File Coverage

blib/lib/Locale/TextDomain/OO/Plugin/Expand/Gettext/Named.pm

Criterion	Covered	Total	%
statement	40	44	90.9
branch	19	26	73.0
condition	2	3	66.6
subroutine	9	11	81.8
pod	2	2	100.0
total	72	86	83.7

package Locale::TextDomain::OO::Plugin::Expand::Gettext::Named; ## no critic (TidyCode)

use strict;
use warnings;
use Carp qw(cluck confess);
use Hash::Util qw(lock_keys);
use Locale::Utils::PlaceholderNamed;
use Moo::Role;
use Try::Tiny;

our $VERSION = '1.027';

requires qw(
    translate
    filter
    run_filter
    category
    domain
);

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

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

has expand_gettext_named => (
    is      => 'rw',
    default => sub {
        return Locale::Utils::PlaceholderNamed->new;
    },
);

my $begin_d = sub {
    my ($self, $domain) = @_;

    defined $domain
        or confess 'Domain is not defined';
    push
        @{ $self->_shadow_domains_named },
        $self->domain;
    $self->domain($domain);

    return $self;
};

my $begin_c = sub {
    my ($self, $category) = @_;

    defined $category
        or confess 'Category is not defined';
    push
        @{ $self->_shadow_categories_named },
        $self->category;
    $self->category($category);

    return $self;
};

my $end_d = sub {
    my $self = shift;

    if ( ! @{ $self->_shadow_domains_named } ) {
        cluck 'Tried to get the domain from stack but no domain is not stored';
        return $self;
    }
    $self->domain( pop @{ $self->_shadow_domains_named } );

    return $self;
};

my $end_c = sub {
    my $self = shift;

    if ( ! @{ $self->_shadow_categories_named } ) {
        cluck 'Tried to get the category from stack but no category is stored',
        return $self;
    }
    $self->category( pop @{ $self->_shadow_categories_named } );

    return $self;
};

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

    my $arg_ref = ref $args[0] eq 'HASH' ? $args[0] : { @args };
    try {
        lock_keys( %{$arg_ref}, qw( category domain context text plural replace ) );
        exists $arg_ref->{plural}
            or return;
        lock_keys( %{ $arg_ref->{plural} }, qw( singular plural count ) );
    }
    catch {
        confess $_;
    };

    $arg_ref->{domain}
        and $self->$begin_d( $arg_ref->{domain} );
    $arg_ref->{category}
        and $self->$begin_c( $arg_ref->{category} );
    my $translation
        = exists $arg_ref->{text}
        ? $self->translate(
            @{$arg_ref}{ qw( context text ) },
        )
        : exists $arg_ref->{plural}
        ? $self->translate(
            $arg_ref->{context},
            @{ $arg_ref->{plural} }{ qw( singular plural count ) },
            1,
        )
        : q{};
    $arg_ref->{replace}
        and $translation = $self->expand_gettext_named->expand_named(
            $translation,
            $arg_ref->{replace},
        );
    $self->filter
        and $self->run_filter(\$translation);
    if ( exists $arg_ref->{text} || exists $arg_ref->{plural} ) {
        $arg_ref->{domain}
            and $self->$end_d;
        $arg_ref->{category}
            and $self->$end_c;
    }

    return $translation;
}

sub Nlocn { ## no critic (Capitalization)
    my (undef, @args) = @_;

    my $arg_ref = ref $args[0] eq 'HASH' ? $args[0] : { @args };

    return wantarray ? @args : $args[0];
}

1;

__END__