view release on metacpan or  search on metacpan

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

This function takes B<binary string> to encode and return the encoded string.

=item $c64->decode($string)

This function takes B<text string> to decode and return the decoded data.

=back

=head1 AUTHOR

 view release on metacpan or  search on metacpan

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

Acme::EnclosedChar generates Enclosed Alphanumerics.


=head1 METHOD

=head2 enclose($decoded_text)

encode text into Enclosed Alphanumerics

=head2 enclose_katakana($decoded_text)

Also Japanese Katakana will be encoded.

=head2 enclose_week_ja($decoded_text)

Also Japanese day of week will be encoded.

=head2 enclose_kansuji($decoded_text)

Also Japanese kansuji will be encoded.

=head2 enclose_kanji($decoded_text)

Also Japanese kanji will be encoded.

=head2 enclose_all($decoded_text)

enclose text as far as possible


=head1 REPOSITORY

 view release on metacpan or  search on metacpan

lib/FSM.pm  view on Meta::CPAN

=item query specific I<[turn]>

Two scalars are I<$state> and specially encoded I<$rule>
(refer to L<B<query_switch()> method|/query_switch()> about encoding).
If I<$rule> can't be decoded then B<croak>s.
Returns (after verification) requested I<$rule> as ARRAY.
While straightforward I<[turn]>s (such as C<tturn>, C<fturn>, and such) could
be in fact queried through L<B<fst()> method|/fst()> turn map needs bit more
sophisticated handling;
and that's what B<turn()> does;

 view release on metacpan or  search on metacpan

lib/Acme/Free/API/Geodata/GeoIP.pm  view on Meta::CPAN

    my $url = "http://ip-api.com/json/" . $ip;

    my $content = $self->_fetchURL($url);

    my $ok = 0;
    my $decoded;
    eval {
        $decoded = decode_json($content);
        $ok = 1;
    };

    if(!$ok || !defined($decoded)) {
        $self->_debuglog("Failed to decode response. Not a JSON document?");
        $self->_debuglog(Dumper($decoded));
        return;
    }

    #$self->_debuglog(Dumper($decoded));

    return $decoded;
}



# internal helpers

lib/Acme/Free/API/Geodata/GeoIP.pm  view on Meta::CPAN

    if(!defined($response)) {
        $self->_debuglog("Could not get agent response");
        return;
    }

    my $content = $response->decoded_content;
    if(!defined($content) || !length($content)) {
        $self->_debuglog("Could not get response content");
        return;
    }

 view release on metacpan or  search on metacpan

script/gen-generic-ind-company-names  view on Meta::CPAN

#    }
#
#    \@argv;
#}
#
## return ($err, $res, $decoded_val)
#sub _parse_raw_value {
#    my ($self, $val, $needs_res) = @_;
#
#    if ($val =~ /\A!/ && $self->{enable_encoding}) {
#

script/gen-generic-ind-company-names  view on Meta::CPAN

#        # key line
#        if ($line =~ /^\s*([^=]+?)\s*=\s*(.*)/) {
#            my $key = $1;
#            my $val = $2;
#
#            # the common case is that value are not decoded or
#            # quoted/bracketed/braced, so we avoid calling _parse_raw_value here
#            # to avoid overhead
#            if ($val =~ /\A["!\\[\{~]/) {
#                $_raw_val = $val if $cb;
#                my ($err, $parse_res, $decoded_val) = $self->_parse_raw_value($val);
#                $self->_err("Invalid value: " . $err) if $err;
#                $val = $decoded_val;
#            } else {
#                $_raw_val = $val if $cb;
#                $val =~ s/\s*[#;].*//; # strip comment
#            }
#

script/gen-generic-ind-company-names  view on Meta::CPAN

#C<section> (str, section name).
#
#=item * Found a key line
#
#Arguments passed: C<event> (str, 'section'), C<linum>, C<line>, C<cur_section>,
#C<key> (str, key name), C<val> (any, value name, already decoded if encoded),
#C<raw_val> (str, raw value).
#
#=back
#
#TODO: callback when there is merging.

 view release on metacpan or  search on metacpan

t/01_spec.t  view on Meta::CPAN

{
    my $name = 'encodes and decodes JWTs';
    my $secret = 'secret';
    my $jwt = Acme::JWT->encode($payload, $secret);
    my $decoded_payload = Acme::JWT->decode($jwt, $secret);
    is_d $decoded_payload, $payload, $name;
}


{
    my $algorithm = 'HS512';

t/01_spec.t  view on Meta::CPAN

        $algorithm = 'RS256';
    }
    my $name = 'encodes and decodes JWTs for RSA signaturese';
    my $rsa = Crypt::OpenSSL::RSA->generate_key(512);
    my $jwt = Acme::JWT->encode($payload, $rsa->get_private_key_string, $algorithm);
    my $decoded_payload = Acme::JWT->decode($jwt, $rsa->get_public_key_string);
    is_d $decoded_payload, $payload, $name;
}

