Result:
found more than 953 distributions - search limited to the first 2001 files matching your query
( run in 3.709 )
CGI-Deurl-XS
view release on metacpan or search on metacpan
value in the hash is the scalar value of the encoded parameter value. If a
parameter appears more than once, the hash value is an array reference
containing each value given (with value order preserved). Obviously, parameter
order is not preserved in the hash.
HTTP escapes (ASCII and Unicode) are decoded in both keys and values. The utf8
flag is not set on returned strings, nor are non-utf8 encodings decoded.
=back
=head1 EXPORT
CGI-Deurl
view release on metacpan or search on metacpan
$query{a} = 5;
$query{b} = 13;
=item deurlstr
=item $decodedstring = deurlstr $string
Decodes the string as if it was a CGI parameter value.
That is ist translates all '+' to ' ' and all
%xx to the corresponding character. It doesn't care about
'&' nor '='.
CGI-Easy
view release on metacpan or search on metacpan
lib/CGI/Easy/Request.pm view on Meta::CPAN
=item {raw}
By default we suppose request send either in UTF8 (or ASCII) encoding.
Request path, GET/POST/cookie names and values (except uploaded files content)
and uploaded file names will be decoded from UTF8 to Unicode.
If you need to handle requests in other encodings, you should disable
automatic decoding from UTF8 using C<< raw => 1 >> option and decode
all these things manually.
lib/CGI/Easy/Request.pm view on Meta::CPAN
=item {path}
Path from url, always begin with '/'.
Will be decoded from UTF8 to Unicode unless new() called with option
C<< raw=>1 >>.
=item {GET}
=item {POST}
lib/CGI/Easy/Request.pm view on Meta::CPAN
'b[]' => [ 7, 8 ],
'c' => [ 9 ],
},
POST => {}
Parameter names and values (except file content) be decoded from UTF8 to
Unicode unless new() called with option C<< raw=>1 >>.
=item {filename}
=item {mimetype}
lib/CGI/Easy/Request.pm view on Meta::CPAN
mimetype => {
a => undef,
image => 'image/gif',
}
Parameter names and file names will be decoded from UTF8 to Unicode unless
new() called with option C<< raw=>1 >>.
=item {cookie}
Will contain hash with cookie names and values. Example:
lib/CGI/Easy/Request.pm view on Meta::CPAN
cookie => {
some_cookie => 'some value',
other_cookie => 'other value',
}
Cookie names and values will be decoded from UTF8 to Unicode unless
new() called with option C<< raw=>1 >>.
=item {REMOTE_ADDR}
=item {REMOTE_PORT}
CGI-ExtDirect
view release on metacpan or search on metacpan
examples/p5httpd view on Meta::CPAN
PROTECTED:
logmsg "checking password";
$passphrase =~ tr#A-Za-z0-9+/##cd; # remove non-base64 chars
$passphrase =~ tr#A-Za-z0-9+/# -_#; # convert to uuencoded format
my $len = pack( "c", 32 + 0.75 * length($passphrase) ); # compute length byte
my $decoded = unpack( "u", $len . $passphrase ); # uudecode and print
my ( $name, $password ) = split /:/, $decoded;
if ( my $encrypted_password = $encrypted_passwords{$name} ) {
return $name
if crypt( $password, $encrypted_password ) eq
$encrypted_password; # check password
CGI-Github-Webhook
view release on metacpan or search on metacpan
lib/CGI/Github/Webhook.pm view on Meta::CPAN
The payload as passed as payload in the POST request if it is valid
JSON, else an error message in JSON format.
=head4 payload_perl
The payload as perl data structure (hashref) as decoded by
decode_json. If the payload was no valid JSON, it returns a hashref
containing either { payload => 'none' } if there was no payload, or {
error => ... } in case of a decode_json error had been caught.
=head1 SUBROUTINES/METHODS
CGI-IDS
view release on metacpan or search on metacpan
lib/CGI/IDS.pm view on Meta::CPAN
# DESCRIPTION
# Equivalent to PHP's urldecode
# INPUT
# string the URL to decode
# OUTPUT
# string the decoded URL
# SYNOPSIS
# IDS::urldecode($url);
#****
sub urldecode {
lib/CGI/IDS.pm view on Meta::CPAN
If the parameter value matches this rule or the rule tag is not present, the IDS will not run its filters on it.
Case-sensitive; mode modifiers I<m> and I<s> in use.
=item * encoding
Use value I<json> if the parameter contains JSON encoded data. IDS will test the decoded data,
otherwise a false positive would occur due to the 'suspicious' JSON encoding characters.
=item * conditions
Set of conditions to be fulfilled. This is the parameter environment in which
CGI-Info
view release on metacpan or search on metacpan
bin/testjson.pl view on Meta::CPAN
$req->header('content-type' => 'application/json');
$req->content('{ "first": "Nigel", "last": "Horne" }');
my $resp = $ua->request($req);
if($resp->is_success()) {
print "Reply:\n\t", $resp->decoded_content, "\n";
} else {
print STDERR $resp->code(), "\n", $resp->message(), "\n";
}
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-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)
( run in 3.709 seconds using v1.01-cache-2.11-cpan-26ccb49234f )