view release on metacpan or  search on metacpan

lib/Acme/MetaSyntactic/nethack.pm  view on Meta::CPAN

package Acme::MetaSyntactic::nethack;

use 5.006001;
use utf8;
use strict;
use warnings;

use version; our $VERSION = qv('v1.0.1');

use base 'Acme::MetaSyntactic::MultiList';
__PACKAGE__->init();

1; # Magic true value required at end of module

=encoding utf8

=for stopwords mmm mmmm NetHack something's ummm

=head1 NAME

 view release on metacpan or  search on metacpan

lib/Acme/MetaSyntactic/soviet.pm  view on Meta::CPAN

}

38;
# Why 38? Hint: s/r$/t/

=encoding utf8

=head1 NAME

Acme::MetaSyntactic::soviet -- NATO codenames for Soviet-designed equipment

 view release on metacpan or  search on metacpan

lib/Acme/MetaSyntactic/vim.pm  view on Meta::CPAN

package Acme::MetaSyntactic::vim;

use 5.006001;
use utf8;
use strict;
use warnings;

use version; our $VERSION = qv('v1.0.1');

use base 'Acme::MetaSyntactic::MultiList';
__PACKAGE__->init();

1; # Magic true value required at end of module

=encoding utf8

=for stopwords Moolenaar autocmds

=head1 NAME

 view release on metacpan or  search on metacpan

eg/say.pl  view on Meta::CPAN

#!/usr/bin/perl
use strict;
use warnings;
use utf8;
use Acme::MilkyHolmes;

my ($sherlock, $nero, $elly, $cordelia)  = Acme::MilkyHolmes->members();

$sherlock->say('ってなんでですかー');

 view release on metacpan or  search on metacpan

lib/Acme/MorningMusume/ShinMember.pm  view on Meta::CPAN

use warnings;
use strict;
use Acme::MorningMusume;
use Acme::BloodType;
use utf8;
use base 'Acme::MorningMusume::Base';

=head1 NAME

Acme::MorningMusume::ShinMember - Create random Morning Musume!

lib/Acme/MorningMusume/ShinMember.pm  view on Meta::CPAN

    my ($mom, $dad) = @musume[rand(@musume), rand(@musume)];
    
    my %attributes;
    $attributes{first_name_en} = $mom->first_name_en;
    $attributes{first_name_ja} = $mom->first_name_ja;
    utf8::decode($attributes{first_name_ja});
    $attributes{family_name_en}  = $dad->family_name_en;
    $attributes{family_name_ja}  = $dad->family_name_ja;
    utf8::decode($attributes{family_name_ja});
    $attributes{nick} = [substr($attributes{first_name_ja}, 0, 1).'っちゃん'];
    $attributes{birthday} = $mom->birthday - rand($mom->birthday - 
						  $dad->birthday);
    $attributes{blood_type} = Acme::BloodType->new(
				     {phenotype => $mom->blood_type} 

lib/Acme/MorningMusume/ShinMember.pm  view on Meta::CPAN

			      Acme::BloodType->new(
				     {phenotype => $dad->blood_type}))
			       ->get_bloodtype;
    
    $attributes{hometown} = (rand 1 < 0.5 ? $mom : $dad)->hometown;
    utf8::decode($attributes{hometown});

    $attributes{graduate_date} = undef;
    $attributes{class} = int ($mom->class - rand($mom->class - $dad->class));
    $attributes{emoticon} = [(@{$dad->emoticon||()}, 
			       @{$mom->emoticon||()})[0..rand 2]];
    utf8::decode($_) for @{$attributes{emoticon}};
    return %attributes;
}

=head1 AUTHOR

 view release on metacpan or  search on metacpan

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

use warnings;
use strict;
our $VERSION = '0.0.5';

use utf8;

sub yorosiku {
  my $class   = shift if $_[0] eq __PACKAGE__; ## no critic
  my $text    = shift || "";

 view release on metacpan or  search on metacpan

lib/Acme/MyFirstModule/BDFOY.pm  view on Meta::CPAN

use 5.008;
use strict;
use warnings;

=encoding utf8

=head1 NAME

Acme::MyFirstModule::BDFOY - The great new Acme::MyFirstModule::BDFOY!

 view release on metacpan or  search on metacpan

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

1;
__END__

=encoding utf8

=head1 NAME

Acme::NabeAtzz - One, Two, さーん

 view release on metacpan or  search on metacpan

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

package Acme::Nyaa;
use strict;
use warnings;
use utf8;
use 5.010001;
use Encode;
use Module::Load;

use version; our $VERSION = qv('0.0.10');

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

    $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 );

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

    # 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'} );
    }

    return $text;
}

1;
__END__

=encoding utf8

=head1 NAME

Acme::Nyaa - Convert texts like which a cat is talking in Japanese

 view release on metacpan or  search on metacpan

lib/Tie/Cycle.pm  view on Meta::CPAN

"Tie::Cycle";

__END__

=encoding utf8

=head1 NAME

Tie::Cycle - Cycle through a list of values via a scalar.

 view release on metacpan or  search on metacpan

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

 package Acme::Ognon;

