File Coverage

blib/lib/Data/Localize/Namespace.pm

Criterion	Covered	Total	%
statement	57	62	91.9
branch	10	14	71.4
condition	2	3	66.6
subroutine	9	9	100.0
pod	3	3	100.0
total	81	91	89.0

package Data::Localize::Namespace;
use Moo;
use Module::Pluggable::Object;
use Encode ();
use Data::Localize;

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

extends 'Data::Localize::Localizer';

has _namespaces => (
    is => 'rw',
    default => sub { [] },
    init_arg => 'namespaces',
);

has _loaded_classes => (
    is => 'ro',
    default => sub { +{} }
);

has _failed_classes => (
    is => 'ro',
    default => sub { +{} }
);

around register => sub {
    my ($next, $self, $loc) = @_;

    $self->$next($loc);
    my $finder = Module::Pluggable::Object->new(
        'require' => 1,
        search_path => [ $self->namespaces ]
    );

    # find the languages that we currently support
    my $re = join('|', $self->namespaces);
    foreach my $plugin ($finder->plugins) {
        $plugin =~ s/^(?:$re):://;
        $plugin =~ s/::/_/g;
        if (Data::Localize::DEBUG) {
            debugf("register - Registering for language %s -> $self",
                $plugin,
                $self
            );
        }
        $loc->add_localizer_map($plugin, $self);
    }
    $loc->add_localizer_map('*', $self);
};

sub add_namespaces {
    my $self = shift;
    unshift @{ $self->_namespaces }, @_;
}

sub namespaces {
    my $self = shift;
    return @{ $self->_namespaces };
}

sub get_lexicon {
    my ($self, $lang, $id) = @_;

    $lang =~ s/-/_/g;

    my $LOADED = $self->_loaded_classes;
    my $FAILED = $self->_failed_classes;
    foreach my $namespace ($self->namespaces) {
        my $klass = "$namespace\::$lang";

        if ($FAILED->{ $klass }) {
            if (Data::Localize::DEBUG) {
                debugf("get_lexicon - Already attempted loading %s and failed. Skipping...", $klass);
            }
            next;
        }

        if (Data::Localize::DEBUG) {
            debugf("get_lexicon - Trying %s", $klass);
        }

        # Catch the very weird case where is_class_loaded() returns true
        # but the class really hasn't been loaded yet.
        no strict 'refs';
        my $first_load = 0;
        if (! $LOADED->{$klass}) {
            if (%{"$klass\::Lexicon"} && %{"$klass\::"}) {
                if (Data::Localize::DEBUG) {
                    debugf("get_lexicon - class %s already loaded", $klass);
                }
            } else {
                if (Data::Localize::DEBUG) {
                    debugf("get_lexicon - loading %s", $klass);
                }

                my $code =
                    "\n" .
                    "#line " . __LINE__ . ' "' . __FILE__ . '"' . "\n" .
                    "require $klass;"
                ;
                eval($code);
                if ($@) {
                    if (Data::Localize::DEBUG) {
                        debugf("get_lexicon - Failed to load %s: %s", $klass, $@);
                        $FAILED->{$klass}++;
                    }
                    next;
                }
            }
            if (Data::Localize::DEBUG) {
                debugf("get_lexicon - setting %s to already loaded", $klass);
            }
            $LOADED->{$klass}++;
            $first_load = 1;
        }

        if (Data::Localize::DEBUG) {
            debugf("get_lexicon - returning lexicon from %s (%d lexicons)",
                $klass,
                scalar keys %{"$klass\::Lexicon"},
            );
        }
        my $h = \%{ "$klass\::Lexicon" };
        if ($first_load) {
            my %t;
            while (my($k, $v) = each %$h) {
                if ( ! Encode::is_utf8($k) ) {
                    $k = Encode::decode_utf8($k);
                }
                if ( ! Encode::is_utf8($v) ) {
                    $v = Encode::decode_utf8($v);
                }
                $t{$k} = $v;
            }
            %$h = ();
            %$h = %t;
        }
        return $h->{$id};

    }
    return ();
}

1;

__END__