File Coverage

blib/lib/Mojolicious/Plugin/LocaleTextDomainOO.pm

Criterion	Covered	Total	%
statement	51	82	62.2
branch	1	18	5.5
condition	8	29	27.5
subroutine	11	19	57.8
pod	1	1	100.0
total	72	149	48.3

package Mojolicious::Plugin::LocaleTextDomainOO;
use Mojo::Base 'Mojolicious::Plugin';

use Locale::TextDomain::OO;
use Locale::TextDomain::OO::Lexicon::File::PO;
use Locale::TextDomain::OO::Lexicon::File::MO;
use I18N::LangTags;
use I18N::LangTags::Detect;

use constant DEBUG => $ENV{MOJO_I18N_DEBUG} || 0;

our $VERSION = '0.04';

has 'po' => sub { Locale::TextDomain::OO::Lexicon::File::PO->new };
has 'mo' => sub { Locale::TextDomain::OO::Lexicon::File::MO->new };

my $plugins_default = [
    qw/
      Expand::Gettext::DomainAndCategory
      Language::LanguageOfLanguages
      /
];

sub register {
    my ( $plugin, $app, $plugin_config ) = @_;

    # Initialize
    my $file_type = $plugin_config->{file_type} || 'po';
    my $default   = $plugin_config->{default}   || 'en';
    $default =~ tr/-A-Z/_a-z/;
    $default =~ tr/_a-z0-9//cd;
    my $languages = $plugin_config->{languages} // [$default];

    my $plugins = $plugins_default;
    push @$plugins, @{ $plugin_config->{plugins} }
      if ( ref $plugin_config->{plugins} eq 'ARRAY' );

    my $logger = sub { };
    $logger = sub {
        my ( $message, $arg_ref ) = @_;
        my $type = $arg_ref->{type} || 'debug';
        $app->log->$type($message);
        return;
      }
      if DEBUG;

    # Default Handler
    my $loc = sub {
        Locale::TextDomain::OO->instance(
            plugins   => $plugins,
            languages => $languages,
            logger    => $logger,
        );
    };

    # Add hook and replace url_for helper
    $Mojolicious::Plugin::LocaleTextDomainOO::I18N::code->(
        $app, $plugin_config
    );

    # Add "locale" helper
    $app->helper( locale => $loc );

    # Add "lexicon" helper
    $app->helper(
        lexicon => sub {
            my ( $app, $conf ) = @_;
            $conf->{decode} = $conf->{decode} // 1;    # Default: utf8 flaged
            $plugin->$file_type->lexicon_ref($conf);
        }
    );

    # Add "languages" helper
    $app->helper(
        languages => sub {
            my ( $self, @languages ) = @_;
            unless (@languages) { $self->locale->languages }
            else                { $self->locale->languages( \@languages ) }
        }
    );

    # Add "language" helper
    $app->helper(
        language => sub {
            my ( $self, $language ) = @_;
            unless ($language) { $self->locale->language }
            else               { $self->locale->language($language) }
        }
    );

    # Add helper from gettext methods
    my @methods = (
        qw/
          __  __x  __n  __nx  __p  __px  __np  __npx
          N__  N__x  N__n  N__nx  N__p  N__px  N__np  N__npx
          __d  __dn  __dp  __dnp  __dx  __dnx  __dpx  __dnpx
          N__d  N__dn  N__dp  N__dnp  N__dx  N__dnx  N__dpx  N__dnpx
          /
    );
    foreach my $method (@methods) {
        $app->helper( $method => sub { shift->app->locale->$method(@_) } );
    }

    foreach my $method (qw /__begin_d  __end_d/) {
        $app->helper( $method => sub { shift->app->locale->$method(@_); undef; }
        );
    }
}

#######################################################################
###  This code is Mojolicious::Plugin::I18N
#######################################################################
package Mojolicious::Plugin::LocaleTextDomainOO::I18N;

our $code = sub {
    my ( $app, $conf ) = @_;

    my $langs   = $conf->{support_url_langs};
    my $hosts   = $conf->{support_hosts};
    my $default = $conf->{default} || 'en';
    $default =~ tr/-A-Z/_a-z/;
    $default =~ tr/_a-z0-9//cd;

    # Add hook
    $app->hook(
        before_dispatch => sub {
            my $self = shift;

            # Header detection
            my @languages =
              $conf->{no_header_detect}
              ? ()
              : I18N::LangTags::implicate_supers(
                I18N::LangTags::Detect->http_accept_langs(
                    $self->req->headers->accept_language
                )
              );

            # Host detection
            my $host = $self->req->headers->header('X-Host')
              || $self->req->headers->host;
            if ( $conf->{support_hosts} && $host ) {
                warn $host;
                $host =~ s/^www\.//;    # hack
                if ( my $lang = $conf->{support_hosts}->{$host} ) {
                    $self->app->log->debug(
                        "Found language $lang, Host header is $host");

                    unshift @languages, $lang;
                }
            }

            # Set default language
            $self->stash( lang_default => $languages[0] ) if $languages[0];

            # URL detection
            if ( my $path = $self->req->url->path ) {
                my $part = $path->parts->[0];

                if ( $part && $langs && grep { $part eq $_ } @$langs ) {

                    # Ignore static files
                    return if $self->res->code;

                    $self->app->log->debug("Found language $part in URL $path");

                    unshift @languages, $part;

                    # Save lang in stash
                    $self->stash( lang => $part );

                    # Clean path
                    shift @{ $path->parts };
                    $path->trailing_slash(0);
                }
            }

            # Languages
            $self->languages( @languages, $default );
        }
    );

    # Reimplement "url_for" helper
    my $mojo_url_for = *Mojolicious::Controller::url_for{CODE};

    my $i18n_url_for = sub {
        my $self = shift;
        my $url  = $self->$mojo_url_for(@_);

        # Absolute URL
        return $url if $url->is_abs;

        # Discard target if present
        shift if ( @_ % 2 && !ref $_[0] ) || ( @_ > 1 && ref $_[-1] );

        # Unveil params
        my %params = @_ == 1 ? %{ $_[0] } : @_;

        # Detect lang
        if ( my $lang = $params{lang} || $self->stash('lang') ) {
            my $path = $url->path || [];

            # Root
            if ( !$path->[0] ) {
                $path->parts( [$lang] );
            }

            # No language detected
            elsif ( ref $langs ne 'ARRAY'
                or not scalar grep { $path->contains("/$_") } @$langs )
            {
                unshift @{ $path->parts }, $lang;
            }
        }

        $url;
    };

    {
        no strict 'refs';
        no warnings 'redefine';

        *Mojolicious::Controller::url_for = $i18n_url_for;
    }
};

1;
__END__