=encoding utf8

=head1 NAME

Acme::Ognon - Suivez le Conseil supérieur de la langue française ... peut-être

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

use 5.008_001;

use strict;
use warnings;
use utf8;

use Module::Build;
use File::Basename;
use File::Spec;
use CPAN::Meta;

 view release on metacpan or  search on metacpan

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

package Acme::Oppai;

use strict;
use warnings;
use utf8;

use Encode;
use Encode::Guess;
use Scalar::Util qw(blessed);

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

use overload q("") => sub { 
    my $self = shift;
    my $oppai = ${ $self->[0] };

    if ($self->[1]->{use_utf8}) {
        utf8::decode($oppai) unless utf8::is_utf8($oppai);
    } else {
        utf8::encode($oppai) if utf8::is_utf8($oppai);
    }
    $self->clear;
    $oppai;
};

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

sub gen_word {
    my ($self, $type, $word) = @_;

    return $BASIC_WORD{$type} unless $word;
    return $word if utf8::is_utf8($word);
    my $enc = guess_encoding($word, qw(euc-jp shiftjis 7bit-jis utf8));
    return $word unless ref($enc);
    $enc->decode($word);
}

sub gen {

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

            }
        }
    }

    my $word = $self->gen_word($type, @_);
    utf8::decode($word) unless utf8::is_utf8($word);
    push @{ $self->[3] }, {type => $type, word => $word};
    ${ $self->[0] } .= $self->gen($type, $word);
    $self;
}

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

=item option

=over 4

=item * use_utf8

use utf8 flag.

=item * default

default Asc Art type(up or down or default)

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

use utf8;
use strict;
use warnings;
use Module::Build;

Module::Build->new(

 view release on metacpan or  search on metacpan

lib/Acme/Pano/Util.pm  view on Meta::CPAN

package Acme::Pano::Util;

use 5.006;
use strict;
use encoding 'utf8';
use utf8;
use warnings FATAL => 'all';
use Exporter qw/import/;
our @EXPORT = qw/toBareword fromBareword/;
our @EXPORT_OK = ();
our %EXPORT_TAGS = (

 view release on metacpan or  search on metacpan

Happy.pm  view on Meta::CPAN

__END__

=pod

=encoding utf8

=head1 NAME

Acme::People::Happy - Does people happy?

 view release on metacpan or  search on metacpan

inc/Module/Install/TrustMetaYml.pm  view on Meta::CPAN

1;

__END__

=encoding utf8

 view release on metacpan or  search on metacpan

inc/MyBumpVersionAfterRelease.pm  view on Meta::CPAN

use warnings;
package inc::MyBumpVersionAfterRelease;

use Moose;
with 'Dist::Zilla::Role::AfterRelease';
use utf8;
use Path::Tiny 0.061;

# this is a smarter version of:
# [Run::AfterRelease]
# run = %x -p -i -e's/^version = 3\.(\d+)\s/sprintf(q(version = %0.( . (length($1)+1) . q(g), atan2(1,1)*4)/x'

inc/MyBumpVersionAfterRelease.pm  view on Meta::CPAN

    my $new_version = substr($Ï€, 0, $length);

    # munge dist.ini to edit version line
    my $path = path('dist.ini');
    my $content = $path->slurp_utf8;

    my $delta_length = $length - length($original_version);

    if ($content =~ s/^(version = )$original_version\s{$delta_length}(\s+)/$1$new_version$2/m)
    {
        # append+truncate to preserve file mode
        $path->append_utf8({ truncate => 1 }, $content);
        return 1;
    }

    return;
}

 view release on metacpan or  search on metacpan

benchmark/pinoko_vs_geso.pl  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use utf8;
use Acme::Pinoko;
#use Acme::Ikamusume; # Acme::Ikamusume invades Text::MeCab globally
use Benchmark qw/cmpthese timethese/;
use open qw/:utf8 :std/;


my $kytea_pinoko = Acme::Pinoko->new(parser => 'Text::KyTea');
my $mecab_pinoko = Acme::Pinoko->new(parser => 'Text::MeCab');

 view release on metacpan or  search on metacpan

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

    #!/usr/bin/env perl

    use strict;
    use warnings;
    use utf8;
    use feature qw/say/;
    use Data::Dumper;
    use Acme::Pointer;

    my $a = {

 view release on metacpan or  search on metacpan

lib/Acme/Pony/Pink.pm  view on Meta::CPAN

use 5.010;
use autodie;
use strict;
no warnings;
use utf8;

BEGIN {
	$Acme::Pony::Pink::AUTHORITY = 'cpan:TOBYINK';
	$Acme::Pony::Pink::VERSION   = '0.003';
}

 view release on metacpan or  search on metacpan

lib/Acme/PrettyCure/CureAqua.pm  view on Meta::CPAN

package Acme::PrettyCure::CureAqua;
use utf8;
use Any::Moose;

with 'Acme::PrettyCure::Role';

sub human_name   {'水無月かれん'}

 view release on metacpan or  search on metacpan

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

package Acme::PriPara;
use 5.008001;
use strict;
use warnings;
use utf8;

our $VERSION = "0.04";

use Readonly;

 view release on metacpan or  search on metacpan

author/RandomEmoji.pm  view on Meta::CPAN

package Acme::RandomEmoji;
use strict;
use warnings;
use utf8;

use Exporter 'import';
our @EXPORT_OK = qw(random_emoji);
our $VERSION = '0.01';

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

          ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
           ? ((lp = SvCUR(sv)), SvPVX(sv)) : my_sv_2pvbyte(aTHX_ sv, &lp))
       static char *
       my_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)
       {   
           sv_utf8_downgrade(sv,0);
           return SvPV(sv,*lp);
       }
