view release on metacpan or search on metacpan
share/assets/dash_core_components/async~markdown.js.map view on Meta::CPAN
{"version":3,"sources":["webpack:///./node_modules/is-whitespace-character/index.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/trim/index.js","webpack:///./node_modules/is-decimal/index.js","webpack:///./node_modules/u...
view release on metacpan or search on metacpan
lib/Data/Apache/mod_status.pm view on Meta::CPAN
my $response = $ua->get($url);
die 'failed to fetch "', $url, '" - '.$response->status_line
if $response->is_error();
# tidy mod_status page to be xhtml document
return $response->decoded_content;
}
"Zed's Dead, baby";
view release on metacpan or search on metacpan
lib/Data/BISON/Decoder.pm view on Meta::CPAN
Create a new Data::BISON::Encoder.
=item C<< decode >>
Decode BISON serialized data. The data to be decoded may optionally have
been yEnc encoded; C<decode> will detect this and perform the
appropriate decoding.
The returned value is a scalar, hash reference or array reference.
view release on metacpan or search on metacpan
lib/Data/Binary.pm view on Meta::CPAN
my $length = length($string);
my $odd = ($string =~ tr/\x01\x02\x03\x04\x05\x06\x07\x09\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f//d);
# Detecting >=128 and non-UTF-8 is interesting. Note that all UTF-8 >=128 has several bytes with
# >=128 set, so a quick test is possible by simply checking if any are >=128. However, the count
# from that is typically wrong, if this is binary data, it'll not have been decoded. So we do this
# in two steps.
my $copy = $string;
if (($copy =~ tr[\x80-\xff][]d) > 0) {
my $modified = decode_utf8($string, Encode::FB_DEFAULT);
view release on metacpan or search on metacpan
examples/integercoding.pl view on Meta::CPAN
$str = encode_delta(8); # die unless $str eq '00100000';
$str = encode_omega(8); # die unless $str eq '1110000';
$str = encode_fib(8); # die unless $str eq '000011';
The C<decode_> methods take a single binary string as input and produce an
unsigned integer output decoded from the bit encoding.
$n = decode_unary('000000000000001'); # die unless $n == 14;
$n = decode_gamma('0001110'); # die unless $n == 14;
$n = decode_delta('00100110'); # die unless $n == 14;
$n = decode_omega('1111100'); # die unless $n == 14;
view release on metacpan or search on metacpan
examples/compression-code.pl view on Meta::CPAN
my $e1 = int(tv_interval($s1)*1_000_000);
my $s2 = [gettimeofday];
@list = $stream->get_unary(-1);
my $e2 = int(tv_interval($s2)*1_000_000);
$listn = scalar @list;
printf "Slurped $listn numbers in %.1f ms, decoded in %.1f ms\n", $e1/1000,$e2/1000;
}
# average value
my $avg = int( ((sum @list) / $listn) + 0.5);
# bytes required in fixed size (FOR encoding)
view release on metacpan or search on metacpan
=over 4
=item _ReturnMap = 1 unless exists
_ReturnMap says that returns embedded in fields should be decoded on
read() and encoded again on write(). The industry-standard encoding
for embedded returns is ^K (ascii 11 -- but see next setting to change
it). This defaults to true but can be turned off if you want data
untouched by read(). This setting has no effect on data files where
no fields contain embedded returns. However, it is vital to leave
this option ON when writing any data file whose fields could contain
embedded returns -- if you have such data and call write() with
_ReturnMap turned off, the resulting file will be an invalid Merge/CSV
file and might not be re-readable.
When these fields are decoded on read(), encoded returns are converted
to C<"\n"> in memory, whatever its interpretation may be on the current
platform (\x0A on Unix or DOS; \x0D on MacPerl).
IMPORTANT NOTE: When these fields are encoded by write(), any
occurrence of the current _LineEnding being used to write the file is
view release on metacpan or search on metacpan
lib/Data/ChipsChallenge.pm view on Meta::CPAN
Given the encoded level password in raw binary (4 bytes followed by a null byte),
this function returns the 4 ASCII byte password in clear text. This is the password
you'd type into Chip's Challenge.
Passwords are decoded by XORing the values in the raw binary by hex C<0x99>,
if you're curious.
=cut
sub decode_password {
view release on metacpan or search on metacpan
lib/Data/CompactReadonly.pm view on Meta::CPAN
This is not yet implemented for Arrays.
=back
Returns the "root node" of the database. If that root node is a number, some
piece of text, True, False, or Null, then it is decoded and the value returned. Otherwise an
object (possibly a tied object) representing an Array or a Dictionary is returned.
=head1 OBJECTS
If you asked for normal objects to be returned instead of tied objects, then
lib/Data/CompactReadonly.pm view on Meta::CPAN
=head1 UNSUPPORTED PERL TYPES
Globs, Regexes, References (except to Arrays and Dictionaries).
Booleans are only supported on perl version 5.35.7 or later. On earlier perls, a
Boolean in the database will be decoded as a true or false I<value>, but its type
will be numeric or string. And a older perls will never write a True or False node
to the database, they'll always write numbers or strings with true/false values,
which other implementations will decode as numbers or strings.
=head1 BUGS/FEEDBACK
view release on metacpan or search on metacpan
lib/Data/Decode.pm view on Meta::CPAN
use Data::Decode;
my $decoder = Data::Decode->new(
strategy => Data::Decode::Encode::Guess->new()
);
my $decoded = $decoder->decode($data);
=head1 DESCRIPTION
WARNING: Alpha grade software.
lib/Data/Decode.pm view on Meta::CPAN
=item strategy
Required. Takes in the object that encapsulates the actual decoding logic.
The object must have a method named "decode", which takes in a reference
to the Data::Decode object and a string to be decoded. An optional third
parameter may be provided to specify any hints that could be used to figure
out what to do.
sub decode {
my ($self, $decoder, $string, $hints) = @_;
# $decoder = Data::Decode object
# $string = a scalar to be decoded
# $hints = a hashref of hints
}
=back
view release on metacpan or search on metacpan
t/10_basic.t view on Meta::CPAN
use strict;
use warnings;
use Test::More tests => 5;
# encoded/decoded Japanese hiragana (a)
my $str = "\x{3042}";
my $char = "\x{82}\x{A0}";
my $data = {str => $str, array => [$str]};
my $re = qr/\\x\{[^\}]+\}/;
view release on metacpan or search on metacpan
lib/Data/Dumper/AutoEncode.pm view on Meta::CPAN
=head2 BEFORE_HOOK / AFTER_HOOK
Set code ref for hooks which excuted around encoding
$Data::Dumper::AutoEncode::BEFORE_HOOK = sub {
my $value = $_[0]; # decoded
$value =~ s/\x{2019}/'/g;
return $value;
};
$Data::Dumper::AutoEncode::AFTER_HOOK = sub {
lib/Data/Dumper/AutoEncode.pm view on Meta::CPAN
return $value;
};
=head2 CHECK_ALREADY_ENCODED : false
If you set this option true value, check a target before encoding. And do encode in case of decoded value.
=head2 DO_NOT_PROCESS_NUMERIC_VALUE : true
By default, numeric values are ignored (do nothing).
view release on metacpan or search on metacpan
lib/Data/Dumper/Interp.pm view on Meta::CPAN
C<< use open IO => ':locale'; >> or otherwise arrange to
encode the output for your terminal.
You'll also want C<< use utf8; >> if your Perl source
contains characters outside the ASCII range.
Undecoded binary octets (e.g. data read from a 'binmode' file)
will still be escaped as individual bytes.
=item *
Depending on options, spaces·may·be·shown·visibly
view release on metacpan or search on metacpan
lib/Data/Edit/Xml/Xref.pm view on Meta::CPAN
{my ($xref, $file, $href) = @_; # Cross referencer, file containing reference, reference
my $fileExists = sub # Check that the specified file exists by looking for the topic id which L<Dita> guarantees will exist
{my ($file) = @_; # File to check
return 1 if $xref->topicIds->{$file}; # File exists
my $decodedTarget = wwwDecode($file); # Decode file name by expanding % signs to see if we can get a match
return 2 if $xref->topicIds->{$decodedTarget}; # File exists after decoding % signs
return 3 if -e $file; # Images
undef # Cannot locate file
};
if ($href =~ m(#)) # Full Dita href
view release on metacpan or search on metacpan
lib/Data/Encoder.pm view on Meta::CPAN
=item my $encoded = $encoder->encode($stuff [, @args]);
The module SHOULD have a C<<encode>> method.
=item my $decoded = $encoder->decode($stuff [, @args]);
The module SHOULD have a C<<decod>> method.
=back
view release on metacpan or search on metacpan
t/Data-FastPack-JPacker.t view on Meta::CPAN
my $count=5;
my $encoded="";
encode_fastpack($encoded,[[0,1,$_]]) for(1..$count);
my $encoded_copy=$encoded;
my @decoded;
decode_fastpack($encoded_copy, \@decoded);
ok (@decoded == $count);
#use Data::Dumper;
#use feature ":all";
#say STDERR Dumper @decoded;
use File::Temp qw<mktemp>;
# Write to file
my $input=mktemp("fastpackXXXXXXXX");;
view release on metacpan or search on metacpan
lib/Data/FastPack.pm view on Meta::CPAN
Buffer is aliased and is an in/out parameter
Decoded messages are added to the dereferenced output array
An optional limit of message count can be specified.
Returns the number of bytes consumed during decoding. I a message could not be
decoded, 0 bytes are consumed.
buffer (aliased)
output (array ref)
limit (numeric)
view release on metacpan or search on metacpan
lib/Data/Feed.pm view on Meta::CPAN
or Carp::confess(
"Failed to fetch URI $stream: " . $res->status_line );
if ( $res->code == 410 ) {
Carp::confess("This feed has been permanently removed");
}
$content = $res->decoded_content;
}
elsif ( $ref eq 'SCALAR' ) {
$content = $$stream;
}
elsif ( $ref eq 'GLOB' ) {
view release on metacpan or search on metacpan
lib/Data/HexConverter.pm view on Meta::CPAN
=head1 FUNCTIONS
=head2 hex_to_binary(\$hexstr)
Takes a reference to a hex string, returns the decoded binary string.
=head2 binary_to_hex(\$binstr)
Takes a reference to a binary string, returns the hex encoded string.
view release on metacpan or search on metacpan
lib/Data/ICal/RDF.pm view on Meta::CPAN
# for some reason base64 is not built into Data::ICal.
return MIME::Base64::decode($prop->value);
}
elsif ($enc eq 'QUOTED-PRINTABLE') {
# QP *is* built in, however.
return $prop->decoded_value;
}
else {
return;
}
}
view release on metacpan or search on metacpan
lib/Data/ICal/Property.pm view on Meta::CPAN
You shouldn't need to create L<Data::ICal::Property> values directly
-- just use C<add_property> in L<Data::ICal::Entry>.
The C<encoding> parameter value is only interpreted by L<Data::ICal>
in the C<decoded_value> and C<encode> methods: all other methods
access the encoded version directly (if there is an encoding).
Currently, the only supported encoding is C<QUOTED-PRINTABLE>.
=head1 METHODS
lib/Data/ICal/Property.pm view on Meta::CPAN
return $dec;
}
},
);
=head2 decoded_value
Gets the value of this property, converted from the encoding specified
in its encoding parameter. (That is, C<value> will return the encoded
version; this will apply the encoding.) If the encoding is not
specified or recognized, just returns the raw value.
=cut
sub decoded_value {
my $self = shift;
my $value = $self->value;
my $encoding = uc( $self->parameters->{'ENCODING'} || "" );
if ( $ENCODINGS{$encoding} ) {
lib/Data/ICal/Property.pm view on Meta::CPAN
}
}
=head2 encode $encoding
Calls C<decoded_value> to get the current decoded value, then encodes
it in C<$encoding>, sets the value to that, and sets the encoding
parameter to C<$encoding>. (C<$encoding> is first converted to upper
case.)
If C<$encoding> is undef, deletes the encoding parameter and sets the
value to the decoded value. Does nothing if the encoding is not
recognized.
=cut
sub encode {
my $self = shift;
my $encoding = uc shift;
my $decoded_value = $self->decoded_value;
if ( not defined $encoding ) {
$self->value($decoded_value);
delete $self->parameters->{'ENCODING'};
} elsif ( $ENCODINGS{$encoding} ) {
$self->value( $ENCODINGS{$encoding}{'encode'}->($decoded_value) );
$self->parameters->{'ENCODING'} = $encoding;
}
return $self;
}
view release on metacpan or search on metacpan
lib/Data/JPack.pm view on Meta::CPAN
$pairs{$_}=~/"(.*)"/;
$compression=$1;
}
}
my $decoded;
my $output="";
for($compression){
if(/deflate/){
$decoded=decode_base64($data);
rawinflate(\$decoded, \$output) or die $RawInflateError;
}
else {
$output=decode_base64($data);
}
}
view release on metacpan or search on metacpan
lib/Data/Localize.pm view on Meta::CPAN
# using the key ('Hello, [_1]') as the localization token.
print $loc->localize('Hello, [_1]', 'John Doe'), "\n";
=head1 UTF8
All data is expected to be in decoded utf8. You must "use utf8" or
decode them to Perl's internal representation for all values
passed to Data::Localizer. We won't try to be smart for you. USE UTF8!
=over 4
view release on metacpan or search on metacpan
$count++;
is $stream->data, 'hoge', 'data ok';
}
}
is $count, 100, 'decoded count ok';
}
{
# New specification: Str type
my $utf8_mp = Data::MessagePack->new->utf8;
view release on metacpan or search on metacpan
t/15_utf8.t view on Meta::CPAN
for(1 .. 2) {
ok $u->get_utf8();
$p = $u->execute($packed, $p);
my $d = $u->data();
$u->reset();
is_deeply $d, $data, 'decoded';
}
is $u->utf8(0), $u, 'utf8(0)';
$p = 0;
for(1 .. 2) {
t/15_utf8.t view on Meta::CPAN
$p = $u->execute($packed, $p);
my $d = $u->data();
$u->reset();
my $s = $data->[3];
utf8::encode($s);
is_deeply $d->[3], $s, 'not decoded';
}
done_testing;
view release on metacpan or search on metacpan
lib/Data/OFAC/SDN.pm view on Meta::CPAN
$lwp->env_proxy;
my $rsp = $lwp->get(SDNURL);
if ( $rsp->is_success ) {
$self->buildDatabase( $rsp->decoded_content );
}
else {
$self->{_status} = 'dirty';
}
view release on metacpan or search on metacpan
lib/Data/OpenGraph.pm view on Meta::CPAN
my $ua = LWP::UserAgent->new();
my $res = $ua->get( $uri );
if (! $res->is_success) {
Carp::croak( "Failed to get $uri: " . $res->status_line);
}
return $class->parse_string( $res->decoded_content );
} else {
Carp::croak( "No applicable UserAgent (such as LWP::UserAgent) found" );
}
}
lib/Data/OpenGraph.pm view on Meta::CPAN
my $og = Data::OpenGraph->parse_uri( "http://some.content/with/opengraph.html" );
my $ua = LWP::UserAgent->new();
my $res = $ua->get( "http://some.content/with/opengraph.html" );
my $og = Data::OpenGraph->parse_uri( $res->decoded_content );
my $title = $og->property( "title" );
my $type = $og->property( "type" );
=head1 DESCRIPTION
view release on metacpan or search on metacpan
t/04encodings.t view on Meta::CPAN
$ch = "\x{05D0}"; # the letter "Alef" in hebrew, in unicode
$oc = "\xE0"; # the same in iso-8859-8
ok( $s->build($ch) eq $oc, "Char hebrew: Build: simple");
ok( $s->parse($oc) eq $ch, "Char hebrew: Parse: simple");
my $love_decoded = "\x{05D0}\x{05D4}\x{05D1}\x{05D4}";
my $love_encoded = "\xd7\x90\xd7\x94\xd7\x91\xd7\x94";
$s = PaddedString("foo", 10, encoding => "utf8", padchar => "\0");
$oc = $love_encoded."\0\0";
ok( $s->build($love_decoded) eq $oc, "String: Build: love");
ok( $s->parse($oc) eq $love_decoded, "String: Parse: love");
$s = PascalString("foo", undef, "utf8");
$oc = "\x04".$love_encoded;
ok( $s->build($love_decoded) eq $oc, "PascalString: Build: love");
ok( $s->parse($oc) eq $love_decoded, "PascalString: Parse: love");
$s = CString("foo", encoding => "utf8");
$oc = $love_encoded."\0";
ok( $s->build($love_decoded) eq $oc, "CString: Build: love");
ok( $s->parse($oc) eq $love_decoded, "CString: Parse: love");
view release on metacpan or search on metacpan
share/dictionary.txt view on Meta::CPAN
declining
declivities
declivity
declivity's
decode
decoded
decoder
decoder's
decodes
decoding
decolletes
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/English.pm view on Meta::CPAN
'decisions' => 1465,
'deck' => 1921,
'decked' => 10339,
'declare' => 3272,
'decode' => 11109,
'decoded' => 13804,
'decoder' => 11397,
'decompose' => 18327,
'decomposed' => 14333,
'decomposing' => 12047,
'decompress' => 17301,