view release on metacpan or  search on metacpan

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

package Acme::MetaSyntactic::legomarvelsavengers;
$Acme::MetaSyntactic::legomarvelsavengers::VERSION = '0.02';
#ABSTRACT: LEGO Marvel's Avengers theme

use utf8;
use strict;
use warnings;
use Acme::MetaSyntactic::List;
our @ISA = qw( Acme::MetaSyntactic::List );
__PACKAGE__->init();

 view release on metacpan or  search on metacpan

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

package Acme::MetaSyntactic::legomovievideogame;
$Acme::MetaSyntactic::legomovievideogame::VERSION = '0.02';
#ABSTRACT: LEGO Movie Videogame theme

use utf8;
use strict;
use warnings;
use Acme::MetaSyntactic::List;
our @ISA = qw( Acme::MetaSyntactic::List );
__PACKAGE__->init();

 view release on metacpan or  search on metacpan

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

package Acme::MetaSyntactic::legothehobbit;
$Acme::MetaSyntactic::legothehobbit::VERSION = '0.02';
#ABSTRACT: LEGO The Hobbit game theme

use utf8;
use strict;
use warnings;
use Acme::MetaSyntactic::List;
our @ISA = qw( Acme::MetaSyntactic::List );
__PACKAGE__->init();

 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

builder/Acme/Parataxis/Builder.pm  view on Meta::CPAN

    #
    ADJUST {
        -e 'META.json' or die "No META information provided\n";
    }
    method write_file( $filename, $content ) { path($filename)->spew_raw($content) or die "Could not open $filename: $!\n" }
    method read_file ($filename)             { path($filename)->slurp_utf8         or die "Could not open $filename: $!\n" }

    method step_build() {
        for my $pl_file ( find( qr/\.PL$/, 'lib' ) ) {
            ( my $pm = $pl_file ) =~ s/\.PL$//;
            system $^X, $pl_file->stringify, $pm and die "$pl_file returned $?\n";

 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