File Coverage

blib/lib/Religion/Bible/Regex/Versification.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package Religion::Bible::Regex::Versification;

use warnings;
use strict;
use Carp;

use Religion::Bible::Regex::Reference;

use version; our $VERSION = '0.2';

# There are four way to initialize a versification map
# 1. Pass in a string representing the location of a versification file
# 2. Pass in an array of verse pairs. Ex. [['Ge 1:1', 'Ge 1:2']]
# 3. Pass in a hash of vers pairs. Ex. { 'Ge 1:1' => 'Ge 1:2' }
# 4. Put the versification map in the YAML configuration file
sub new {
    my ($class, $config, $regex, $versification_file) = @_;
    my ($self) = {};
    bless $self, $class;

    $self->{config} = $config or confess 'Versification requires a Religion::Bible::Regex::Config object';
    $self->{regex} = $regex   or confess 'Versification requires a Religion::Bible::Regex::Builder object';

    # is the versification map defined in the config object?
    if (defined($config->get_versification_configurations)) {
	# Build the versification map from the configuration object
	$self->{versification} = $self->normalize_map( $config->get_versification_configurations );

    # does $versification_file exist?
    } elsif (-e $versification_file) {
	# Build the versification map from a file
	$self->{versification} = $self->normalize_map( $self->parse_versification_map($versification_file) );

    # if $versification_file is an array or hash
    } elsif (ref($versification_file) eq 'HASH' || ref($versification_file) eq 'ARRAY') {
	$self->{versification} = $self->normalize_map( $versification_file );
    }

    return $self;
}

# Subroutines related to getting information
sub get_regexes {
  my $self = shift;
  confess "regex is not defined\n" unless defined($self->{regex});
  return $self->{regex};
}

# Returns a reference to a Religion::Bible::Regex::Config object.
sub get_configuration {
  my $self = shift;
  confess "config is not defined\n" unless defined($self->{config});
  return $self->{config};
}

sub parse_versification_map {
    my $self = shift;
    my $config = $self->{config};
    my $map = shift;
    my $r1 = new Religion::Bible::Regex::Reference($self->get_configuration, $self->get_regexes);
    my @versification_array;

    croak "Versification mapping is not defined\n" unless (defined($map));

    if (-e $map) {
	open(my ($list), "<:encoding(UTF-8)", $self->{file}) || croak "Could not open versification mapping file, \'$self->{file})\': $!\n";

	while (<$list>) {
	    chomp;                  # no newline
	    s/[^\\]#.*//;           # no comments si il y a un '\' devant le '#' il n'est pas un commentarie
	    s/^\s+//;               # no leading white
	    s/\s+$//;               # no trailing white
	    next unless length;     # anything left?

	    my ($key, $value) = split /,/;
	    push @versification_array, [$key, $value];
	}
	close ($list);
    }

    return @versification_array;
}


sub normalize_map {
    my $self = shift;
    my $map = shift;
    my %versification_map;

    # Create a reusable Reference Object
    my $r1 = new Religion::Bible::Regex::Reference($self->get_configuration, $self->get_regexes);

    # versification_file is an array ... normalize it.
    if ( ref($map) eq 'ARRAY' ) {
	foreach my $c (@{$map}) {
	    my $r2 = new Religion::Bible::Regex::Reference($self->get_configuration, $self->get_regexes);
	    $r1->parse($c->[0]);
	    $r2->parse($c->[1]);
	    $versification_map{ $r1->normalize } = $r2;
	}

    # versification_file is an array ... normalize it.
    } elsif ( ref($map) eq 'HASH' ) {
	while ( my ($key, $value) = each(%$map) ) {
	    my $r2 = new Religion::Bible::Regex::Reference($self->get_configuration, $self->get_regexes);
	    $r1->parse($key);
	    $r2->parse($value);
	    $versification_map{ $r1->normalize } = $r2;
	}

    # carp
    } else {
	carp "versification_map must be either an array or a hash\n"
	    unless (ref($map) eq 'HASH' || ref($map) eq 'ARRAY');
    }

    # if map is not a HASH or an ARRAY then an empty hash is returned
    return \%versification_map;
}

sub decalage {
    my $self = shift;
    my $reference = shift;

    # Versification can only be done for references with a book, chapter and verse
    return $reference unless ($reference->is_explicit);

    # Since the versification files that we have only contain LCV style references
    # If we have a references like Ps 3:1-9, where Ps 3:1 is not shifted, but Ps 3:9 is shifted
    # then we must break it apart into Ps 3:1 and Ps 3:9, shift both references and recombine them
    if ($reference->has_interval) {
        my $r1 = $reference->begin_interval_reference;
        my $r2 = $reference->end_interval_reference;

        my $dref1 = $self->decalage($r1);
        my $dref2 = $self->decalage($r2);

        return $dref1->interval($dref2);
    } else {
	my $normalized_reference = $reference->normalize;
        if (defined($self->{versification}->{$normalized_reference})) {
            my $ref_decale = new Religion::Bible::Regex::Reference($self->get_configuration, $self->get_regexes);

            # Be sure to make a copy of the reference, otherwise changing the reference later would
            # in the versification map
            $ref_decale->{reference} = &Storable::dclone($self->{versification}->{$normalized_reference}->{reference});
            $ref_decale->set_b($reference->ob);
            $ref_decale->set_b2($reference->ob2);
            return $ref_decale;
        }
    }
    return $reference;
}

1; # Magic true value required at end of module
__END__