File Coverage

blib/lib/Data/Localize/Gettext.pm

Criterion	Covered	Total	%
statement	52	52	100.0
branch	3	6	50.0
condition	1	2	50.0
subroutine	15	15	100.0
pod	3	4	75.0
total	74	79	93.6

package Data::Localize::Gettext;
use utf8;
use Moo;
use Module::Load ();
use Carp ();
use Data::Localize::Gettext::Parser;
use File::Temp ();
use Data::Localize;
use Data::Localize::Storage::Hash;

BEGIN {
    if (Data::Localize::DEBUG) {
        require Data::Localize::Log;
        Data::Localize::Log->import;
    }
}

extends 'Data::Localize::Localizer';
with 'Data::Localize::Trait::WithStorage';

has encoding => (
    is => 'ro',
    default => sub { 'utf-8' },
);

has paths => (
    is => 'ro',
    trigger => sub {
        my $self = shift;
        if ($self->initialized) {
            $self->load_from_path($_) for @{$_[0]};
        }
    },
);

has use_fuzzy => (
    is => 'ro',
    default => sub { 0 },
);

has keep_empty => (
    is => 'ro',
    default => sub { 0 },
);

has _parser => (
    is => 'rw',
    lazy => 1,
    builder => "_build__parser",
    isa => sub { $_[0]->isa('Data::Localize::Gettext::Parser') },
);

around register => sub {
    my ($next, $self, $loc) = @_;
    $self->$next($loc);
    $loc->add_localizer_map('*', $self);
};

sub _build__parser {
    my $self = shift;
    return Data::Localize::Gettext::Parser->new(
        use_fuzzy  => $self->use_fuzzy(),
        keep_empty => $self->keep_empty(),
        encoding   => $self->encoding(),
    );
}

after BUILD => sub {
    my $self = shift;
    my $paths = $self->paths;
    foreach my $path (@$paths) {
        $self->load_from_path($path);
    }
};

sub BUILDARGS {
    my ($class, %args) = @_;

    my $path = delete $args{path};
    if ($path) {
        $args{paths} ||= [];
        push @{$args{paths}}, $path;
    }
    $class->SUPER::BUILDARGS(%args);
}

sub _build_formatter {
    Module::Load::load( 'Data::Localize::Format::Gettext' );
    return Data::Localize::Format::Gettext->new();
}

sub add_path {
    my $self = shift;
    push @{$self->paths}, @_;
    $self->load_from_path($_) for @_;
}

sub load_from_path {
    my ($self, $path) = @_;

    return unless $path;

    if (Data::Localize::DEBUG) {
        debugf("load_from_path - loading from glob(%s)", $path);
    }

    foreach my $x (glob($path)) {
        $self->load_from_file($x) if -f $x;
    }
}

sub load_from_file {
    my ($self, $file) = @_;

    if (Data::Localize::DEBUG) {
        debugf("load_from_file - loading from file %s", $file);
    }

    my $lexicon = $self->_parser->parse_file($file);

    my $lang = File::Basename::basename($file);
    $lang =~ s/\.[mp]o$//;

    if (Data::Localize::DEBUG) {
        debugf("load_from_file - registering %d keys", scalar keys %{$lexicon});
    }

    # This needs to be merged
    $self->merge_lexicon($lang, $lexicon);
}

1;

__END__