File Coverage

blib/lib/Locale/TextDomain/OO/Singleton/Lexicon.pm

Criterion	Covered	Total	%
statement	49	49	100.0
branch	16	32	50.0
condition			n/a
subroutine	10	10	100.0
pod	4	4	100.0
total	79	95	83.1

package Locale::TextDomain::OO::Singleton::Lexicon; ## no critic (TidyCode)

use strict;
use warnings;
use Carp qw(confess);
use Moo;
use MooX::StrictConstructor;
use namespace::autoclean;

our $VERSION = '1.031';

with qw(
    Locale::TextDomain::OO::Role::Logger
    MooX::Singleton
);

has data => (
    is       => 'ro',
    init_arg => undef,
    default  => sub {
        my $self = shift;
        return {
            # empty lexicon of developer English
            'i-default::' => {
                q{} => {
                    nplurals    => 2,
                    plural      => 'n != 1',
                    plural_code => sub { return shift != 1 },
                },
            },
        };
    },
);

sub merge_lexicon {
    my ( $self, $from1, $from2, $to ) = @_;
    defined $from1
        or confess 'Undef is not a lexicon name to merge from';
    defined $from2
        or confess 'Undef is not a lexicon name to merge from';
    exists $self->data->{$from1}
        or confess qq{Missing lexicon "$from1" to merge from};
    exists $self->data->{$from2}
        or confess qq{Missing lexicon "$from2" to merge from};
    defined $to
        or confess 'Undef is not a lexicon name to merge to';

    $self->data->{$to} = {
        %{ $self->data->{$from1} },
        %{ $self->data->{$from2} },
    };
    $self->logger and $self->logger->(
        qq{Lexicon "$from1", "$from2" merged to "$to".},
        {
            object => $self,
            type   => 'debug',
            event  => 'lexicon,merge',
        },
    );

    return $self;
}

sub copy_lexicon {
    my ( $self, $from, $to ) = @_;

    defined $from
        or confess 'Undef is not a lexicon name to copy from';
    exists $self->data->{$from}
        or confess qq{Missing lexicon "$from" to copy from};
    defined $to
        or confess 'Undef is not a lexicon name to copy to';

    $self->data->{$to} = {
        %{ $self->data->{$from} },
    };
    $self->logger and $self->logger->(
        qq{Lexicon "$from" copied to "$to".},
        {
            object => $self,
            type   => 'debug',
            event  => 'lexicon,copy',
        },
    );

    return $self;

}

sub move_lexicon {
    my ( $self, $from, $to ) = @_;

    defined $from
        or confess 'Undef is not a lexicon name to move from';
    exists $self->data->{$from}
        or confess qq{Missing lexicon "$from" to move from};
    defined $to
        or confess 'Undef is not a lexicon name to move to';
    $self->data->{$to} = delete $self->data->{$from};
    $self->logger and $self->logger->(
        qq{Lexicon "$from" moved to "$to".},
        {
            object => $self,
            type   => 'debug',
            event  => 'lexicon,move',
        },
    );

    return $self;
}

sub delete_lexicon {
    my ( $self, $name ) = @_;

    defined $name
        or confess 'Undef is not a lexicon name to delete';
    my $deleted = delete $self->data->{$name};
    $self->logger and $self->logger->(
        qq{Lexicon "$name" deleted.},
        {
            object => $self,
            type   => 'debug',
            event  => 'lexicon,delete',
        },
    );

    return $deleted;
}

__PACKAGE__->meta->make_immutable;

1;

__END__