Acme-AjiFry
5 results

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN 

    test_files           => ((-d '.git' || $ENV{RELEASE_TESTING}) && -d 'xt') ? 't/ xt/' : 't/',
    recursive_test_files => 1,
);
if (-d 'share') {
    $args{share_dir} = 'share';
}

my $builder = Module::Build->subclass(
    class => 'MyBuilder',
    code => q{
        sub ACTION_distmeta {
            die "Do not run distmeta. Install Minilla and `minil install` instead.\n";
        }
        sub ACTION_installdeps {
            die "Do not run installdeps. Run `cpanm --installdeps .` instead.\n";
        }
    }
)->new(%args);
$builder->create_build_script();

my $mbmeta = CPAN::Meta->load_file('MYMETA.json');
my $meta = CPAN::Meta->load_file('META.json');
my $prereqs_hash = CPAN::Meta::Prereqs->new(
    $meta->prereqs

cpanfile  view on Meta::CPAN 

requires 'perl',           '5.008009';
requires 'Encode',         '2.39';
requires 'List::Util',     '1.22';
requires 'Filter::Simple', '0.84';

on 'build' => sub {
    requires 'FindBin',               0;
    requires 'Test::More',            '0.98';
    requires 'File::Copy',            '2.13';
    requires 'File::Compare',         '1.1005';
    requires 'File::Spec::Functions', 0;
};

on 'configure' => sub {
    requires 'Module::Build', '0.4003';
};

lib/Acme/AjiFry.pm  view on Meta::CPAN 

    w => [ 'わ', 'を', 'ゎ' ],
};
use constant DULLNESS => [
    'が', 'ぎ', 'ぐ', 'げ', 'ご', 'ざ', 'じ', 'ず', 'ぜ', 'ぞ',
    'だ', 'ぢ', 'づ', 'で', 'ど', 'ば', 'び', 'ぶ', 'べ', 'ぼ'
];
use constant P_SOUND => [ 'ぱ', 'ぴ', 'ぷ', 'ぺ', 'ぽ' ];
use constant DOUBLE_CONSONANT =>
  [ 'ぁ', 'ぃ', 'ぅ', 'ぇ', 'ぉ', 'っ', 'ゃ', 'ゅ', 'ょ', 'ゎ' ];

sub new {
    my $class = shift;
    return $class;
}

sub to_AjiFry {
    my ( $self, $raw_string ) = @_;

    my $chomped = chomp($raw_string);
    unless ($raw_string) {
        return "\n" if $chomped;
        return '';
    }

    $raw_string = decode_utf8($raw_string);
    my $ajifry_word = $self->_to_ajifry($raw_string);
    $ajifry_word .= "\n" if $chomped;
    return encode_utf8($ajifry_word);
}

sub translate_to_ajifry {
    my ( $self, $raw_string ) = @_;
    return $self->to_AjiFry($raw_string);
}

sub to_Japanese {
    my ( $self, $ajifry_word ) = @_;
    my $chomped = chomp($ajifry_word);

    unless ($ajifry_word) {
        return "\n" if $chomped;
        return '';
    }

    $ajifry_word = decode_utf8($ajifry_word);
    my $japanese_word = $self->_to_Japanese($ajifry_word);
    $japanese_word .= "\n" if $chomped;
    return encode_utf8($japanese_word);
}

sub translate_from_ajifry {
    my ( $self, $ajifry_word ) = @_;
    return $self->to_Japanese($ajifry_word);
}

sub _search_key_of_element {
    my ( $self, $element, $hash ) = @_;

    foreach my $key ( sort keys %$hash ) {
        if ( List::Util::first { $_ eq $element } @{ $hash->{$key} } ) {
            return $key;
        }
    }
}

sub _find_first {
    my ( $self, $key, $list ) = @_;

    return ( List::Util::first { $_ eq $key } @$list ) ? 1 : 0;
}

sub _find_duplicate_element_in_both_lists {
    my $self = shift;
    my ( $list_A, $list_B ) = @_;

    my @duplicate_elements;
    foreach my $element_A ( @{$list_A} ) {
        foreach my $element_B ( @{$list_B} ) {
            if ( $element_A eq $element_B ) {
                push( @duplicate_elements, $element_A );
            }
        }
    }
    return @duplicate_elements;
}

sub _get_ajifry_word_by_consonant {
    my $self      = shift;
    my $consonant = shift;

    if ( $consonant eq 'a' ) {
        return "食え";
    }
    elsif ( $consonant eq 'k' ) {
        return "フライ";
    }
    elsif ( $consonant eq 's' ) {

lib/Acme/AjiFry.pm  view on Meta::CPAN 

        return "ああ";
    }
    elsif ( $consonant eq 'w' ) {
        return "雄山";
    }
    else {
        return "";
    }
}

sub _get_ajifry_word_by_vowel {
    my $self  = shift;
    my $vowel = shift;

    if ( $vowel eq 'a' ) {
        return "食え食え";
    }
    elsif ( $vowel eq 'i' ) {
        return "ドボドボ";
    }
    elsif ( $vowel eq 'u' ) {

lib/Acme/AjiFry.pm  view on Meta::CPAN 

        return "アジフライ";
    }
    elsif ( $vowel eq 'n' ) {
        return "京極";
    }
    else {
        return "";
    }
}

