File Coverage

blib/lib/Locale/TextDomain/OO/Lexicon/Role/StoreFilter.pm

Criterion	Covered	Total	%
statement	45	45	100.0
branch	4	4	100.0
condition			n/a
subroutine	12	12	100.0
pod	3	3	100.0
total	64	64	100.0

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

use strict;
use warnings;
use Carp qw(confess);
use Clone qw(clone);
use Locale::TextDomain::OO::Singleton::Lexicon;
use Locale::TextDomain::OO::Util::JoinSplitLexiconKeys;
use Moo::Role;
use MooX::Types::MooseLike::Base qw(HashRef);
use namespace::autoclean;

our $VERSION = '1.017';

for my $name ( qw( language category domain project ) ) {
    has "filter_$name" => (
        is  => 'rw',
        isa => sub {
            my $value = shift;
            defined $value
                or return;
            my $ref = ref $value;
            $ref eq 'Regexp'
                and return;
            $ref eq 'CODE'
                and return;
            $ref
                and confess 'Undef, Str, RegexpRef or CodeRef expected';
        },
    );
}

sub clear_filter {
    my $self = shift;

    $self->filter_language(undef);
    $self->filter_category(undef);
    $self->filter_domain(undef);
    $self->filter_project(undef);

    return $self;
};

has data => (
    is      => 'ro',
    isa     => HashRef,
    lazy    => 1,
    default => sub { {} },
);

my $is_expected_lexicon_key = sub {
    my ( $self, $lexicon_key ) = @_;

    my $key_ref = Locale::TextDomain::OO::Util::JoinSplitLexiconKeys
        ->instance
        ->split_lexicon_key($lexicon_key);
    NAME:
    for my $name ( qw( language category domain project ) ) {
        defined $key_ref->{$name}
            or $key_ref->{$name} = q{};
        my $method = "filter_$name";
        my $filter = $self->$method;
        if ( defined $filter ) {
            local $_ = $key_ref->{$name};
            my $ref = ref $filter;
            $ref eq 'Regexp'
                ? $_ =~ $filter
                : $ref eq 'CODE'
                ? $filter->($method)
                : $_ eq $filter
                or return;
        }
    }

    return 1;
};

my $prepare_lexicon = sub {
    my ( $self, $lexicon_ref ) = @_;

    $lexicon_ref = clone($lexicon_ref);

    # not able to serialize code references
    delete $lexicon_ref->{ q{} }->{plural_code};

    my $key_util = Locale::TextDomain::OO::Util::JoinSplitLexiconKeys->instance;
    MESSAGE_KEY:
    for my $message_key ( keys %{$lexicon_ref} ) {
        length $message_key
            or next MESSAGE_KEY;
        my $new_message_key = $key_util->join_message_key(
            $key_util->split_message_key($message_key),
            'JSON',
        );
        $lexicon_ref->{$new_message_key} = delete $lexicon_ref->{$message_key};
    }

    return $lexicon_ref;
};

sub copy {
    my $self = shift;

    my $data = Locale::TextDomain::OO::Singleton::Lexicon->instance->data;
    for my $lexicon_key ( keys %{$data} ) {
        $self->$is_expected_lexicon_key($lexicon_key)
            and $self->data->{$lexicon_key}
                = $self->$prepare_lexicon( $data->{$lexicon_key} );
    }

    return $self;
}

sub remove {
    my $self = shift;

    my $data = $self->data;
    for my $lexicon_key ( keys %{$data} ) {
        $self->$is_expected_lexicon_key($lexicon_key)
            and delete $data->{$lexicon_key};
    }

    return $self;
}

1;

__END__