#   endif
#else
#   define SvPVbyte SvPV

 view release on metacpan or  search on metacpan

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

}

1;
__END__

=encoding utf8

=head1 NAME

Acme::Replica

 view release on metacpan or  search on metacpan

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

    return if $rv eq 1;
    return if $rv eq '__PACKAGE__';
    return if $rv =~ /^__PACKAGE__->meta->make_immutable/;

    $rv = decode_utf8($rv);

    my $data = {
        'file'    => $filename,
        'package' => $this_package,
        'PPI'     => ref $match,

 view release on metacpan or  search on metacpan

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

package Acme::Samurai;
use 5.010001;
use strict;
use warnings;
use utf8;
our $VERSION = '0.04';

use File::ShareDir qw/dist_file/;
use Lingua::JA::Alphabet::Yomi qw/alphabet2yomi/;
use Lingua::JA::Numbers qw/num2ja/;

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

Acme::Samurai - Speak like a Samurai

=head1 SYNOPSIS

  use utf8;
  use Acme::Samurai;

  Acme::Samurai->gozaru("私、侍です"); # => "それがし、侍でござる"

=head1 DESCRIPTION

 view release on metacpan or  search on metacpan

t/000-report-versions.t  view on Meta::CPAN

# UTF Support?
sub HAVE_UTF8 () { $] >= 5.007003 }
BEGIN {
    if ( HAVE_UTF8 ) {
        # The string eval helps hide this from Test::MinimumVersion
        eval "require utf8;";
        die "Failed to load UTF-8 support" if $@;
    }

    # Class structure
    require 5.004;

t/000-report-versions.t  view on Meta::CPAN

    } else {
        # Strip UTF-8 bom if found, we'll just ignore it
        $string =~ s/^\357\273\277//;
    }

    # Try to decode as utf8
    utf8::decode($string) if HAVE_UTF8;

    # Check for some special cases
    return $self unless length $string;
    unless ( $string =~ /[\012\015]+\z/ ) {
        return $self->_error("Stream does not end with newline character");

 view release on metacpan or  search on metacpan

lib/Acme/Shukugawa/Atom.pm  view on Meta::CPAN

package Acme::Shukugawa::Atom;
use strict;
use warnings;
use base qw(Class::Accessor::Fast);
use utf8;
use Encode qw(decode_utf8);
use File::ShareDir;
use Text::MeCab;
use YAML ();

our $VERSION = '0.00004';

lib/Acme/Shukugawa/Atom.pm  view on Meta::CPAN

our ($CONFIG, @DEFAULT_WORDS, $RE_EXCEPTION, $RE_SMALL, $RE_SYLLABLE, $RE_NBAR);
BEGIN
{
    my $config = YAML::LoadFile( 
        $CONFIG || File::ShareDir::module_file(__PACKAGE__, 'config.yaml') );
    $RE_SMALL    = decode_utf8("[ャュョッー]");
    $RE_SYLLABLE = decode_utf8("(?:.$RE_SMALL?)");
    $RE_NBAR     = decode_utf8("^ンー");
    @DEFAULT_WORDS = map { 
        (decode_utf8($_->[0]), decode_utf8($_->[1]))
    } @{ $config->{custom_words} || [] };
}

sub _create_exception_re
{
    my $self = shift;
    my $custom = $self->custom_words;

    return decode_utf8(join("|",
        map { $custom->[$_ * 2 + 1] } (0..(scalar(@$custom) - 1)/2) ));
}

sub translate
{
    my $self   = shift;
    my $string = decode_utf8(shift);

    if (! ref $self) {
        $self = $self->new({ custom_words => \@DEFAULT_WORDS, @_ });
    }

lib/Acme/Shukugawa/Atom.pm  view on Meta::CPAN

        }

        foreach (my $node = $mecab->parse($text); $node; $node = $node->next) {
            next unless $node->surface;

            my $surface = decode_utf8($node->surface);
            my $feature = decode_utf8($node->feature);
            my ($type, $yomi) = (split(/,/, $feature))[0,8];
# warn "$surface -> $type, $yomi";

            if ($surface eq '上手') {
                $ret .= 'マイウー';
                next;
            }

            if ($type eq 'å‹•è©ž' && $node->next) {
                # 助動詞を計算に入れる
                my $next_feature = decode_utf8($node->next->feature);
                my ($next_type, $next_yomi) = (split(/,/, $next_feature))[0,8];
                if ($next_type eq '助動詞') {
                    $yomi .= $next_yomi;
                    $node = $node->next;
                }