File Coverage

blib/lib/Lingua/RU/Declension.pm

Criterion	Covered	Total	%
statement	73	119	61.3
branch	14	56	25.0
condition	5	11	45.4
subroutine	16	24	66.6
pod	13	13	100.0
total	121	223	54.2

use 5.014;
use utf8;
use strict;
use warnings;

package Lingua::RU::Declension;
$Lingua::RU::Declension::VERSION = '0.006';
use Text::CSV 1.91 qw(csv);
use File::Share qw(dist_file);
use Carp qw(confess);

# ABSTRACT: Decline Russian pronouns, adjectives and nouns



sub new {
    my $class = shift;

    if ( (scalar @_) and (scalar @_ % 2 != 0) ) {
        confess "Expected pairs for initialization values";
    }

    my $self = bless {}, $class;
    return $self->_load(@_);

}

sub _load {
    my $self = shift;



    my %defaults = (
             'nouns' => { 'file' => 'nouns_utf8.csv',
                           'key' => 'nom' },
        'adjectives' => { 'file' => 'adjectives_utf8.csv',
                           'key' => 'masc_nom' },
          'pronouns' => { 'file' => 'pronouns_utf8.csv',
                           'key' => 'masc_nom' },
             'stems' => { 'file' => 'sentence_stems_utf8.csv',
                           'key' => 'case' },
    );

    my %files = (%defaults);

    if ( @_ ) {
        %files = (%defaults, %{@_});
    }

    for my $k ( keys %files ) {
        my $c = $files{$k};
        $self->{$k} = csv(in => dist_file('Lingua-RU-Declension',
                                          $c->{file}),
                          key => $c->{key},
                          encoding => 'UTF-8');
    }

    return $self;
}


sub select_nouns {
    my $self = shift;
    my $code = shift;

    if ( ref($code) ne "CODE" ) {
        confess "Expected second parameter to be a code reference.";
    }

    return grep { $code->($self->{nouns}->{$_}) }
                                         keys %{ $self->{nouns} };
}


sub decline_random_adjective {
    my $self = shift;
    return $self->decline_adjective($self->choose_random_adjective(), @_);
}


sub choose_random_adjective {
    my $self = shift;
    return $self->_choose_random($self->{adjectives})->{masc_nom};
}

sub _choose_random {
    my $self = shift;
    my $h = shift;

    return $h->{(keys %{ $h })[rand keys %{ $h }]};
}


sub decline_adjective {
    my $self = shift;
    my $adj = shift;

    if ( not exists $self->{adjectives}->{$adj} ) {
        confess "Couldn't find adjective '$adj' in my data.";
    }

    my $hk = $self->_select_hash_key(@_);

    return $self->{adjectives}->{$adj}->{$hk};
}


sub choose_random_pronoun {
    my $self = shift;
    return $self->_choose_random($self->{pronouns})->{masc_nom};
}


sub decline_random_pronoun {
    my $self = shift;
    return $self->decline_pronoun($self->choose_random_pronoun(), @_);
}


sub decline_pronoun {
    my $self = shift;
    my $pronoun = shift;

    if ( not exists $self->{pronouns}->{$pronoun} ) {
        confess "Couldn't find pronoun '$pronoun' in my data.";
    }

    my $hk = $self->_select_hash_key(@_);

    return $self->{pronouns}->{$pronoun}->{$hk};
}


sub decline_noun {
    my $self = shift;
    my $noun = shift;
    my $case = shift // 'nom';
    my $is_plural = shift // 0;
    $is_plural = $is_plural eq "plural" ? 1 : 0 ;

    if ( not exists $self->{nouns}->{$noun} ) {
        confess "Couldn't find noun '$noun' in my data.";
    }

    if ( $is_plural ) {
        return $self->{nouns}->{$noun}->{nmp} if $case eq "nom";
        return $self->{nouns}->{$noun}->{acp} if $case eq "acc";
        return $self->{nouns}->{$noun}->{gnp} if $case eq "gen";
        return $self->{nouns}->{$noun}->{dtp} if $case eq "dat";
        return $self->{nouns}->{$noun}->{itp} if $case eq "inst";
        return $self->{nouns}->{$noun}->{prp} if $case eq "prep";
    }
    else {
        return $self->{nouns}->{$noun}->{$case};
    }
}


sub choose_random_noun {
    my $self = shift;
    return $self->_choose_random($self->{nouns})->{nom};
}


sub decline_random_noun {
    my $self = shift;
    return $self->decline_noun($self->choose_random_noun(), @_);
}


sub russian_sentence_stem {
    my $self = shift;
    return $self->_select_sentence_stem(@_)->{rus};
}


sub english_sentence_stem {
    my $self = shift;
    my $h = $self->_select_sentence_stem(@_)->{eng};
}

sub _select_sentence_stem {
    my $self = shift;
    my $case = shift;

    if ( not exists $self->{stems}->{$case} ) {
        confess "Could not find case $case in the sentence stem data.";
    }

    return $self->{stems}->{$case};
}

sub _select_hash_key {
    my $self = shift;
    my $noun = shift;
    my $case = shift // 'nom' ;
    my $is_plural = shift // 0;
    $is_plural = $is_plural eq "plural" ? 1 : 0 ;
    my $animate = $self->{nouns}->{$noun}->{animate};
    my $gender = $self->{nouns}->{$noun}->{gender};

    if ( $is_plural ) {
        if ( $case eq "acc" ) {
            return "pl_gen" if $animate eq "a"; #animate nouns get genitive endings
            return "pl_nom"; # inanimate nouns get nominative endings
        }

        return "pl_".$case;
    }
    else {
        if ( $gender eq "m" ) {
            if ( $case eq "acc" ) {
                return "masc_gen" if $animate eq "a";
                return "masc_nom";
            }
             return "masc_$case";
        }
        elsif ( $gender eq "f" ) {
             return "fem_nom" if $case eq "nom";
             return "fem_acc" if $case eq "acc";
             return "fem_oth";
        }
        elsif ( $gender eq "n" ) {
             return "neu_nom" if $case eq "nom";
             return "neu_nom" if $case eq "acc";
             return "masc_$case";
        }
        else {
             confess "I don't know how to decline '$noun' (gender: $gender, animate: $animate)";
        }
    }
}

1;

__END__