File Coverage

blib/lib/Mojolicious/Command/generate/lexicont.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

package Mojolicious::Command::generate::lexicont;
use 5.008005;
use strict;
use warnings;
use Mojo::Base 'Mojolicious::Command';
use Lingua::Translate;
use Config::PL;
use Carp;
use Encode qw/decode/;

__PACKAGE__->attr(description => <<'EOF');
Generate lexicon file translations.
EOF

__PACKAGE__->attr(usage => <<"EOF");
usage: APPLICATION generate lexicont src_lang dest_lang ...
EOF

__PACKAGE__->attr('conf_file');
__PACKAGE__->attr('conf');

our $VERSION = "0.03";


sub run {
    my $self      = shift;

    my $arg_num = @_;

    if ($arg_num < 2){
        croak $self->usage;
    }

    my $src_lang  = shift;

    my $app;
    if (ref $self->app eq 'CODE'){
        $app = $self->app->();
    }
    else{
        $app = $self->app;
    }
    my $app_class = ref $app;
    $app_class =~ s{::}{/}g;
    my $app_klass = ref $app;

    my $verbose;

    my @dest_langs = @_;

    my $src_file = $app->home->rel_file("lib/$app_class/I18N/${src_lang}.pm");
    my $org_file = $app->home->rel_file("lib/$app_class/I18N/org.pm");

    if ( ! -e $org_file && ! -e $src_file) {
        croak <
Src lexicon not found $src_file
NOTFOUND
    }

    my %srclex = ();

    if (-e $src_file){
        %srclex = eval {
            require "$app_class/I18N/${src_lang}.pm";
            no strict 'refs';
            %{*{"${app_klass}::I18N::${src_lang}::Lexicon"}};
        };
        if ($@){
            croak( "error $@" );
        }
    }

    my $conf_file = $self->conf_file || "lexicont.conf";
    my $conf;
    eval{
        $conf = config_do $conf_file;
    };
    if ($@){
        croak "Config file cannot read $@ ($conf_file)"
    }

    $self->conf($conf);

    if (-e $org_file) {

        my %orglex = eval {
            require "$app_class/I18N/org.pm";
            no strict 'refs';
            %{*{"${app_klass}::I18N::org::Lexicon"}};
        };
        if ($@){
            croak( "error $@" );
        }

        my %changes = ();

        for my $key (%orglex){
            if ( defined $srclex{$key} && ($orglex{$key} ne $srclex{$key})){
                $changes{$key} = 1;
            }
        }

        for my $dest_lang (@dest_langs){

            my $dest_file = $app->home->rel_file("lib/$app_class/I18N/${dest_lang}.pm");

            my %destlex = ();
            if ( -e $dest_file){
                %destlex = eval {
                    require "$app_class/I18N/${dest_lang}.pm";
                    no strict 'refs';
                    %{*{"${app_klass}::I18N::${dest_lang}::Lexicon"}};
                };
                if ($@){
                    croak( "error $@" );
                }
            }

            my %lexicon = ();

            for my $key (keys %orglex){
                if ( ! defined $srclex{$key} || (defined $changes{$key} && $changes{$key} == 1)){
                    $lexicon{$key} = $self->translate( $src_lang, $dest_lang, $orglex{$key});
                }
                else{
                    $lexicon{$key} = $destlex{$key};
                }
            }

            # Output lexem
            $self->render_to_file('package', $dest_file, $app_klass, $dest_lang,
                \%lexicon);

            if ( defined $conf->{json} && $conf->{json} == 1 ){
                my $dest_json = $app->home->rel_file("public/${dest_lang}.json");

                # Output json
                $self->render_to_file('json', $dest_json, $app_klass, $dest_lang,
                    \%lexicon);
            }

        }

        my %utf8_orglex = map { $_ => (utf8::is_utf8 ($orglex{$_})) ? $orglex{$_} : decode("utf8", $orglex{$_})} keys %orglex;
        my $src_file = $app->home->rel_file("lib/$app_class/I18N/${src_lang}.pm");
        $self->render_to_file('package', $src_file, $app_klass, $src_lang,
                \%utf8_orglex);

        if ( defined $conf->{json} && $conf->{json} == 1 ){

            my $dest_json = $app->home->rel_file("public/${src_lang}.json");

            # Output json
            $self->render_to_file('json', $dest_json, $app_klass, $src_lang,
                \%utf8_orglex);

        }

    }
    else{

        for my $dest_lang (@dest_langs){

            my $dest_file = $app->home->rel_file("lib/$app_class/I18N/${dest_lang}.pm");

            my %lexicon = map { $_ => $self->translate( $src_lang, $dest_lang, $srclex{$_}) } keys %srclex;

            # Output lexem
            $self->render_to_file('package', $dest_file, $app_klass, $dest_lang,
                \%lexicon);

            if ( defined $conf->{json} && $conf->{json} == 1 ){

                my $dest_json = $app->home->rel_file("public/${dest_lang}.json");

                # Output json
                $self->render_to_file('json', $dest_json, $app_klass, $dest_lang,
                    \%lexicon);
            }

        }

        if ( defined $conf->{json} && $conf->{json} == 1 ){

            my $dest_json = $app->home->rel_file("public/${src_lang}.json");

            my %utf8_srclex = map { $_ => (utf8::is_utf8 ($srclex{$_})) ? $srclex{$_} : decode("utf8", $srclex{$_})} keys %srclex;

            # Output json
            $self->render_to_file('json', $dest_json, $app_klass, $src_lang,
                \%utf8_srclex);

        }

    }

}

sub translate{

    my $self = shift;
    my $src = shift;
    my $dest = shift;
    my $text = shift;

    my $xl8r;

    eval{
        $xl8r  = Lingua::Translate->new(%{$self->conf->{lingua_translate}}, src => $src, dest => $dest);
    };
    if ($@){
        croak "Lingua::Translate create error $@";
    }

    my $trans_text = '';

    eval{
        $trans_text = $xl8r->translate($text);
        if (defined $self->conf->{sleep}){
            sleep( $self->conf->{sleep} );
        }
    };
    if ($@){
        warn ("Cannot translate $@");
    }
    return $trans_text;

}

1;

__DATA__