File Coverage

blib/lib/Data/Localize.pm

Criterion	Covered	Total	%
statement	103	121	85.1
branch	19	30	63.3
condition	7	14	50.0
subroutine	23	28	82.1
pod	15	16	93.7
total	167	209	79.9

package Data::Localize;
use Moo;
use Module::Load ();
use Scalar::Util ();
use I18N::LangTags ();
use I18N::LangTags::Detect ();
use 5.008;

our $VERSION = '0.00028';
our $AUTHORITY = 'cpan:DMAKI';

BEGIN {
    if (! defined &DEBUG) {
        require constant;
        constant->import(DEBUG => !!$ENV{DATA_LOCALIZE_DEBUG});
    }
}

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

has auto => (
    is => 'rw',
    default => sub { 1 },
);

has auto_localizer => (
    is => 'rw',
    lazy => 1,
    builder => "_build_auto_localizer",
    isa => sub { $_[0]->isa('Data::Localize::Auto') },
);

has _languages => (
    is => 'rw',
    lazy => 1,
    builder => "_build__languages",
    init_arg => 'languages',
);

has _fallback_languages => (
    is => 'rw',
    lazy => 1,
    builder => "_build__fallback_languages",
    init_arg => 'fallback_languages',
);

has _localizers => (
    is => 'rw',
    coerce => sub {
        if (ref $_[0] ne 'ARRAY') {
            Carp::croak("localizer list must be a list of Localizer objects");
        }

        # XXX Want to deprecate this auto-instantiation
        foreach my $args (@{$_[0]}) {
            if (Scalar::Util::blessed($args)) {
                next;
            }

            my $klass = delete $args->{class};
            if (! $klass) {
                Carp::croak("No class provided for localizer list");
            }
            if ($klass !~ s/^\+//) {
                $klass = "Data::Localize::$klass";
            }
            Module::Load::load($klass);
            $args = $klass->new(%$args);
        }
        $_[0];
    },
    default => sub { +[] },
    init_arg => 'localizers',
);

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

sub BUILD {
    my $self = shift;

    if ($self->count_localizers > 0) {
        foreach my $loc (@{ $self->_localizers }) {
            $loc->register($self);
        }
    }
    return $self;
}

sub _build__fallback_languages {
    return [ 'en' ];
}

sub _build__languages {
    my $self = shift;
    $self->detect_languages();
}

sub _build_auto_localizer {
    my $self = shift;
    require Data::Localize::Auto;
    Data::Localize::Auto->new();
}

sub set_languages {
    my $self = shift;
    $self->_languages([ @_ > 0 ? @_ : $self->detect_languages ]);
};


sub add_fallback_languages {
    my $self = shift;
    push @{$self->_fallback_languages}, @_;
}

sub fallback_languages {
    my $self = shift;
    return @{$self->_fallback_languages};
}

sub languages {
    my $self = shift;
    return @{$self->_languages};
}

sub localizers {
    my $self = shift;
    return $self->_localizers;
}

sub count_localizers {
    my $self = shift;
    return scalar @{$self->_localizers};
}

sub grep_localizers {
    my ($self, $cb) = @_;
    grep { $cb->($_) } @{$self->_localizers};
}

sub get_localizer_from_lang {
    my ($self, $key) = @_;
    return $self->localizer_map->{$key};
}

sub set_localizer_map {
    my ($self, $key, $value) = @_;
    return $self->localizer_map->{$key} = $value;
}

sub detect_languages {
    my $self = shift;
    my @lang = I18N::LangTags::implicate_supers(
        I18N::LangTags::Detect::detect() ||
        $self->fallback_languages,
    );
    if (DEBUG) {
        local $Log::Minimal::AUTODUMP = 1;
        debugf("detect_languages: auto-detected %s", \@lang);;
    }
    return wantarray ? @lang : \@lang;
}

sub detect_languages_from_header {
    my $self = shift;
    my @lang = I18N::LangTags::implicate_supers(
        I18N::LangTags::Detect->http_accept_langs( $_[0] || $ENV{HTTP_ACCEPT_LANGUAGE}),
        $self->fallback_languages,
    );
    if (DEBUG) {
        local $Log::Minimal::AUTODUMP = 1;
        debugf("detect_languages_from_header detected %s", \@lang);
    }
    return wantarray ? @lang : \@lang;
}

