view release on metacpan or search on metacpan
lib/Dubber/API.pm view on Meta::CPAN
ssl_opts => { verify_hostname => $self->strict_ssl },
);
}
# ------------------------------------------------------------------------
method _clear_state () { $self->clear_decoded_response; $self->clear_response; }
# ------------------------------------------------------------------------
__PACKAGE__->meta->make_immutable;
view release on metacpan or search on metacpan
lib/DustyDB/Meta/Attribute.pm view on Meta::CPAN
This is a subroutine used to transform a Perl object into a something else you want to store. Since we use L<DBM::Deep> to store the objects, this can be much more flexible than just a scalar.
Be careful, though, not to store a hash with a C<class_name> key or very bad things might happen.
This subroutine should expect the decoded value in C<$_> and return whatever value should be stored.
=cut
has encode => (
is => 'rw',
view release on metacpan or search on metacpan
lib/EBook/FB2/Binary.pm view on Meta::CPAN
if (@nodes) {
$self->content_type($nodes[0]->getValue());
}
# XXX: eval this, it might fail with invalid data
my $decoded = MIME::Base64::decode($node->string_value());
$self->data($decoded)
}
1;
__END__
lib/EBook/FB2/Binary.pm view on Meta::CPAN
Returns id of binary element
=item data()
Returns content of binary element (base64-decoded)
=item content_type()
Returns content-type of binary element
view release on metacpan or search on metacpan
lib/EBook/Ishmael/Decode.pm view on Meta::CPAN
B<EBook::Ishmael::Decode> does not export any subroutines by default.
=head2 $d = lz77_decode($data)
Decodes PalmDoc lz77-encoded C<$data>, returning the decoded data.
=head1 AUTHOR
Written by Samuel Young, E<lt>samyoung12788@gmail.comE<gt>.
view release on metacpan or search on metacpan
- encoding is now binmode syntax
0.42 2012-05-03
- we get decoded pod, so we have to ensure to write the file with
correct encoding (thx to reneeb)
0.41 2012-04-18
- stop spamming /tmp
view release on metacpan or search on metacpan
lib/EBook/Tools/LZSS.pm view on Meta::CPAN
The eBookwise .IMP format typically compresses with 3 length bits.
Note that the actual length of the LZSS reference in bytes is greater
than the value stored in the length bits. The actual number of bytes
returned is the decoded length bits value plus C<maxuncoded> plus 1,
=item * C<offsetbits>
The number of bits used to encode the offset to a LZSS reference.
This also determines the size of the sliding window of reference data.
lib/EBook/Tools/LZSS.pm view on Meta::CPAN
spaces.
=item * C<windowstart>
The first byte position in the window that will be overwritten by
decoded text. If not specified, defaults to 0.
=item * C<maxuncoded>
The maximum number of uncoded bytes (?). This currently isn't used
for that purpose, but determines the actual length of a LZSS reference.
view release on metacpan or search on metacpan
Evas/Evas.xs view on Meta::CPAN
void
evas_object_text_style_pad_get(Evas_Object *obj, int *l, int *r, int *t, int *b)
int
evas_string_char_next_get(char *str, int pos, int *decoded)
int
evas_string_char_prev_get(char *str, int pos, int *decoded)
int
evas_string_char_len_get(char *str)
void
view release on metacpan or search on metacpan
t/02-engines.t view on Meta::CPAN
use Encode;
use File::Basename;
use Scalar::Util qw(tainted);
my $encoded_text = "\xE3\x83\x86\xE3\x82\xB9\xE3\x83\x88";
my $decoded_text = decode_utf8($encoded_text);
my $unicode_notation = "\\u30C6\\u30B9\\u30C8";
my $invalid_text = "Invalid: \xFF";
my $sanitized_text = "Invalid: \xEF\xBF\xBD";
my $tainted_text = do {
open(my $in, dirname(__FILE__).'/data/tainted.txt') or die "$!: tainted.txt";
t/02-engines.t view on Meta::CPAN
close $in;
$tmp;
};
ok !Encode::is_utf8($encoded_text);
ok Encode::is_utf8($decoded_text);
isnt Encode::decode_utf8($invalid_text), $invalid_text;
ok tainted($tainted_text);
for my $engine (@EJS::Template::JSAdapter::SUPPORTED_ENGINES) {
eval {EJS::Template::JSAdapter->create($engine)};
t/02-engines.t view on Meta::CPAN
'C', 3, sub {'III'},
{str => 'F', num => 6, func => sub {'VI'}},
['G', 7, sub {'VII'}],
],
encoded => $encoded_text,
decoded => $decoded_text,
invalid => $invalid_text,
tainted => $tainted_text,
};
my $config = {engine => $engine};
t/02-engines.t view on Meta::CPAN
no strict 'refs';
my $sanitize_utf8 = ${"EJS::Template::JSAdapter::".$engine."::SANITIZE_UTF8"};
my $preserve_utf8 = ${"EJS::Template::JSAdapter::".$engine."::PRESERVE_UTF8"};
use strict 'refs';
my $decoded_text_expected = ($preserve_utf8 ? $decoded_text : $encoded_text);
my $invalid_text_expected = ($sanitize_utf8 ? $sanitized_text : $invalid_text);
ejs_test('<%= encoded %>', $encoded_text, $variables, $config);
ejs_test('<%= decoded %>', $decoded_text_expected, $variables, $config);
SKIP: {
if ($preserve_utf8) {
ejs_test("<%= '$unicode_notation' %>", $decoded_text, $variables, $config);
} else {
skip "$engine cannot preserve unicode", 1;
}
}
view release on metacpan or search on metacpan
t/00-basic.t view on Meta::CPAN
sub test_enums {
my $elf;
for (qw: executable shared relocatable core :) {
$elf= ELF::Writer->new(type => $_);
is( $elf->type_sym, $_, "enum type=$_ decoded" );
is( $elf->type, $ELF::Writer::type_from_sym{$_}, "enum type=$_ correct value" );
}
$elf= ELF::Writer->new(type => 42);
is( $elf->type, 42, "enum type=42 allowed" );
is( $elf->type_sym, 42, "enum type=42 decoded as self" );
for (qw: 32bit 64bit :) {
$elf= ELF::Writer->new(class => $_);
is( $elf->class_sym, $_, "enum class=$_ decoded" );
is( $elf->class, $ELF::Writer::class_from_sym{$_}, "enum class=$_ correct value" );
}
for (qw: 2LSB 2MSB :) {
$elf= ELF::Writer->new(data => $_);
is( $elf->data_sym, $_, "enum data=$_ decoded" );
is( $elf->data, $ELF::Writer::data_from_sym{$_}, "enum data=$_ correct value" );
}
for (qw: Linux Solaris :) {
$elf= ELF::Writer->new(osabi => $_);
is( $elf->osabi_sym, $_, "enum osabi=$_ decoded" );
is( $elf->osabi, $ELF::Writer::osabi_from_sym{$_}, "enum osabi=$_ correct value" );
}
for (qw: x86-64 :) {
$elf= ELF::Writer->new(machine => $_);
is( $elf->machine_sym, $_, "enum machine=$_ decoded" );
is( $elf->machine, $ELF::Writer::machine_from_sym{$_}, "enum machine=$_ correct value" );
}
for (qw: note :) {
my $seg= ELF::Writer::Segment->new(type => $_);
is( $seg->type_sym, $_, "enum segment.type=$_ decoded" );
is( $seg->type, $ELF::Writer::Segment::type_from_sym{$_}, "enum segment.type=$_ correct value" );
}
};
subtest simple_x86_64_elf => \&test_return_42;
view release on metacpan or search on metacpan
lib/ELab/Client.pm view on Meta::CPAN
file => [ $args{file} ]
},
Content_Type => 'form-data',
Authorization => $self->token(),
);
return decode_json $self->getUseragent()->request($request)->decoded_content();
}
sub upload_to_item {
lib/ELab/Client.pm view on Meta::CPAN
file => [ $args{file} ]
},
Content_Type => 'form-data',
Authorization => $self->token(),
);
return decode_json $self->getUseragent()->request($request)->decoded_content();
}
sub create_event {
view release on metacpan or search on metacpan
lib/EPFL/Net/ipv6Test.pm view on Meta::CPAN
my $ua = p_createUserAgent();
my $url = p_buildUrl( $api, $domain, $withScheme );
my $response = p_getUrl( $ua, $url );
if ( $response->is_success ) {
my $struct = from_json( $response->decoded_content );
return $struct;
}
return;
}
view release on metacpan or search on metacpan
lib/EPFL/Sciper/List.pm view on Meta::CPAN
my $ua = p_createUserAgent();
foreach my $letter (@alphabet) {
my $response = p_getUrl( $ua, p_buildUrl($letter) );
if ( $response->is_success ) {
my $struct = from_json( $response->decoded_content );
push @listPersons, @{ $struct->{result} };
}
}
my %hash = ();
view release on metacpan or search on metacpan
lib/ETL/Yertl/Adapter/graphite.pm view on Meta::CPAN
$url->query_form( %form );
#; say "Fetching $url";
my $res = $self->http_client->GET( $url )->get;
#; say $res->decoded_content;
if ( $res->is_error ) {
die sprintf "Error fetching metric '%s': " . $res->decoded_content . "\n", $metric;
}
my $result = decode_json( $res->decoded_content );
my @points;
for my $series ( @{ $result } ) {
for my $point ( @{ $series->{datapoints} } ) {
push @points, {
metric => $series->{target},
view release on metacpan or search on metacpan
lib/EZID.pm view on Meta::CPAN
my %metadata;
my $ua = LWP::UserAgent->new;
my $r = $ua->get("http://ezid.cdlib.org/id/$identifier");
if ($r->is_success) {
$response = { _parse($r->decoded_content) };
} else {
$self->{_error_msg} = $r->decoded_content;
}
return $response;
}
lib/EZID.pm view on Meta::CPAN
'Content-Type' => "text/plain; charset=UTF-8",
'Content' => $content);
my $response;
if ($r->is_success) {
$response = { _parse($r->decoded_content) };
} else {
$self->{_error_msg} = $r->decoded_content;
}
return $response;
}
view release on metacpan or search on metacpan
lib/Egg/Model/Auth/Crypt/CBC.pm view on Meta::CPAN
=head1 METHODS
=head2 password_check ([CRYPT_PASSWORD], [INPUT_PAWWORD])
CRYPT_PASSWORD is decoded and whether it agrees is confirmed with INPUT_PAWWORD.
=head2 create_password ([PLAIN_PASSWORD])
PLAIN_PASSWORD is encrypted.
view release on metacpan or search on metacpan
lib/Eixo/Rest/Request.pm view on Meta::CPAN
sub send {die ref($_[0]) . "::send: MUST BE DEFINED"}
sub unmarshall{
my ($self, $response) = @_;
my $content = $response->decoded_content(
default_charset=> 'UTF-8'
);
# nowadays (HTTP::Message v6.11)
# decoded_content isn't decoding utf8 charset
# if content_type is application/json
if($response->content_type eq 'application/json'){
use Encode;
$content = Encode::decode('UTF-8', $content);
}
view release on metacpan or search on metacpan
lib/Elastic/Model/Types.pm view on Meta::CPAN
has 'binary_field' => (
is => 'ro',
isa => Binary
);
Inherits from the C<Defined> type. Is automatically Base64 encoded/decoded.
=head2 GeoPoint
use Elastic::Model::Types qw(GeoPoint);
view release on metacpan or search on metacpan
lib/ElasticEmail.pm view on Meta::CPAN
push(@{$allTheData[0]}, ($fieldName, [$file, $localFileName]));
$num++;
}
$response = $ua->post($fullURL, Content_Type => 'multipart/form-data', Content => @allTheData);
}
my $content = $response->decoded_content();
return $content;
}
view release on metacpan or search on metacpan
lib/ElasticSearchX/Model/Generator.pm view on Meta::CPAN
returns the content of the URL at C<mapping_url>
=head2 _build__mapping_data
returns the decoded data from C<JSON> stored in C<_mapping_content>
=head1 AUTHOR
Kent Fredric <kentfredric@gmail.com>
view release on metacpan or search on metacpan
lib/Elastijk.pm view on Meta::CPAN
=head2 Elastijk::request( $args :HashRef ) : ($status :Int, $response :HashRef)
Making a request to the Elasticsearch server specified in C<$args>. It returns 2
values. C<$status> is the HTTP status code of the response, and the C<$response>
decoded as HashRef. Elasticsearch API always respond a single HashRef as JSON
text, this might or might not be changed in the future, if it is changed then
this function will be adjusted accordingly.
The C<$args> is a HashRef takes contains the following key-value pairs:
lib/Elastijk.pm view on Meta::CPAN
=head2 Elastijk::request_raw( $args :HashRef ) : ($status :Int, $response :Str)
Making a request to the Elasticsearch server specified in C<$args>. The main
difference between this function and C<Elastijk::request> is that
C<$args->{body}> s expected to be a String scalar, rather then a HashRef. And
the $response is not decoded from JSON. This function can be used if users wish
to use their own JSON parser to parse response, or if they wish to delay the
parsing to be done latter in some bulk-processing pipeline.
=head1 OBJECT
view release on metacpan or search on metacpan
lib/Email/Abstract.pm view on Meta::CPAN
=head2 as_string
my $string = $email->as_string;
This returns the whole email as a decoded string.
=head2 cast
my $mime_entity = $email->cast('MIME::Entity');
lib/Email/Abstract.pm view on Meta::CPAN
#pod
#pod =head2 as_string
#pod
#pod my $string = $email->as_string;
#pod
#pod This returns the whole email as a decoded string.
#pod
#pod =head2 cast
#pod
#pod my $mime_entity = $email->cast('MIME::Entity');
#pod
view release on metacpan or search on metacpan
# ok( $utf_8 !~ $Email::Address::addr_spec, "...it !~ addr_spec");
}
{
my (@addr) = Email::Address->parse($text);
is(@addr, 0, "unicode (decoded) address: not ok");
# ok( $text =~ $Email::Address::addr_spec, "...it !~ addr_spec");
}
{
view release on metacpan or search on metacpan
lib/Email/Barcode/Decode.pm view on Meta::CPAN
my $ebd = Email::Barcode::Decode->new(email => $msg);
my @symbols = $ebd->get_symbols;
foreach my $symbol (@symbols) {
print(
'decoded ' . $symbol->{type} .
' symbol "' . $symbol->{data} .'"'.
' file "' . $symbol->{filename} .'"'.
"\n"
);
}
view release on metacpan or search on metacpan
t/UTF-8_html.t view on Meta::CPAN
binmode $builder->failure_output, ":encoding(UTF-8)";
binmode $builder->todo_output, ":encoding(UTF-8)";
my $response = LWP::UserAgent->new->get("file://$Bin/data/UTF-8.html");
my $body = $response->decoded_content;
my $from = generate_address('Föö', 'test@foo.example');
my $to = generate_address('Bäz', 'test@baz.example');
my $subject = encode_mimeword(encode_utf8('Sübject'), 'Q', 'UTF-8');
view release on metacpan or search on metacpan
lib/Email/MIME/Encodings.pm view on Meta::CPAN
#pod =head1 SYNOPSIS
#pod
#pod use Email::MIME::Encodings;
#pod my $encoded = Email::MIME::Encodings::encode(base64 => $body);
#pod my $decoded = Email::MIME::Encodings::decode(base64 => $encoded);
#pod
#pod If a third argument is given, it is the encoding to which to fall back. If no
#pod valid codec can be found (considering both the first and third arguments) then
#pod an exception is raised.
#pod
lib/Email/MIME/Encodings.pm view on Meta::CPAN
=head1 SYNOPSIS
use Email::MIME::Encodings;
my $encoded = Email::MIME::Encodings::encode(base64 => $body);
my $decoded = Email::MIME::Encodings::decode(base64 => $encoded);
If a third argument is given, it is the encoding to which to fall back. If no
valid codec can be found (considering both the first and third arguments) then
an exception is raised.
view release on metacpan or search on metacpan
lib/Email/MIME/Kit/Assembler/Markdown.pm view on Meta::CPAN
}
sub assemble {
my ($self, $stash) = @_;
my $markdown = ${ $self->kit->get_decoded_kit_entry( $self->path ) };
my $plaintext = $markdown;
if ($self->renderer) {
{
lib/Email/MIME/Kit/Assembler/Markdown.pm view on Meta::CPAN
for my $type (keys %content) {
my $type_wrapper = "$type\_wrapper";
if (my $wrapper_path = $self->$type_wrapper) {
my $wrapper = ${ $self->kit->get_decoded_kit_entry($wrapper_path) };
if ($self->render_wrapper) {
local $stash->{wrapped_content} = $content{$type};
local $stash->{part_type} = $type;
my $output_ref = $self->renderer->render(\$wrapper, $stash);
view release on metacpan or search on metacpan
lib/Email/MIME/Kit.pm view on Meta::CPAN
#pod render, and so on. This, further, means that strings passed to the C<assemble>
#pod method for use in rendering should also be text strings.
#pod
#pod In older versions of Email::MIME::Kit, files read from disk were read in raw
#pod mode and then handled as octet strings. Meanwhile, the manifest's contents
#pod (and, thus, any templates stored as strings in the manifest) were decoded into
#pod text strings. This could lead to serious problems. For example: the
#pod F<manifest.json> file might contain:
#pod
#pod "header": [
#pod { "Subject": "Message for [% customer_name %]" },
lib/Email/MIME/Kit.pm view on Meta::CPAN
has manifest => (reader => 'manifest', writer => '_set_manifest');
my @auto_attrs = (
[ manifest_reader => ManifestReader => JSON => [ 'read_manifest' ] ],
[ kit_reader => KitReader => Dir => [ 'get_kit_entry',
'get_decoded_kit_entry' ] ],
);
for my $tuple (@auto_attrs) {
my ($attr, $role, $default, $handles) = @$tuple;
lib/Email/MIME/Kit.pm view on Meta::CPAN
render, and so on. This, further, means that strings passed to the C<assemble>
method for use in rendering should also be text strings.
In older versions of Email::MIME::Kit, files read from disk were read in raw
mode and then handled as octet strings. Meanwhile, the manifest's contents
(and, thus, any templates stored as strings in the manifest) were decoded into
text strings. This could lead to serious problems. For example: the
F<manifest.json> file might contain:
"header": [
{ "Subject": "Message for [% customer_name %]" },
view release on metacpan or search on metacpan
t/01_parse.t view on Meta::CPAN
my $mail = Email::MIME::MobileJP::Parser->new($src->as_string);
subtest 'subject' => sub {
is $mail->subject(), 'コンニãƒãƒ¯';
ok Encode::is_utf8($mail->subject), 'decoded';
};
subtest 'carrier' => sub {
isa_ok $mail->carrier, 'Email::Address::JP::Mobile::DoCoMo';
is $mail->carrier->name, 'DoCoMo';
view release on metacpan or search on metacpan
);
for (my $i=0; $i<@tests; $i+=2) {
my ($encoded, $expect) = ($tests[$i], $tests[$i+1]);
my $decoded = $decoder->decode_phrase($encoded);
is($decoded, $expect, "decode_phrase $encoded");
}
view release on metacpan or search on metacpan
lib/Email/MIME.pm view on Meta::CPAN
#pod
#pod use Email::MIME;
#pod my $parsed = Email::MIME->new($message);
#pod
#pod my @parts = $parsed->parts; # These will be Email::MIME objects, too.
#pod my $decoded = $parsed->body;
#pod my $non_decoded = $parsed->body_raw;
#pod
#pod my $content_type = $parsed->content_type;
#pod
#pod ...or...
#pod
lib/Email/MIME.pm view on Meta::CPAN
#pod =head1 DESCRIPTION
#pod
#pod This is an extension of the L<Email::Simple> module, to handle MIME
#pod encoded messages. It takes a message as a string, splits it up into its
#pod constituent parts, and allows you access to various parts of the
#pod message. Headers are decoded from MIME encoding.
#pod
#pod =head1 METHODS
#pod
#pod Please see L<Email::Simple> for the base set of methods. It won't take
#pod very long. Added to that, you have:
lib/Email/MIME.pm view on Meta::CPAN
use Email::MIME;
my $parsed = Email::MIME->new($message);
my @parts = $parsed->parts; # These will be Email::MIME objects, too.
my $decoded = $parsed->body;
my $non_decoded = $parsed->body_raw;
my $content_type = $parsed->content_type;
...or...
lib/Email/MIME.pm view on Meta::CPAN
=head1 DESCRIPTION
This is an extension of the L<Email::Simple> module, to handle MIME
encoded messages. It takes a message as a string, splits it up into its
constituent parts, and allows you access to various parts of the
message. Headers are decoded from MIME encoding.
=head1 PERL VERSION
This library should run on perls released even a long time ago. It should
work on any version of perl released in the last five years.
lib/Email/MIME.pm view on Meta::CPAN
=head2 header_str_pairs
my @pairs = $email->header_str_pairs;
This method behaves like C<header_raw_pairs>, returning a list of field
name/value pairs, but the values have been decoded to character strings, when
possible.
=head2 header_as_obj
my $first_obj = $email->header_as_obj($field);
lib/Email/MIME.pm view on Meta::CPAN
#pod =method header_str_pairs
#pod
#pod my @pairs = $email->header_str_pairs;
#pod
#pod This method behaves like C<header_raw_pairs>, returning a list of field
#pod name/value pairs, but the values have been decoded to character strings, when
#pod possible.
#pod
#pod =method header_as_obj
#pod
#pod my $first_obj = $email->header_as_obj($field);