sub _get_consonant_by_ajifry_word {
    my $self        = shift;
    my $ajifry_word = shift;

    if ( $ajifry_word eq '食え' ) {
        return 'a';
    }
    elsif ( $ajifry_word eq 'フライ' ) {
        return 'k';
    }
    elsif ( $ajifry_word eq 'お刺身' ) {

lib/Acme/AjiFry.pm  view on Meta::CPAN 

        return 'r';
    }
    elsif ( $ajifry_word eq '雄山' ) {
        return 'w';
    }
    else {
        return;
    }
}

sub _get_vowel_by_ajifry_word {
    my $self        = shift;
    my $ajifry_word = shift;

    if ( $ajifry_word eq '食え食え' ) {
        return 'a';
    }
    elsif ( $ajifry_word eq 'ドボドボ' ) {
        return 'i';
    }
    elsif ( $ajifry_word eq 'お刺身' ) {

lib/Acme/AjiFry.pm  view on Meta::CPAN 

        return 'e';
    }
    elsif ( $ajifry_word eq 'アジフライ' ) {
        return 'o';
    }
    else {
        return;
    }
}

sub _to_ajifry {
    my $self       = shift;
    my $raw_string = shift;

    my @raw_chars = split //, $raw_string;
    my $ajifry_word;
    foreach my $raw_char (@raw_chars) {
        my $vowel     = $self->_search_key_of_element( $raw_char, COLS );
        my $consonant = $self->_search_key_of_element( $raw_char, ROWS );

        if ( !$vowel && !$consonant ) {

lib/Acme/AjiFry.pm  view on Meta::CPAN 

        $ajifry_word .= "中川"
          if $self->_find_first( $raw_char, DOUBLE_CONSONANT );
        $ajifry_word .= $self->_get_ajifry_word_by_consonant($consonant);
        $ajifry_word .= $self->_get_ajifry_word_by_vowel($vowel);
        $ajifry_word .= "社主" if $self->_find_first( $raw_char, P_SOUND );
        $ajifry_word .= "陶人" if $self->_find_first( $raw_char, DULLNESS );
    }
    return $ajifry_word;
}

sub _to_Japanese {
    my $self        = shift;
    my $ajifry_word = shift;

    my $translated_word;
    while (1) {
        unless ($ajifry_word) {
            last;
        }

        my $is_double_consonant = 0;

lib/Acme/AjiFry/EN.pm  view on Meta::CPAN 

    4 => '陶人ドボドボ',
    5 => '陶人お刺身',
    6 => '陶人むむ･･･',
    7 => '陶人アジフライ',
    8 => '社主食え食え',
    9 => '社主ドボドボ',

    space => '中川',
};

sub new {
    my $class = shift;
    return $class;
}

sub to_AjiFry {
    my ( $self, $raw_string ) = @_;
    my $chomped = chomp($raw_string);

    unless ($raw_string) {
        return "\n" if $chomped;
        return '';
    }

    $raw_string = decode_utf8($raw_string);
    my $ajifry_word = $self->_to_ajifry($raw_string);
    $ajifry_word .= "\n" if $chomped;
    return encode_utf8($ajifry_word);
}

sub translate_to_ajifry {
    my ( $self, $raw_string ) = @_;
    return $self->to_AjiFry($raw_string);
}

sub to_English {
    my ( $self, $ajifry_word ) = @_;
    my $chomped = chomp($ajifry_word);

    unless ($ajifry_word) {
        return "\n" if $chomped;
        return '';
    }

    $ajifry_word = Encode::decode_utf8($ajifry_word);
    my $translated_word = $self->_to_English($ajifry_word);
    $translated_word .= "\n" if $chomped;
    return encode_utf8($translated_word);
}

sub translate_from_ajifry {
    my ( $self, $ajifry_word ) = @_;
    return $self->to_English($ajifry_word);
}

sub _to_ajifry {
    my $self       = shift;
    my $raw_string = shift;

    my @raw_chars = split //, $raw_string;
    my $ajifry_word;
    foreach my $raw_char (@raw_chars) {
        if ( $raw_char eq ' ' ) {
            $ajifry_word .= MAP->{space};
        }
        elsif ( $raw_char =~ /[a-zA-Z0-9]/ ) {
            $ajifry_word .= MAP->{$raw_char};
        }
        else {
            $ajifry_word .= $raw_char;
        }
    }

    return $ajifry_word;
}

sub _to_English {
    my $self        = shift;
    my $ajifry_word = shift;

    my $translated_word;
    while ($ajifry_word) {
        my $match = 0;

        my $map = MAP;
        foreach my $key ( keys %{$map} ) {
            if ( $ajifry_word =~ s/^$map->{$key}// ) {

lib/Acme/AjiFry/Perl.pm  view on Meta::CPAN 

package Acme::AjiFry::Perl;

use warnings;
use strict;
use utf8;

use Acme::AjiFry::EN;
use Filter::Simple;

sub _extract_statements_avobe_declaration {
    open my $frh, '<', $0 or die "Can't open $0: $!";

    my $above_declaration_str;
    foreach my $line (<$frh>) {
        $above_declaration_str .= $line;
        last if ( $line =~ /^\s*use\s*Acme::AjiFry::Perl/ );
    }
    close $frh;

    return $above_declaration_str;
}

my $ajifry = Acme::AjiFry::EN->new();

FILTER_ONLY all => sub {
    s/(.+)/$ajifry->to_AjiFry($1)/eg;

    open my $fh, '+<', "$0" or die "Can't rewrite '$0'\n";
    seek $fh, 0, 0;

    print $fh &_extract_statements_avobe_declaration;
    print $fh $_;

    s/(.+)/$ajifry->to_English($1)/eg;



( run in 0.263 second using v1.01-cache-2.11-cpan-4d50c553e7e )