root/lang/perl/FormValidator-LazyWay/branches/rebuild/lib/FormValidator/LazyWay/Message.pm @ 13760

package FormValidator::LazyWay::Message;

use Moose;
use Data::Dumper;
use Carp;
use UNIVERSAL::require;

has rule         => ( is => 'ro', isa => 'FormValidator::LazyWay::Rule' );
has config       => ( is => 'ro', isa => 'HashRef' );
has alias        => ( is => 'ro', isa => 'HashRef' );
has lang         => ( is => 'ro' );
has langs        => ( is => 'ro', isa => 'ArrayRef' );
has rule_message => ( is => 'ro', isa => 'HashRef' );

sub BUILD {
    my $self = shift;
    $self->_set_lang();
    $self->{rule_message} = $self->_finalize_rule_message( $self->_load_rule_message() );
}

sub _finalize_rule_message {
    my $self = shift;
    my $rule_message = shift;

    my $message_storage = {};
    foreach my $lang ( @{ $self->langs } ) {
        foreach my $level ( keys %{ $self->rule->constraints } ) {
            foreach my $field ( keys %{ $self->rule->constraints->{$level} } ) {
                for my $item ( @{ $self->rule->constraints->{$level}{$field} } ){
                    my $message =  $rule_message->{$lang}{ $item->{label} };
                                foreach my $key ( keys %{$item->{args}}) {
                                    my $regexp = '\$_\[' . $key . '\]';
                                    my $value  = $item->{args}{$key};
                                    $message =~ s/$regexp/$value/g;
                                }
                    $message_storage->{$lang}{$level}{$field}{$item->{label}} = $message;
                }
            }
        }
    }

    return $message_storage;
}

sub get {
    my $self = shift;
    my $params = shift;
    return $self->message_storage->{$params->{lang}}{$params->{level}}{$params->{field}}{$params->{label}} ;
}

sub _set_lang {
    my $self = shift;
    $self->{lang}  = $self->config->{lang}  || 'en';
    $self->{langs} = $self->config->{langs} || [ $self->lang ];
}

sub _load_rule_message {
    my $self = shift;

    my @subs = (
        sub { $self->_load_from_config(@_) },
        sub { $self->_load_from_rule(@_) },
        sub { $self->_loading_error(@_) },
    );

    my %message = ();
LANG:
    for my $lang ( @{ $self->langs } ) {
        $self->_loading_modules($lang);
    LABEL:
        foreach my $label ( keys %{ $self->rule->labels } ) {
        MESSAGE:
            for my $sub (@subs) {
                my $message = $sub->( $lang, $label, $self->rule->labels->{$label} );
                $message{$lang}{$label} = $message;
                last MESSAGE if $message;
            }
        }
    }
    return \%message;
}

sub _loading_modules {
    my $self = shift;
    my $lang = shift;
    for my $module ( @{ $self->rule->modules } ) {
        my $package = $module . '::' . uc $lang;
        $package->require;
    }
}

sub _loading_error {
    my $self  = shift;
    my $lang  = shift;
    my $label = shift;
    croak sprintf( "You neet to have rule message for lang:%s label:%s",
        $lang, $label );
    return;
}

sub _load_from_config {
    my $self  = shift;
    my $lang  = shift;
    my $label = shift;

    my $config = $self->config->{messages};
    return $config->{$lang}{rule}{$label} if $config->{$lang}{rule}{$label};

    my $alias = $self->rule->labels->{$label}{alias};
    return unless $alias;
    return $config->{$lang}{rule}{$alias} if $config->{$lang}{rule}{$alias};

    return;

}

sub _load_from_rule {
    my $self         = shift;
    my $lang         = shift;
    my $label        = shift;
    my $package_info = shift;
    my $package      = $package_info->{package} . '::' . uc $lang;
    my $method       = $package . '::' . $package_info->{method};

    my $message;
    no strict 'refs';
    eval { $message = $method->(); };

    return $message;
}

1;