Result:
found more than 907 distributions - search limited to the first 2001 files matching your query
( run in 0.892 )
CGI-Lite
view release on metacpan or search on metacpan
lib/CGI/Lite.pm view on Meta::CPAN
=head2 parse_form_data
This handles the following types of requests: GET, HEAD and POST.
By default, CGI::Lite uses the environment variable REQUEST_METHOD to
determine the manner in which the query/form information should be
decoded. However, it may also be passed a valid request
method as a scalar string to force CGI::Lite to decode the information in
a specific manner.
my $params = $cgi->parse_form_data ('GET');
lib/CGI/Lite.pm view on Meta::CPAN
=head2 url_decode
This method is used to URL-decode a string.
$decoded_string = $cgi->url_decode ($string);
Returns the URL-decoded string.
=head2 is_dangerous
This method checks for the existence of dangerous meta-characters.
CGI-Minimal
view release on metacpan or search on metacpan
lib/CGI/Minimal.pod view on Meta::CPAN
=over 4
=item url_decode($string);
Returns URL *decoding* of input string (%xx and %uxxxx substitutions
are decoded to their actual values).
Example:
my $url_decoded_string = $cgi->url_decode($string);
=back
=cut
CGI-MxScreen
view release on metacpan or search on metacpan
MxScreen/Session/Medium/Browser.pm view on Meta::CPAN
require MIME::Base64;
require Crypt::CBC;
require Digest::MD5;
my $decoded = MIME::Base64::decode(CGI::param(MX_CONTEXT));
my $cipher = new Crypt::CBC($self->key, CRYPT_ALGO);
my $decrypted = $cipher->decrypt($decoded);
CGI::delete(MX_CONTEXT);
#
# Before attempting to de-serialize, check the MD5 certificate.
# Deserialization would fail anyway if the context was "corrupted".
CGI-PathInfo
view release on metacpan or search on metacpan
lib/CGI/PathInfo.pod view on Meta::CPAN
=over 4
=item url_decode($string);
Returns URL *decoding* of input string (%xx substitutions
are decoded to their actual values).
Example:
my $url_decoded_string = $path_info->url_decode($string);
=back
=head1 BUGS
CGI-Pure
view release on metacpan or search on metacpan
# Value processing.
my $value;
if ($self->{'utf8'}) {
if (ref $pairs_hr->{$key} eq 'ARRAY') {
my @decoded = ();
foreach my $val (@{$pairs_hr->{$key}}) {
push @decoded, decode_utf8($val);
}
$value = \@decoded;
} else {
$value = decode_utf8($pairs_hr->{$key});
}
} else {
$value = $pairs_hr->{$key};
CGI-SecureState
view release on metacpan or search on metacpan
SecureState.pm view on Meta::CPAN
sub decipher
{
my $self = shift;
my ($cipher,$statefile) = @$self{'.cipher','.statefile'};
my ($length,$extra,$decoded,$buffer,$block);
if ($AVOID_SYMLINKS) { -l $statefile and $self->errormsg('symlink encountered')}
sysopen(STATEFILE,$statefile, O_RDONLY) || $self->errormsg('failed to open the state file');
if ($USE_FLOCK) { flock(STATEFILE, LOCK_SH) || $self->errormsg('failed to lock the state file') }
binmode STATEFILE;
SecureState.pm view on Meta::CPAN
#parse metadata
$block^=$buffer;
$self->{'.age'} = unpack("N",substr($block,4,4));
$length = unpack("N",substr($block,0,4));
$extra = ($length % 8) ? (8-($length % 8)) : 0;
$decoded=-8;
#sanity check
if ((stat(STATEFILE))[7] != ($length+$extra+8))
{ $self->errormsg('invalid state file') }
SecureState.pm view on Meta::CPAN
{ $self->errormsg('invalid state file') }
my $next_block;
$block = $cipher->decrypt(substr($buffer,0,8));
#decrypt it
while (($decoded+=8)<$length-8) {
$next_block = substr($buffer,$decoded+8,8);
$block^=$next_block;
substr($buffer, $decoded, 8, $block);
$block=$cipher->decrypt($next_block);
}
substr($buffer, $decoded, 8, $block);
substr($buffer, -$extra, $extra, "");
}
if ($USE_FLOCK) { flock(STATEFILE, LOCK_UN) || $self->errormsg('failed to unlock the state file') }
close(STATEFILE) || $self->errormsg('failed to close the state file');
CGI-Simple
view release on metacpan or search on metacpan
lib/CGI/Simple.pm view on Meta::CPAN
# short and sweet upload
$ok = $q->upload( $q->param('upload_file'), '/path/to/write/file.name' );
print "Uploaded ".$q->param('upload_file')." and wrote it OK!" if $ok;
$decoded = $q->url_decode($encoded);
$encoded = $q->url_encode($unencoded);
$escaped = $q->escapeHTML('<>"&');
$unescaped = $q->unescapeHTML('<>"&');
$qs = $q->query_string; # get all data in $q as a query string OK for GET
lib/CGI/Simple.pm view on Meta::CPAN
=head2 url_decode() Decode a URL encoded string
This method will correctly decode a url encoded string.
$decoded = $q->url_decode( $encoded );
=head2 url_encode() URL encode a string
This method will correctly URL encode a string.
CGI-Test-Input-Custom
view release on metacpan or search on metacpan
lib/CGI/Test/Input/Custom.pm view on Meta::CPAN
sub new {
my ($class, %args) = @_;
my $this = bless {}, $class;
$this->_init;
$this->{_ctic_mime_type} = _firstdef(delete $args{-mime_type}, 'application/octet-stream');
$this->{_data_decoded} = _firstdef(delete $args{-content}, '');
$this->{_encoding} = _firstdef(delete $args{-encoding}, 'utf8');
%args and croak "unsupported constructor argument(s) ".join(', ', keys %args);
$this->{stale} = 1;
$this;
}
lib/CGI/Test/Input/Custom.pm view on Meta::CPAN
sub mime_type { shift->{_ctic_mime_type} }
sub _build_data {
my $this = shift;
encode($this->{_encoding}, $this->{_data_decoded})
}
sub add_content {
my $this = shift;
$this->{_data_decoded} .= join('', @_);
$this->{stale} = 1;
}
CGI-Tiny
view release on metacpan or search on metacpan
$cgi = $cgi->set_multipart_form_charset('UTF-8');
Sets the default charset for decoding multipart/form-data forms,
defaults to UTF-8. Parameter and upload field names, upload filenames,
and text parameter values that don't specify a charset will be decoded
from this charset. Set to an empty string to disable this decoding,
effectively interpreting such values in ISO-8859-1.
set_input_handle
Retrieve URL query string parameters and
application/x-www-form-urlencoded or multipart/form-data body
parameters as an ordered array reference of name/value pairs,
represented as two-element array references. Names and values are
decoded to Unicode characters.
Query parameters are returned first, followed by body parameters. Use
"query_params" or "body_params" to retrieve query or body parameters
separately.
my $arrayref = $cgi->param_names;
Retrieve URL query string parameter names and
application/x-www-form-urlencoded or multipart/form-data body parameter
names, decoded to Unicode characters, as an ordered array reference,
without duplication.
Query parameter names are returned first, followed by body parameter
names. Use "query_param_names" or "body_param_names" to retrieve query
or body parameter names separately.
my $value = $cgi->param('foo');
Retrieve value of a named URL query string parameter or
application/x-www-form-urlencoded or multipart/form-data body
parameter, decoded to Unicode characters.
If the parameter name was passed multiple times, returns the last body
parameter value if any, otherwise the last query parameter value. Use
"param_array" to get multiple values of a parameter, or "query_param"
or "body_param" to retrieve the last query or body parameter value
my $arrayref = $cgi->param_array('foo');
Retrieve values of a named URL query string parameter or
application/x-www-form-urlencoded or multipart/form-data body
parameter, decoded to Unicode characters, as an ordered array
reference.
Query parameter values will be returned first, followed by body
parameter values. Use "query_param_array" or "body_param_array" to
retrieve query or body parameter values separately.
my $pairs = $cgi->query_params;
Retrieve URL query string parameters as an ordered array reference of
name/value pairs, represented as two-element array references. Names
and values are decoded to Unicode characters.
query_param_names
my $arrayref = $cgi->query_param_names;
Retrieve URL query string parameter names, decoded to Unicode
characters, as an ordered array reference, without duplication.
query_param
my $value = $cgi->query_param('foo');
Retrieve value of a named URL query string parameter, decoded to
Unicode characters.
If the parameter name was passed multiple times, returns the last
value. Use "query_param_array" to get multiple values of a parameter.
query_param_array
my $arrayref = $cgi->query_param_array('foo');
Retrieve values of a named URL query string parameter, decoded to
Unicode characters, as an ordered array reference.
body
my $bytes = $cgi->body;
my $pairs = $cgi->body_params;
Retrieve application/x-www-form-urlencoded or multipart/form-data body
parameters as an ordered array reference of name/value pairs,
represented as two-element array references. Names and values are
decoded to Unicode characters.
NOTE: This will read the text form fields into memory, so make sure the
"set_request_body_limit" can fit well within the available memory.
multipart/form-data file uploads will be streamed to temporary files
accessible via "uploads" and related methods.
body_param_names
my $arrayref = $cgi->body_param_names;
Retrieve application/x-www-form-urlencoded or multipart/form-data body
parameter names, decoded to Unicode characters, as an ordered array
reference, without duplication.
NOTE: This will read the text form fields into memory as in
"body_params".
body_param
my $value = $cgi->body_param('foo');
Retrieve value of a named application/x-www-form-urlencoded or
multipart/form-data body parameter, decoded to Unicode characters.
If the parameter name was passed multiple times, returns the last
value. Use "body_param_array" to get multiple values of a parameter.
NOTE: This will read the text form fields into memory as in
body_param_array
my $arrayref = $cgi->body_param_array('foo');
Retrieve values of a named application/x-www-form-urlencoded or
multipart/form-data body parameter, decoded to Unicode characters, as
an ordered array reference.
NOTE: This will read the text form fields into memory as in
"body_params".
my $pairs = $cgi->uploads;
Retrieve multipart/form-data file uploads as an ordered array reference
of name/upload pairs, represented as two-element array references.
Names are decoded to Unicode characters.
NOTE: This will read the text form fields into memory, so make sure the
"set_request_body_limit" can fit well within the available memory.
File uploads are represented as a hash reference containing the
upload_names
my $arrayref = $cgi->upload_names;
Retrieve multipart/form-data file upload names, decoded to Unicode
characters, as an ordered array reference, without duplication.
NOTE: This will read the text form fields into memory as in "uploads".
upload
date string if not set manually.
If the "request_method" is HEAD, any provided response content will be
ignored (other than redirect URLs) and Content-Length will be set to 0.
text, html, or xml data is expected to be decoded Unicode characters,
and will be encoded according to "set_response_charset" (UTF-8 by
default). Unicode::UTF8 will be used for efficient UTF-8 encoding if
available.
json data structures will be encoded to JSON and UTF-8.
date string if not set manually.
If the "request_method" is HEAD, any provided response content will be
ignored.
text, html, or xml data is expected to be decoded Unicode characters,
and will be encoded according to "set_response_charset" (UTF-8 by
default). Unicode::UTF8 will be used for efficient UTF-8 encoding if
available.
json data structures will be encoded to JSON and UTF-8.
CGI-Untaint-Facebook
view release on metacpan or search on metacpan
lib/CGI/Untaint/Facebook.pm view on Meta::CPAN
# was a timeout
carp "$url: ", $webdoc->status_line();
}
return 0;
}
my $response = $browser->decoded_content();
if($response =~ /This content isn't available at the moment/mis) {
return 0;
}
return 1;
}
CGI-Utils
view release on metacpan or search on metacpan
lib/CGI/Utils.pm view on Meta::CPAN
=pod
=head2 urlDecode($url_encoded_str)
Returns the decoded version of the given URL-encoded string.
Aliases: url_decode()
=cut
sub urlDecode {
lib/CGI/Utils.pm view on Meta::CPAN
=pod
=head2 urlUnicodeDecode($url_encoded_str)
Returns the decoded version of the given URL-encoded string,
with unicode support.
Aliases: url_unicode_decode()
=cut
CGI-Widget-DBI-Browse
view release on metacpan or search on metacpan
lib/CGI/Widget/DBI/Browse.pm view on Meta::CPAN
$col_found = 1;
last;
}
}
my $extra_vars = $self->{ws}->extra_vars_for_uri([ @{ $self->{'filter_columns'} }, '_browse_skip_to_results_', @exclude_params ]);
my $category_decoded = $self->decode_utf8($row->{$category_col});
return $col_found
? '<a href="?'.join('&', (map { _uri_param_pair($_, $self->decode_utf8($row->{$_})) } @cols), $extra_vars || ()).'" id="jumpToCategoryLink">'
.$category_decoded.'</a>'
: $category_decoded;
}
sub _category_columndata_closure {
my ($self, $category_col) = @_;
my $existing_category_filters =
lib/CGI/Widget/DBI/Browse.pm view on Meta::CPAN
my $before_link_closure = $self->{-category_before_link_closures}->{$category_col};
my $column_closure = $self->{-category_column_closures}->{$category_col};
my @filter_columns = @{ $self->{'filter_columns'} };
return sub {
my ($sd, $row) = @_;
my $category_decoded = $sd->decode_utf8($row->{$category_col}) || '(empty)';
my $category_display_value = ref $column_closure eq 'CODE' ? $column_closure->($sd, $row) : $category_decoded;
my $extra_vars = $sd->extra_vars_for_uri([ @filter_columns, '_browse_skip_to_results_' ]);
return ($before_link_closure ? $before_link_closure->($sd, $row) : '').'<a href="?'.join(
'&', $existing_category_filters || (),
_uri_param_pair($category_col, $category_decoded),
$extra_vars || (),
).'" id="categoryNavLink-'.CGI::escapeHTML($category_decoded).'">'.$category_display_value.'</a>'; # TODO: HTML::Escape is faster than CGI
};
}
1;
CGI_Lite
view release on metacpan or search on metacpan
CGI_Lite.pm view on Meta::CPAN
$cgi->create_variables ($form);
$escaped_string = browser_escape ($string);
$encoded_string = url_encode ($string);
$decoded_string = url_decode ($string);
$status = is_dangerous ($string);
$safe_string = escape_dangerous_chars ($string);
=head1 DESCRIPTION
CGI_Lite.pm view on Meta::CPAN
=item B<parse_form_data>
This will handle the following types of requests: GET, HEAD and POST.
By default, CGI_Lite uses the environment variable REQUEST_METHOD to
determine the manner in which the query/form information should be
decoded. However, as of v1.8, you are allowed to pass a valid request
method to this function to force CGI_Lite to decode the information in
a specific manner.
For multipart/form-data, uploaded files are stored in the user selected
directory (see B<set_directory>). If timestamp mode is on (see
CGI_Lite.pm view on Meta::CPAN
You can use this method to URL decode a string.
I<Return Value>
URL decoded string.
=item B<is_dangerous>
This method checks for the existence of dangerous meta-characters.
CHI
view release on metacpan or search on metacpan
deserialized after retrieving - see L</serializer>.
=item *
Values with their utf8 flag on are utf8 encoded before storing, and utf8
decoded after retrieving.
=back
=head1 SUBCACHES
CLI-Dispatch
view release on metacpan or search on metacpan
lib/CLI/Dispatch/Command.pm view on Meta::CPAN
$self->log( info => 'going to convert encoding' );
# debug message will be printed only when "debug" option is set
$self->log( debug => 'going to convert encoding' );
my $decoded = decode( $self->option('from'), $args[0] );
print encode( $self->option('to'), $decoded );
}
1;
__END__
CLI-Startup
view release on metacpan or search on metacpan
Debian_CPANTS.txt view on Meta::CPAN
"libwww-facebook-api-perl", "WWW-Facebook-API", "0.4.18", "2", "3"
"libwww-freshmeat-perl", "WWW-Freshmeat", "0.21", "0", "1"
"libwww-google-auth-clientlogin-perl", "WWW-Google-Auth-ClientLogin", "0.04", "0", "0"
"libwww-google-calculator-perl", "WWW-Google-Calculator", "0.07", "0", "0"
"libwww-mechanize-autopager-perl", "WWW-Mechanize-AutoPager", "0.02", "0", "0"
"libwww-mechanize-decodedcontent-perl", "WWW-Mechanize-DecodedContent", "0.02", "1", "0"
"libwww-mechanize-formfiller-perl", "WWW-Mechanize-FormFiller", "0.10", "0", "1"
"libwww-mechanize-gzip-perl", "WWW-Mechanize-GZip", "0.12", "0", "0"
"libwww-mechanize-perl", "WWW-Mechanize", "1.68", "0", "1"
"libwww-mechanize-shell-perl", "WWW-Mechanize-Shell", "0.52", "0", "0"
"libwww-mechanize-treebuilder-perl", "WWW-Mechanize-TreeBuilder", "1.10003", "0", "2"
COPS-Client
view release on metacpan or search on metacpan
lib/COPS/Client.pm view on Meta::CPAN
CableLabs-Event-Message
CableLabs-QoS-Descriptor
When called this function returns the converted attribute into a hash of the attributes
found and decoded.
An example of use would be
my %return_data;
lib/COPS/Client.pm view on Meta::CPAN
my ( $class , $attr ) =@_;
my ( %template );
my ( %current_data );
my ( %complete_decoded_data );
my ( %handles );
$self->{_GLOBAL}{'DEBUG'}=0;
while (my($field, $val) = splice(@{$attr}, 0, 2))
lib/COPS/Client.pm view on Meta::CPAN
$self->{_GLOBAL}{'OpaqueData'}="";
$self->{_GLOBAL}{'RKS_Encoded'}="";
$self->{_GLOBAL}{'template'}= \%template;
$self->{_GLOBAL}{'current_data'}= \%current_data;
$self->{_GLOBAL}{'complete_decoded_data'} = \%complete_decoded_data;
$self->{_GLOBAL}{'Listener_HandlesP'}= \%handles;
return $self;
}
lib/COPS/Client.pm view on Meta::CPAN
waitpid($child,0);
exit(0);
}
if ( ${$handles}{$handle}{'addr'} )
{
if ( $self->{_GLOBAL}{'complete_decoded_data'}{ ${$handles}{$handle}{'addr'} } )
{ undef $self->{_GLOBAL}{'complete_decoded_data'}{ ${$handles}{$handle}{'addr'} }; }
}
delete ${$handles}{$handle};
$self->{_GLOBAL}{'Listen_Selector'}->remove($handle);
$handle->close();
}
lib/COPS/Client.pm view on Meta::CPAN
{
$decode_data = $self-> decode_cops_message ( $decode_data );
}
print "all cops messages decoded.\n" if $self->{_GLOBAL}{'DEBUG'}>0;
$self->{_GLOBAL}{'message_client_id'} = $client_id;
$self->{_GLOBAL}{'message_opcode'} = $opcode;
$self->{_GLOBAL}{'data_received'} = substr( $self->{_GLOBAL}{'data_received'}, $total_length, length($self->{_GLOBAL}{'data_received'})-$total_length);
CORBA-JAVA
view release on metacpan or search on metacpan
javaxml/XMLInputStreamImpl.java view on Meta::CPAN
private int column; // current column number
private int sourceType; // type of input source
private int currentByteCount; // bytes read from current source
//
// Buffers for decoded but unparsed character input.
//
private char readBuffer [];
private int readBufferPos;
private int readBufferLength;
private int readBufferOverflow; // overflow from last data chunk.
//
// Buffer for undecoded raw byte input.
//
private final static int READ_BUFFER_MAX = 16384;
//
CPAN-Audit
view release on metacpan or search on metacpan
lib/CPAN/Audit.pm view on Meta::CPAN
or die "could not read file <$params{json_db}>\n";
<$fh>;
};
state $rc = require JSON;
my $decoded = eval { JSON::decode_json($data) };
die "could not decode JSON from <$params{json_db}>: @_\n" unless defined $decoded;
return $decoded;
}
my $rc = eval { require CPANSA::DB };
if ( $rc ) {
return CPANSA::DB->db;
CPAN-Changes
view release on metacpan or search on metacpan
corpus/dists/DBIx-Class.changes view on Meta::CPAN
- Make resultset chaining consistent wrt selection specification
- Storage::DBI::Replicated cleanup
- Fix autoinc PKs without an autoinc flag on Sybase ASA
0.08118 2010-02-08 11:53:00 (UTC)
- Fix a bug causing UTF8 columns not to be decoded (RT#54395)
- Fix bug in One->Many->One prefetch-collapse handling (RT#54039)
- Cleanup handling of relationship accessor types
0.08117 2010-02-05 17:10:00 (UTC)
- Perl 5.8.1 is now the minimum supported version
CPAN-Meta-YAML
view release on metacpan or search on metacpan
t/10_read.t view on Meta::CPAN
or diag "ERROR: " . CPAN::Meta::YAML->errstr;
cmp_deeply( $got, $case->{perl}, "CPAN::Meta::YAML parses correctly" );
}
if ( $case->{utf8} ) {
ok( utf8::is_utf8( $got->[0]->{$case->{utf8}} ), "utf8 decoded" );
}
# test that read method on object is also a constructor
ok( my $got2 = eval { $got->read( $file ) }, "read() object method");
isnt( $got, $got2, "objects are different" );
CPAN-Meta
view release on metacpan or search on metacpan
lib/Parse/CPAN/Meta.pm view on Meta::CPAN
identical calling semantics are used. These may only be used with YAML sources.
All error reporting is done with exceptions (die'ing).
Note that META files are expected to be in UTF-8 encoding, only. When
converted string data, it must first be decoded from UTF-8.
=begin Pod::Coverage
lib/Parse/CPAN/Meta.pm view on Meta::CPAN
my $metadata_structure = Parse::CPAN::Meta->load_yaml_string($yaml_string);
This method deserializes the given string of YAML and returns the first
document in it. (CPAN metadata files should always have only one document.)
If the source was UTF-8 encoded, the string must be decoded before calling
C<load_yaml_string>.
=head2 load_json_string
my $metadata_structure = Parse::CPAN::Meta->load_json_string($json_string);
This method deserializes the given string of JSON and the result.
If the source was UTF-8 encoded, the string must be decoded before calling
C<load_json_string>.
=head2 load_string
my $metadata_structure = Parse::CPAN::Meta->load_string($some_string);
CPAN-MetaCurator
view release on metacpan or search on metacpan
data/tiddlers.json view on Meta::CPAN
"title": "EditorConfigFiles",
"modified": "20250901234400753",
"created": "20200330020441159"
},
{
"text": "\"\"\"\no See also:\n- [[Acronyms]]\n- MailingLists\n- NetworkProgramming\n- RfcGuide\n- WebServices\n- JMAP rather than IMAP: https://jmap.io/\n- EAV::XS (Address validation)\n- https://metacpan.org/author/RJBS - For Email::* & Mail...
"title": "EmailStuff",
"modified": "20260328062118016",
"created": "20200917062056119"
},
{
CPAN-Testers-Metabase-Feed
view release on metacpan or search on metacpan
lib/CPAN/Testers/Metabase/Feed.pm view on Meta::CPAN
=head1 DESCRIPTION
This module creates a 'recent reports' feed from a CPAN Testers Metabase
in Atom format. Each entry has a title with summary information. The content
is HTML-encoded, but when decoded is just JSON text with report metadata.
=head1 ATTRIBUTES
=head2 ct_metabase (required)
CPAN-Testers-ParseReport
view release on metacpan or search on metacpan
lib/CPAN/Testers/ParseReport.pm view on Meta::CPAN
described in the C<ctgetreports> manpage. $extract is a hashref
containing the found variables.
Note: this parsing is a bit dirty but as it seems good enough I'm not
inclined to change it. We parse HTML with regexps only, not an HTML
parser. Only the entities are decoded.
In %Opt you can use
article => $some_full_article_as_scalar
CPAN-Testers-WWW-Reports
view release on metacpan or search on metacpan
lib/Labyrinth/Plugin/CPAN/Builder.pm view on Meta::CPAN
$progress->( ".. processing rmauth $author $name (cleaning JSON file)" ) if(defined $progress);
my $data = read_file($destfile);
$progress->( ".. processing rmauth $author $name (read JSON file)" ) if(defined $progress);
my $store;
eval { $store = decode_json($data) };
$progress->( ".. processing rmauth $author $name (decoded JSON data)" ) if(defined $progress);
if(!$@ && $store) {
for my $row (@$store) {
next if($requests{$row->{id}}); # filter out requests
push @reports, $row;
lib/Labyrinth/Plugin/CPAN/Builder.pm view on Meta::CPAN
# clean the summary, if we have one
my @summary = $dbi->GetQuery('hash','GetAuthorSummary',$author);
if(@summary) {
$progress->( ".. processing rmauth $author $name (cleaning summary) " . scalar(@summary) . ' ' . ($summary[0] && $summary[0]->{dataset} ? 'true' : 'false') ) if(defined $progress);
my $dataset = decode_json($summary[0]->{dataset});
$progress->( ".. processing rmauth $author $name (decoded JSON summary)" ) if(defined $progress);
for my $data ( @{ $dataset->{distributions} } ) {
my $dist = $data->{dist};
my $summ = $data->{summary};
CPAN-cpanminus-reporter-RetainReports
view release on metacpan or search on metacpan
t/lib/Testing.pm view on Meta::CPAN
sub _analyze_json_file {
my ($tdir, $hr) = @_;
my $lfile = File::Spec->catfile($tdir, "$hr->{json_title}.log.json");
Test::More::ok(-f $lfile, "Log file $lfile created");
my $f = Path::Tiny::path($lfile);
my $decoded = decode_json($f->slurp_utf8);
_test_json_output($decoded, $hr->{expected});
return 1;
}
sub _test_json_output {
my ($got, $expected) = @_;
CPANPLUS
view release on metacpan or search on metacpan
inc/bundle/JSON/PP.pm view on Meta::CPAN
$json->boolean_values([$false, $true])
($false, $true) = $json->get_boolean_values
By default, JSON booleans will be decoded as overloaded
C<$JSON::PP::false> and C<$JSON::PP::true> objects.
With this method you can specify your own boolean values for decoding -
on decode, JSON C<false> will be decoded as a copy of C<$false>, and JSON
C<true> will be decoded as C<$true> ("copy" here is the same thing as
assigning a value to another variable, i.e. C<$copy = $false>).
This is useful when you want to pass a decoded data structure directly
to other serialisers like YAML, Data::MessagePack and so on.
Note that this works only when you C<decode>. You can set incompatible
boolean objects (like L<boolean>), but when you C<encode> a data structure
with such boolean objects, you still need to enable C<convert_blessed>
inc/bundle/JSON/PP.pm view on Meta::CPAN
codeset range. Neither of these flags conflict with each other, although
some combinations make less sense than others.
Care has been taken to make all flags symmetrical with respect to
C<encode> and C<decode>, that is, texts encoded with any combination of
these flag values will be correctly decoded when the same flags are used
- in general, if you use different flag settings while encoding vs. when
decoding you likely have a bug somewhere.
Below comes a verbose discussion of these flags. Note that a "codeset" is
simply an abstract set of character-codepoint pairs, while an encoding
inc/bundle/JSON/PP.pm view on Meta::CPAN
=item C<utf8> flag disabled
When C<utf8> is disabled (the default), then C<encode>/C<decode> generate
and expect Unicode strings, that is, characters with high ordinal Unicode
values (> 255) will be encoded as such characters, and likewise such
characters are decoded as-is, no changes to them will be done, except
"(re-)interpreting" them as Unicode codepoints or Unicode characters,
respectively (to Perl, these are the same thing in strings unless you do
funny/weird/dumb stuff).
This is useful when you want to do the encoding yourself (e.g. when you
CPANSA-DB
view release on metacpan or search on metacpan
lib/CPAN/Audit/DB.pm view on Meta::CPAN
use warnings;
our $VERSION = '20260419.002';
sub db {
{"dists" => {"ActivePerl" => {"advisories" => [{"affected_versions" => ["==5.16.1.1601"],"cves" => ["CVE-2012-5377"],"description" => "Untrusted search path vulnerability in the installation functionality in ActivePerl 5.16.1.1601, when installed in...
}
__PACKAGE__;
CPE
view release on metacpan or search on metacpan
elsif ($data{$k} eq '-') {
$data{$k} = 'NA';
}
elsif ($data{$k} =~ /\%/) {
# URI CPEs may have percent-encoded special characters
# which must be decoded to proper values.
my %decoded = (
'21' => '!', '22' => '"', '23' => '#', '24' => '$',
'25' => '%', '26' => '&', '27' => q('), '28' => '(',
'29' => ')', '2a' => '*', '2b' => '+', '2c' => ',',
'2f' => '/', '3a' => ':', '3b' => ';', '3c' => '<',
'3d' => '=', '3e' => '>', '3f' => '?', '40' => '@',
'60' => '`', '7b' => '{', '7c' => '|', '7d' => '}',
'7e' => '~',
);
$data{$k} =~ s{\%01}{?}g if index($data{$k}, '%01') >= 0;
$data{$k} =~ s{\%02}{*}g if index($data{$k}, '%02') >= 0;
foreach my $special (keys %decoded) {
if (index($data{$k}, '%' . $special) >= 0) {
$data{$k} =~ s{\%$special}{\\$decoded{$special}}ig;
}
}
}
}
# this is a compatibility layer between CPE 2.2 and 2.3.
( run in 0.892 second using v1.01-cache-2.11-cpan-39bf76dae61 )