File Coverage

blib/lib/Yandex/Translate.pm

Criterion	Covered	Total	%
statement	24	113	21.2
branch	0	88	0.0
condition	0	36	0.0
subroutine	8	23	34.7
pod	14	14	100.0
total	46	274	16.7

package Yandex::Translate;

use strict;
use warnings;
use utf8;

use HTML::Entities qw{encode_entities};
use HTTP::Tiny;
use JSON;
use POSIX qw{:locale_h};
use URI::Escape qw{uri_escape_utf8};

#
# The “my” keyword is on a separate line so that the VERSION_FROM attribute
# of ExtUtils::MakeMaker->WriteMakefile() will accurately detect $VERSION.
#
my
$VERSION = '1.000002';

#
# See https://tech.yandex.ru/translate/doc/dg/concepts/api-overview-docpage/
# for the supported language codes.
#
my %valid_lang = map { $_ => 1 } qw{
    az sq am en ar hy af eu ba be bn my bg bs cy hu vi ht gl nl
    mrj el ka gu da he yi id ga it is es kk kn ca ky zh ko xh km
    lo la lv lt lb mg ms
    ml mt mk mi mr mhr mn de ne no pa pap fa pl pt ro ru ceb sr si
    sk sl sw su tg th tl ta tt te tr udm uz uk ur fi fr hi hr cs
    sv gd et eo jv ja
};

my %valid_format = map { $_ => 1 } qw { plain html };

my %valid_options = map { $_ => 1 } qw { 1 };

my %valid_default_ui = map { $_ => 1 } qw{ en ru };

#
# Set the default UI to Russian if the locale is Russian;
# otherwise, set it to English.
#
(my $default_ui = setlocale(LC_CTYPE) || 'en') =~ s/_.*$//;
$default_ui = 'en' if ($default_ui ne 'ru');

sub new
{
    my $class = shift;
    my $self = {
        _key_        => shift,
        _text_       => sub { my $t = shift; return (defined $t) ? uri_escape_utf8($t) : $t },
        _from_lang_  => shift,
        _to_lang_    => shift,
        _ui_         => shift || $default_ui,
        _hint_       => shift,
        _format_     => shift,
        _options_    => shift,
        _base_       => 'https://translate.yandex.net/api/v1.5/tr.json',
        _post_       => undef
    };

    bless $self, $class;
    return $self;
}

sub set_key
{
    my ( $self, $key ) = @_;
    $self->{_key_} = $key if (defined $key);
}

sub set_ui
{
    my ( $self, $ui ) = @_;
    $self->{_ui_} = (defined $ui && exists $valid_lang{$ui}) ? $ui : $default_ui;
}

sub set_default_ui
{
    my ( $self, $this_default_ui ) = @_;
    $default_ui = $this_default_ui if (defined $this_default_ui && exists $valid_default_ui{$this_default_ui});
}

#
# Get a list of supported translation directions.
#
sub get_langs_list
{
    my $self = shift;
    my $query = '/getLangs?';
    $self->{_post_} = 'key='.$self->{_key_}.'&ui='.$self->{_ui_};
    my $response = HTTP::Tiny->new->get($self->{_base_} . $query  . $self->{_post_});

    die "Invalid API key\n" if ($response->{status} eq '401');
    die "Blocked API key\n" if ($response->{status} eq '402');
    die "Failed to get list of supported languages! (response code $response->{status})\n" unless ($response->{success});

    if (defined wantarray && length $response->{content}) {
        my $json_respond = JSON->new->utf8->decode($response->{content});
        return (wantarray) ? @{ $json_respond->{dirs} } : scalar(@{ $json_respond->{dirs} });
    }
}

sub set_text
{
    my ( $self, $text ) = @_;
    $self->{_text_} = uri_escape_utf8($text) if (defined $text);
}

sub set_hint
{
    my ( $self, $hint ) = @_;
    my @valid_hint_lang;
    if (defined $hint && ref($hint) eq 'ARRAY') {
        for (@{ $hint }) {
           push @valid_hint_lang, $_ if (exists $valid_lang{$_});
        }
    }
    $self->{_hint_} = (@valid_hint_lang) ? [ @valid_hint_lang ] : undef;
}