{
    my $name = 'decodes valid JWTs';
    my $example_payload = {hello => 'world'};
    my $example_secret = 'secret';
    my $example_jwt = 'eyJhbGciOiAiSFMyNTYiLCAidHlwIjogIkpXVCJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.tvagLDLoaiJKxOKqpBXSEGy7SYSifZhjntgm9ctpyj8';
    my $decoded_payload = Acme::JWT->decode($example_jwt, $example_secret);
    is_d $decoded_payload, $example_payload, $name;
}

{
    my $name = 'raises exception with wrong hmac key';
    my $right_secret = 'foo';

t/01_spec.t  view on Meta::CPAN

{
    my $name = 'allows decoding without key';
    my $right_secret = 'foo';
    my $bad_secret = 'bar';
    my $jwt = Acme::JWT->encode($payload, $right_secret);
    my $decoded_payload = Acme::JWT->decode($jwt, $bad_secret, 0);
    is_d $decoded_payload, $payload, $name;
}

{
    my $name = 'raises exception on unsupported crypto algorithm';
    eval {

t/01_spec.t  view on Meta::CPAN

{
    my $name = 'encodes and decodes plaintext JWTs';
    my $jwt = Acme::JWT->encode($payload, undef, 0);
    is((my @a = split(/\./, $jwt)), 2, $name . '(length)');
    my $decoded_payload = Acme::JWT->decode($jwt, undef, 0);
    is_d $decoded_payload, $payload, $name;
}

done_testing;

 view release on metacpan or  search on metacpan

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

        }

        # extract, cleanup and return the data
        # if decoding the content fails, we just deal with the raw content
        push @items =>
            $class->extract( $res->decoded_content() || $res->content(),
               $category || () );

    }

    # return unique items

 view release on metacpan or  search on metacpan

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

    my $self    = shift;
    my $arg_ref = shift;

    my $frame   = $arg_ref->{FRAME};
    if (! defined $frame) {
        croak "You need to pass a frame to be decoded.";
    }
    my $last_frame_undo = rindex $frame, 'T';
    if ($last_frame_undo > 0) {
        # if a FUN was found, take everything to the right to be the
        # new frame.

 view release on metacpan or  search on metacpan

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

Then go to:

  http://localhost:7777/?path=%24test2/add()&action=call&arg0=10&arg1=15

The C<path> part, decoded, reads C<< $test2/add() >>.

=head1 DESCRIPTION

By my estimate, there are over 10,000 RPC modules on CPAN.  Each one makes RPC more
difficult than the one before it.  They all want you to pass tokens back and forth,

 view release on metacpan or  search on metacpan

local/lib/perl5/IO/Async/Stream.pm  view on Meta::CPAN

=head2 encoding => STRING

If supplied, sets the name of encoding of the underlying stream. If an
encoding is set, then the C<write> method will expect to receive Unicode
strings and encodes them into bytes, and incoming bytes will be decoded into
Unicode strings for the C<on_read> event.

If an encoding is not supplied then C<write> and C<on_read> will work in byte
strings.

 view release on metacpan or  search on metacpan

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

our @EXPORT = qw/ sudden_death sudden_death_single /;

use version; our $VERSION = '0.09';

sub _generator {
    my $decoded_str = shift;
    my @decoded_lines = split /\n/, $decoded_str;

    my $max_length = 0;
    $max_length = $_ > $max_length ? $_ : $max_length
        for map {Text::VisualWidth::UTF8::width($_)} @decoded_lines;

    my $ascii = [];
    my $frame_length = ($max_length + 2) / 2;
    push @{$ascii}, '＿' . '人' x $frame_length . '＿';
    for my $line (@decoded_lines) {
        my $str_length = $max_length - Text::VisualWidth::UTF8::width($line);
        my ($left, $right) = map{' ' x $_} ($str_length / 2, $str_length / 2);

        $left = $str_length % 2 != 0 ? $left . ' ' : $left;
        push @{$ascii}, '＞ ' . $left . $line . $right . ' ＜';

 view release on metacpan or  search on metacpan

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

sub new {
	my $class = shift;
	my $self = {};
	bless $self, $class;
	$self->{ua} = LWP::UserAgent->new;
	$self->{wisdom} = HTML::TreeBuilder->new_from_content( $self->{ua}->get( 'http://www.timecube.com' )->decoded_content );
	$self->{wisdom} or die "Couldn't fetch wisdom...\n";
	@{ $self->{verses} } = $self->{wisdom}->find_by_tag_name( 'p' );
	return $self
}