Acme-Nyaa

 view release on metacpan or  search on metacpan

bin/nyaa  view on Meta::CPAN

    'nyaa' => ( 1 << 0 ),
    'noun' => ( 1 << 1 ),
    #'lang' => ( 1 << 2 ),
    #'test' => ( 1 << 3 ),
};
my $RunMode = parseoptions();

if( $RunMode ) {

    my $inputfiles = \@ARGV || [];
    my $filehandle = undef;
    my $nekonyaaaa = Acme::Nyaa->new( %$CatConf );
    my $nekobuffer = q();
    my $nounoption = $RunMode & $Options->{'noun'};

    push @$inputfiles, \*STDIN unless scalar @$inputfiles;

    foreach my $e ( @$inputfiles ) {

        $filehandle = ref $e ? $e : IO::File->new( $e, 'r' ) or die 'Cannot open '.$e;
        $nekobuffer = [ <$filehandle> ];

eg/nyaaproxy.psgi  view on Meta::CPAN

use Furl;
use Plack::Builder;
use Plack::Request;
use Plack::Builder;
use Acme::Nyaa;

my $httpobject = Furl->new( 
    'agent' => 'Acme::Nyaa/nyaaproxy/'.$Acme::Nyaa::VERSION, 
    'timeout' => 10
);
my $htresponse = undef;
my $htcontents = undef;
my $servername = undef;
my $requesturl = undef;
my $nekonyaaaa = undef;

builder {
    sub {
        my $env = shift;
        my $url = $env->{'REQUEST_URI'} || $env->{'PATH_INFO'};
        my $req = Plack::Request->new( $env );
        my $res = undef;
        my $err = [ 'Failed to connect' ];
        my $cth = [ 'Content-Type' => 'text/plain' ];
        my $tmp = undef;

        if( length $url > 1 ) {

            if( $url =~ m|\A/(https?://)(.+?)/(.*)\z| ) {
                $servername = $1.$2;
                $requesturl = $servername.'/'.$3;

            } else {
                $requesturl = $servername.$url;
            }

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

    # Constructor of Acme::Nyaa
    my $class = shift;
    my $argvs = { @_ };

    return $class if ref $class eq __PACKAGE__;
    $argvs->{'objects'} = [];
    $argvs->{'language'} ||= $Default;
    $argvs->{'loaded-languages'} = [];
    $argvs->{'objectid'} = int rand 2**24;
    $argvs->{'encoding'} = q();
    $argvs->{'utf8flag'} = undef;

    my $nyaan = bless $argvs, __PACKAGE__;
    my $klass = $nyaan->loadmodule( $argvs->{'language'} );
    my $this1 = $nyaan->findobject( $klass, 1 );

    $nyaan->{'subclass'} = $klass;
    return $nyaan;
}

sub subclass {

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

    return $self->{'subclass'};
}

sub language {
    my $self = shift;
    my $lang = shift // $self->{'language'};

    return $self->{'language'} if $lang eq $self->{'language'};
    return $self->{'language'} unless $lang =~ m/\A[a-zA-Z]{2}\z/;

    my $nekoobject = undef;
    my $referclass = $self->loadmodule( $lang );
    return $self->{'language'} unless length $referclass;
    return $self->{'language'} if $referclass eq $self->subclass;

    $nekoobject = $self->findobject( $referclass, 1 );
    return $self->{'language'} unless ref $nekoobject eq $referclass;

    $self->{'language'} = $lang;
    $self->{'subclass'} = $referclass;
    return $self->{'language'};

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

    Module::Load::load $alterclass;
    push @$list, $Default;
    return $alterclass;
}

sub findobject {
    my $self = shift;
    my $name = shift;
    my $new1 = shift || 0;
    my $this = undef;
    my $objs = $self->{'objects'} || [];

    return unless length $name;

    for my $e ( @$objs ) {

        next unless ref($e) eq $name;
        $this = $e;
    }
    return $this if ref $this;

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

sub reckon {
    # Implement at sub class
    my $self = shift;
    return $self->{'encoding'};
}

sub toutf8 {
    my $self = shift;
    my $argv = shift;
    my $text = undef;

    $text = ref $argv ? $$argv : $argv;
    return $text unless length $text;

    $self->reckon( \$text );
    return $text if $self->{'utf8flag'};
    return $text unless $self->{'encoding'};

    if( not $self->{'encoding'} =~ m/(?:ascii|utf8)/ ) {
        Encode::from_to( $text, $self->{'encoding'}, 'utf8' );
    }

    $text = Encode::decode_utf8 $text unless utf8::is_utf8 $text;
    return $text;
}

sub utf8to {
    my $self = shift;
    my $argv = shift;
    my $text = undef;

    $text = ref $argv ? $$argv : $argv;
    return $text unless $self->{'encoding'};
    return $text unless length $text;

    $text = Encode::encode_utf8 $text if utf8::is_utf8 $text;
    if( $self->{'encoding'} ne 'utf8' ) {
        Encode::from_to( $text, 'utf8', $self->{'encoding'} );
    }

lib/Acme/Nyaa/Ja.pm  view on Meta::CPAN

}
*objects = *object;
*findobject = *object;

sub cat {
    my $self = shift;
    my $argv = shift;
    my $flag = shift // 0;

    my $ref1 = ref $argv;
    my $text = undef;
    my $neko = undef;
    my $nyaa = undef;

    return q() if( $ref1 ne '' && $ref1 ne 'SCALAR' );
    $text = $ref1 eq 'SCALAR' ? $$argv: $argv;
    return q() unless length $text;

    eval { 
        $self->reckon( \$text );
        $neko = $self->toutf8( $text );
    };
    return $text if $@;

lib/Acme/Nyaa/Ja.pm  view on Meta::CPAN

    return $self->utf8to( join( '', @$writingset ) ) unless $flag;
    return join( '', @$writingset );
}

sub neko {
    my $self = shift;
    my $argv = shift;
    my $flag = shift // 0;

    my $ref1 = ref $argv;
    my $text = undef;
    my $neko = undef;

    return q() if( $ref1 ne '' && $ref1 ne 'SCALAR' );
    $text = $ref1 eq 'SCALAR' ? $$argv : $argv;
    return q() unless length $text;


    eval { 
        $self->reckon( \$text );
        $neko = $self->toutf8( $text ); 
    };

t/10_acme-nyaa.t  view on Meta::CPAN

isa_ok( $kijitora->objects, 'ARRAY' );
isa_ok( $kijitora->new, 'Acme::Nyaa' );
is( $kijitora->language, 'ja', '->language() = ja' );
is( $kijitora->language('xx'), 'ja', '->language(xx) = ja' );
is( $kijitora->language('cat'), 'ja', '->language(cat) = ja' );

foreach my $e ( @$language ) {

    my $c = 'Acme::Nyaa::'.ucfirst( $e );
    my $o = Acme::Nyaa->new( 'language' => $e );
    my $p = undef;

    isa_ok( $o, 'Acme::Nyaa' );
    can_ok( $o, @$cmethods );
    can_ok( $o, @$imethods );
    isa_ok( $o->new, 'Acme::Nyaa' );
    isa_ok( $o->objects, 'ARRAY', '->objects() = ARRAY' );
    is( $o->language, $e, sprintf( "->language() = %s", $e ) );
    is( $o->subclass, $c, sprintf( "->subclass() = %s", $c ) );

t/11_acme-nyaa-ja.t  view on Meta::CPAN

my $nekotext = 't/cat-related-text.ja.txt';
my $textlist = [];
my $langlist = [ qw|af ar de el en es fa fi fr he hi id is la pt ru th tr zh| ];
my $encoding = [ qw|euc-jp 7bit-jis shiftjis| ];
my $cmethods = [ 'new', 'reckon', 'toutf8', 'utf8to' ];
my $imethods = [ 
    'cat', 'neko', 'nyaa', 'straycat',
    'language', 'findobject', 'objects', 'object',
];
my $sabatora = undef;

$sabatora = Acme::Nyaa->new( 'language' => 'ja' );
isa_ok( $sabatora, 'Acme::Nyaa' );
is( $sabatora->language, 'ja', '->language() = ja' );

$sabatora = Acme::Nyaa::Ja->new;
isa_ok( $sabatora, 'Acme::Nyaa::Ja' );
isa_ok( $sabatora->new, 'Acme::Nyaa::Ja' );
isa_ok( $sabatora->object, 'Acme::Nyaa::Ja' );
isa_ok( $sabatora->objects, 'Acme::Nyaa::Ja' );

t/11_acme-nyaa-ja.t  view on Meta::CPAN

    }
}

use Encode::Guess qw(shiftjis euc-jp 7bit-jis);
foreach my $e ( @$encoding ) {

    foreach my $t ( @$textlist ) {

        next unless length $t > 100;
        my $label = sprintf( "->cat(%s)", $e );
        my $guess = undef;
        my ($text0, $text1, $text2, $text3, $text4);
        my ($size0, $size1, $size2, $size3, $size4);

        $text0 = $t; chomp $text0;
        Encode::from_to( $text0, 'utf8', $e );
        $guess = Encode::Guess->guess( $text0 );

        ok( ref $guess, ref $guess );
        ok( $guess->name, $guess->name );
        like( $guess->name, qr/$e/, $e );