sub detect_lang
{
    my $self = shift;
    my $query = '/detect?';
    $self->{_post_} = 'key='.$self->{_key_}.'&text='.$self->{_text_};
    $self->{_post_} .= '&hint='.join(',', @{ $self->{_hint_} }) if (defined $self->{_hint_});
    my $response = HTTP::Tiny->new->get($self->{_base_} . $query  . $self->{_post_});

    die "Invalid API key\n" if ($response->{status} eq '401');
    die "Blocked API key\n" if ($response->{status} eq '402');
    die "Exceeded the daily limit on the amount of translated text\n" if ($response->{status} eq '404');
    die "Failed to detect the language! (response code $response->{status})\n" unless ($response->{success});

    if (defined wantarray && length $response->{content}) {
        my $json_respond = JSON->new->utf8->decode($response->{content});
        return (wantarray) ? ($json_respond->{lang}) : $json_respond->{lang};
    }
}

sub set_from_lang
{
    my ( $self, $from_lang ) = @_;
    $self->{_from_lang_} = $from_lang if (!defined $from_lang || exists $valid_lang{$from_lang});
}

sub set_to_lang
{
    my ( $self, $to_lang ) = @_;
    $self->{_to_lang_} = $to_lang if (defined $to_lang && exists $valid_lang{$to_lang});
}

sub set_format
{
    my ( $self, $format ) = @_;
    $self->{_format_} = $format if (!defined $format || exists $valid_format{$format});
}

sub set_options
{
    my ( $self, $options ) = @_;
    $self->{_options_} = $options if (!defined $options || exists $valid_options{$options});
}

sub translate
{
    my $self = shift;
    my $query = '/translate?';
    my $lang = (defined $self->{_from_lang_}) ? $self->{_from_lang_}.'-'.$self->{_to_lang_} : $self->{_to_lang_};
    $self->{_post_} = 'key='.$self->{_key_}.'&text='.$self->{_text_}.'&lang='.$lang;
    $self->{_post_} .= '&format='.$self->{_format_} if (defined $self->{_format_});
    $self->{_post_} .= '&options='.$self->{_options_} if (defined $self->{_options_});
    my $response = HTTP::Tiny->new->get($self->{_base_} . $query  . $self->{_post_});

    die "Invalid API key\n" if ($response->{status} eq '401');
    die "Blocked API key\n" if ($response->{status} eq '402');
    die "Exceeded the daily limit on the amount of translated text\n" if ($response->{status} eq '404');
    die "Exceeded the maximum text size\n" if ($response->{status} eq '413');
    die "The text cannot be translated\n" if ($response->{status} eq '422');
    die "The specified translation direction is not supported\n" if ($response->{status} eq '501');
    die "Failed to translate text! (response code $response->{status})\n" unless ($response->{success});

    if (defined wantarray && length $response->{content}) {
        my $json_respond = JSON->new->utf8->decode($response->{content});
        if (defined $self->{_options_}) {
            return ($json_respond->{detected}->{lang}, $json_respond->{text}[0]);
        }
        else {
            return (wantarray) ? ($json_respond->{text}[0]) : $json_respond->{text}[0];
        }
    }
}

#
# See §2.7 of Пользовательское соглашение сервиса «API Яндекс.Переводчик»
# at https://yandex.ru/legal/translate_api/
#
# See §2.7 of Terms of Use of API Yandex.Translate Service
# at https://yandex.com/legal/translate_api/
#
sub get_yandex_technology_reference
{
    my ( $self, $attribute ) = @_;
    if (defined wantarray) {
        my %yandex_attribute;
        if (defined $attribute && ref($attribute) eq 'HASH') {
            while (my ( $key, $value ) = each %{ $attribute }) {
                $yandex_attribute{$key} = $key.'="'.encode_entities($value).'"' if (lc $key ne 'href');
            }
        }

        #
        # Sort %yandex_attribute so that the same $yandex_attributes value
        # will consistently be produced for a given $attribute hash.
        #
        my $yandex_attributes = (%yandex_attribute) ? ' '.join(' ', map { $yandex_attribute{$_} } sort { $a cmp $b } keys %yandex_attribute) : '';

        my %yandex_url = (
            ru => 'http://translate.yandex.ru/',
            en => 'http://translate.yandex.com/',
        );
        my %yandex_text = (
            ru => 'Переведено сервисом Яндекс.Переводчик',
            en => 'Powered by Yandex.Translate',
        );
        my $yandex_url = (exists $yandex_url{$self->{_ui_}}) ? $yandex_url{$self->{_ui_}} : $yandex_url{$default_ui};
        my $yandex_text = (exists $yandex_text{$self->{_ui_}}) ? $yandex_text{$self->{_ui_}} : $yandex_text{$default_ui};
        my $yandex_element = ''.$yandex_text.'';
        return (wantarray) ? ($yandex_element) : $yandex_element;
    }
}

1;
__END__