File Coverage

blib/lib/Lingua/Num2Word.pm

Criterion	Covered	Total	%
statement	38	59	64.4
branch	5	26	19.2
condition	4	4	100.0
subroutine	13	14	92.8
pod	5	5	100.0
total	65	108	60.1

# For Emacs: -*- mode:cperl; mode:folding -*-
#
# Copyright (C) PetaMem, s.r.o. 2002-present
#
package Lingua::Num2Word;
# ABSTRACT: A wrapper for Lingua::XXX::num2word modules.

# {{{ use block

use 5.10.1;

use strict;
use warnings;

use utf8;

use Carp;
use Encode;

# }}}
# {{{ BEGIN

our $VERSION = 0.0682;

BEGIN {
    use Exporter ();
    use vars qw($VERSION $REVISION @ISA @EXPORT_OK %known);
    ($REVISION) = '$Rev: 682 $' =~ /([\d.]+)/; #'
    @ISA        = qw(Exporter);
    @EXPORT_OK  = qw(cardinal get_interval known_langs langs preprocess_code);
}

# }}}

# {{{ templates for functional and object interface

my $template_func = q{ use __PACKAGE_WITH_VERSION__ ();
                       $result = __PACKAGE__::__FUNCTION__($number);
                     };

my $template_obj  = q{ use __PACKAGE_WITH_VERSION__ ();
                       my $tmp_obj = new __PACKAGE__;
                       $result = $tmp_obj->__FUNCTION__($number);
                     };

# }}}
# {{{ %known                    language codes from iso639 mapped to respective interface

%known = (
    afr => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 0,
        limit_hi => 99_999_999_999,
        function => 'parse',
        code     => $template_obj,
    },
    ces => {
        package  => 'Num2Word',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999,
        function => 'num2ces_cardinal',
        code     => $template_func,
    },
    deu => {
        package  => 'Num2Word',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999,
        function => 'num2deu_cardinal',
        code     => $template_func,
    },
    eng => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 1,
        limit_hi => 999_999_999_999_999, # 1e63
        function => '',
        code     => q{ use __PACKAGE_WITH_VERSION__ qw(American);
                       my $tmp_obj = new __PACKAGE__;
                       $tmp_obj->parse($number);
                       $result = $tmp_obj->get_string;
                     },
    },
    eus => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999,
        function => 'cardinal2alpha',
        code     => $template_func,
    },
    fra => {
        package  => 'Nums2Words',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999_999, # < 1e52
        function => 'num2word',
        code     => $template_func,
    },
    ind => {
        package  => 'Nums2Words',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999_999,
        function => 'nums2words',
        code     => $template_func,
    },
    ita => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999,
        function => 'number_to_it',
        code     => $template_func,
    },
    jpn => {
        package  => 'Number',
        version  => '',
        limit_lo => 1,
        limit_hi => 999_999_999_999_999,
        function => 'to_string',
        code     => q{ use __PACKAGE_WITH_VERSION__ ();
                       my @words = __PACKAGE__::__FUNCTION__($number);
                       $result = join ' ', @words;
                     },
        },
    nld => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 0,
        limit_hi => 99_999_999_999,
        function => 'parse',
        code     => $template_obj,
    },
    nor => {
        package  => 'Num2Word',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999,
        function => 'num2no_cardinal',
        code     => $template_obj,
    },
    pol => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 0,
        limit_hi => 9_999_999_999_999,
        function => 'parse',
        code     => $template_obj,
    },
    por => {
        package  => 'Nums2Words',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999_999,
        function => 'num2word',
        code     => $template_func,
    },
    rus => {
        package  => 'Number',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999_999,
        function => 'rur_in_words',
        code     => q{ use __PACKAGE_WITH_VERSION__ ();
                       $result = __PACKAGE__::__FUNCTION__($number);
                       if ($result) {
                           if ($number) {
                               $result =~ s/\s+\S+\s+\S+\s+\S+$//;
                           }
                           else {
                               $result =~ s/\s+\S+$//;
                           }
                           $result =~ s/^\s+//;
                       }
                     },
    },
    spa => {
        package  => 'Numeros',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999_999_999,
        function => 'cardinal',
        code     => $template_obj,
    },
    swe => {
        package  => 'Num2Word',
        version  => '',
        limit_lo => 0,
        limit_hi => 999_999_999,
        function => 'num2sv_cardinal',
        code     => $template_func,
    },
    zho => {
        package  => 'Numbers',
        version  => '',
        limit_lo => 1,
        limit_hi => 999_999_999_999_999,
        function => '',
        code     => q{ use __PACKAGE_WITH_VERSION__ qw(traditional);
                       my $tmp_obj = new __PACKAGE__;
                       $tmp_obj->parse($number);
                       $result = $tmp_obj->get_string;
                     },
    },
);

# }}}
# {{{ new                       constructor

sub new {
    return bless {}, shift;
}

# }}}
# {{{ known_langs               list of currently supported languages

sub known_langs {
    return wantarray ? sort keys %known : [ sort keys %known ];
}

# }}}
# {{{ get_interval              get minimal and maximal supported number

# Return:
#  undef for unsupported language
#  list or list reference (depending to calling context) with
#  minimal and maximal supported number
#
sub get_interval {
    my $self = ref($_[0]) ? shift : Lingua::Num2Word->new();
    my $lang = shift || return;
    my @limits;

    return if (!defined $known{$lang});

    @limits = ($known{$lang}{limit_lo}, $known{$lang}{limit_hi});

    return @limits if (wantarray);
    return \@limits;
}

# }}}
# {{{ cardinal                  convert number to text

sub cardinal {
    my $self   = ref($_[0]) ? shift : Lingua::Num2Word->new();
    my $result = '';
    my $lang   = defined $_[0] ? shift : return $result;
    my $number = defined $_[0] ? shift : return $result;

    $lang = lc $lang;

    return $result if (!defined $known{$lang});

    if (defined $known{$lang}{lang}) {
        eval $self->preprocess_code($known{$lang}{lang}); ## no critic
        carp $@ if ($@);
    }
    else {
        eval $self->preprocess_code($lang); ## no critic
        carp $@ if ($@);
    }

    return $result;
}

# }}}
# {{{ preprocess_code           prepare code for evaluation

sub preprocess_code {
    my $self                  = shift;
    my $lang                  = shift // return;

    return if !exists $known{$lang};

    my $result                = $known{$lang}{code};
    my $pkg_name              = 'Lingua::' . uc($lang) . '::' . $known{$lang}{package};
    my $pkg_name_with_version = $known{$lang}{version} ne ''
                              ? "$pkg_name $known{$lang}{version}"
                              : $pkg_name
                              ;

    my $function              = $known{$lang}{function};

    $result =~ s/__PACKAGE_WITH_VERSION__/$pkg_name_with_version/g;
    $result =~ s/__PACKAGE__/$pkg_name/g;
    $result =~ s/__FUNCTION__/$function/g;

    return $result;
}
# }}}

1;

__END__