sub localize {
    my ($self, $key, @args) = @_;

    if (DEBUG) {
        debugf("localize - Looking up key '%s'", $key);
    }
    my @languages = $self->languages ;
    if (DEBUG) {
        local $Log::Minimal::AUTODUMP = 1;
        debugf("localize - Loaded languages %s", \@languages);
    }
    foreach my $lang (@languages) {
        if (DEBUG) {
            debugf("localize - Attempting language '%s'", $lang);
        }
        my $localizers = $self->get_localizer_from_lang($lang) || [];
        if (DEBUG) {
            debugf("localize - Loaded %d localizers for lang %s",
                scalar @$localizers,
                $lang
            );
        }
        foreach my $localizer (@$localizers) {
            if (DEBUG) {
                local $Log::Minimal::AUTODUMP = 1;
                debugf("localize - Trying with %s", $localizer);
            }
            my $out = $localizer->localize_for(
                lang => $lang,
                id => $key,
                args => \@args
            );

            if ($out) {
                if (DEBUG) {
                    debugf("localize - Got localization: '%s'", $out);
                }
                return $out;
            }
        }
    }

    if (DEBUG) {
        debugf("localize - nothing found in registered languages");
    }

    # if we got here, we missed on all languages.
    # one last shot. try the '*' slot
    foreach my $localizer (@{$self->get_localizer_from_lang('*') || []}) {
        foreach my $lang ($self->languages) {
            if (DEBUG) {
                debugf("localize - trying %s for '*' with localizer %s",
                    $lang,
                    $localizer
                );
            }
            my $out = $localizer->localize_for(
                lang => $lang,
                id   => $key,
                args => \@args
            );
            if ($out) {
                if (DEBUG) {
                    debugf("localize - found for %s, adding to map", $lang);
                }

                # oh, found one? set it in the localizer map so we don't have
                # to look it up again
                $self->add_localizer_map($lang, $localizer);
                return $out;
            }
        }
    }

    # if you got here, and you /still/ can't find a proper localization,
    # then we fallback to 'auto' feature
    if ($self->auto) {
        if (DEBUG) {
            debugf("localize - trying auto-lexicon for '%s'", $key);
        }
        return $self->auto_localizer->localize_for(id => $key, args => \@args);
    }

    return ();
}

sub add_localizer {
    my $self = shift;

    my $localizer;
    if (@_ == 1) {
        $localizer = $_[0];
    } else {
        my %args = @_;

        my $klass = delete $args{class};
        if ($klass !~ s/^\+//) {
            $klass = "Data::Localize::$klass";
        }
        Module::Load::load($klass);
        if (Data::Localize::DEBUG) {
            local $Log::Minimal::AUTODUMP = 1;
            debugf("Creating localizer '%s' (%s)", $klass, \%args);
        }
        $localizer = $klass->new(%args);
    }

    if (! $localizer || ! Scalar::Util::blessed($localizer) || ! $localizer->isa( 'Data::Localize::Localizer' ) ) {
        Carp::confess("Bad localizer: '" . ( defined $localizer ? $localizer : '(null)' ) . "'");
    }

    if (DEBUG()) {
        debugf("add_localizer: %s", $localizer);
    }
    $localizer->register($self);
    push @{ $self->_localizers }, $localizer;
}

sub find_localizers {
    my ($self, %args) = @_;

    if (my $isa = $args{isa}) {
        return $self->grep_localizers(sub { $_[0]->isa($isa) });
    }
}

sub add_localizer_map {
    my ($self, $lang, $localizer) = @_;

    if (DEBUG) {
        debugf("add_localizer_map %s -> %s", $lang, $localizer);
    }
    my $list = $self->get_localizer_from_lang($lang);
    if (! $list) {
        $list = [];
        $self->set_localizer_map($lang, $list);
    }
    unshift @$list, $localizer;
}

1;

__END__