view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
lib/AnyEvent/HTTP/ScopedClient.pm view on Meta::CPAN
if ( 'HASH' eq ref($reqBody) ) {
my @pair;
# push @pair, "$_=$reqBody->{$_}" for ( keys %$reqBody );
push @pair, "$_=" . uri_escape_utf8( $reqBody->{$_} )
for ( keys %$reqBody );
$reqBody = join( '&', @pair );
}
my $sendingData
view release on metacpan or search on metacpan
lib/AnyEvent/HTTPD/HTTPConnection.pm view on Meta::CPAN
# application/x-www-form-urlencoded
#
# This is the default content type. Forms submitted with this content type must
# be encoded as follows:
#
# 1. Control names and values are escaped. Space characters are replaced by
# `+', and then reserved characters are escaped as described in [RFC1738],
# section 2.2: Non-alphanumeric characters are replaced by `%HH', a percent
# sign and two hexadecimal digits representing the ASCII code of the
# character. Line breaks are represented as "CR LF" pairs (i.e., `%0D%0A').
#
# 2. The control names/values are listed in the order they appear in the
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
lib/Mail/IMAP/Util.pm view on Meta::CPAN
push @{$stack[-1]}, $1; # let's consider this an atom too
} elsif ($text =~ m/\G[])]/gc) {
pop @stack;
} elsif ($text =~ m/\G\"((?:\\.|[^\"\\])*)\"/gc) {
my $str = $1;
# unescape
$str =~ s/\\\"/\"/g;
$str =~ s/\\\\/\\/g;
push @{$stack[-1]}, $str; # found string
} elsif ($text =~ m/\G(\d+)/gc) {
push @{$stack[-1]}, $1 + 0; # found numeric
view release on metacpan or search on metacpan
lib/AnyEvent/IRC/Util.pm view on Meta::CPAN
$msg .= defined $trail ? " :$trail" : "";
return $msg;
}
my @_ctcp_lowlevel_escape = ("\000", "0", "\012", "n", "\015", "r", "\020", "\020");
sub unescape_lowlevel {
my ($data) = @_;
my %map = reverse @_ctcp_lowlevel_escape;
$data =~ s/\020(.)/defined $map{$1} ? $map{$1} : $1/ge;
$data
}
sub escape_lowlevel {
my ($data) = @_;
my %map = @_ctcp_lowlevel_escape;
$data =~ s/([\000\012\015\020])/"\020$map{$1}"/ge;
$data
}
sub unescape_ctcp {
my ($data) = @_;
$data =~ s/\\(.)/$1 eq 'a' ? "\001" : ($1 eq "\\" ? "\\" : $1)/eg;
$data
}
sub escape_ctcp {
my ($data) = @_;
$data =~ s/([\\\001])/$1 eq "\001" ? "\\a" : "\\\\"/eg;
$data
}
=item B<decode_ctcp ($data)>
This function decodes CTCP messages contained in an IRC message.
C<$data> should be the last parameter of a IRC PRIVMSG or NOTICE.
It will first unescape the lower layer, extract CTCP messages
and then return a list with two elements: the line without the CTCP messages
and an array reference which contains array references of CTCP messages.
Those CTCP message array references will have the CTCP message tag as
first element (eg. "VERSION") and the rest of the CTCP message as the second
element.
lib/AnyEvent/IRC/Util.pm view on Meta::CPAN
=cut
sub decode_ctcp {
my ($line) = @_;
$line = unescape_lowlevel ($line);
my @ctcp;
while ($line =~ /\G\001([^\001]*)\001/g) {
my $msg = unescape_ctcp ($1);
my ($tag, $data) = split / /, $msg, 2;
push @ctcp, [$tag, $data];
}
$line =~ s/\001[^\001]*\001//g;
# try to parse broken ctcp messages anyway
if ($line =~ s/\001([^\001]*)$//) {
my $msg = unescape_ctcp ($1);
my ($tag, $data) = split / /, $msg, 2;
push @ctcp, [$tag, $data];
}
return ($line, \@ctcp)
lib/AnyEvent/IRC/Util.pm view on Meta::CPAN
=cut
sub encode_ctcp {
my (@args) = @_;
escape_lowlevel (
join "", map {
ref $_
? "\001" . escape_ctcp (join " ", @$_) . "\001"
: $_
} @args
)
}
=item B<filter_colors ($line)>
This function will filter out any mIRC colors and (most) ansi escape sequences.
Unfortunately the mIRC color coding will destroy improper colored numbers. So this
function may destroy the message in some occasions a bit.
=cut
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
lib/AnyEvent/InfluxDB.pm view on Meta::CPAN
required keys C<measurement> and C<fields> and optional C<tags> and C<time>.
Both can be also mixed and matched within an array reference.
Scalar values are expected to be formatted using InfluxDB line protocol.
All special characters need to be escaped. In that case you might want to use
L<InfluxDB::LineProtocol>:
use InfluxDB::LineProtocol qw(dataline);
...
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
- aemp shell now supports "package" selection and offers an
$ECHO port you can send messages to.
- rely on perl rand() instead of using /dev/urandom when available, as
hopefully it is random enough.
- aemp shell no longer leaks one port per command.
- nodenames can contain %-escapes such as %n or %u.
- aemp now uses aemp/%n/%u as nodename.
- configure supports "eval", a small perl snippet to initialsie a node,
most useful in "aemp run eval ...".
- known_nodes is gone, it has little value, use all_nodes as
replacement.
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
my $videofile = "path/to/file.mkv";
use AnyEvent;
my $mpv = AnyEvent::MPV->new (trace => 1);
$mpv->start ("--idle=yes");
$mpv->cmd (loadfile => $mpv->escape_binary ($videofile));
my $quit = AE::cv;
$mpv->register_event (end_file => $quit);
$quit->recv;
trace => 1,
args => ["--pause", "--idle=yes"],
);
$mpv->start;
$mpv->cmd_recv (loadfile => $mpv->escape_binary ($videofile));
$mpv->cmd ("set", "pause", "no");
my $timer = AE::timer 2, 0, my $quit = AE::cv;
$quit->recv;
To load a file, we then send it a C<loadfile> command, which accepts, as
first argument, the URL or path to a video file. To make sure F<mpv> does
not misinterpret the path as a URL, it was prefixed with F<./> (similarly
to "protecting" paths in perls C<open>).
Since commands send I<to> F<mpv> are send in UTF-8, we need to escape the
filename (which might be in any encoding) using the C<esscape_binary>
method - this is not needed if your filenames are just ascii, or magically
get interpreted correctly, but if you accept arbitrary filenamews (e.g.
from the user), you need to do this.
print "end-file<$data->{reason}>\n";
$quit->send;
});
$mpv->cmd (loadfile => $mpv->escape_binary ($videofile));
$quit->recv;
This example uses a global condvar C<$quit> to wait for the file to finish
playing. Also, most of the logic is now implement in event handlers.
=head2 ENCODING CONVENTIONS
As a rule of thumb, all data you pass to this module to be sent to F<mpv>
is expected to be in unicode. To pass something that isn't, you need to
escape it using C<escape_binary>.
Data received from F<mpv>, however, is I<not> decoded to unicode, as data
returned by F<mpv> is not generally encoded in unicode, and the encoding
is usually unspecified. So if you receive data and expect it to be in
unicode, you need to first decode it from UTF-8, but note that this might
args => [],
%kv,
}, $class
}
=item $string = $mpv->escape_binary ($string)
This module excects all command data sent to F<mpv> to be in unicode. Some
things are not, such as filenames. To pass binary data such as filenames
through a comamnd, you need to escape it using this method.
The simplest example is a C<loadfile> command:
$mpv->cmd_recv (loadfile => $mpv->escape_binary ($path));
=cut
# can be used to escape filenames
sub escape_binary {
shift;
local $_ = shift;
# we escape every "illegal" octet using U+10e5df HEX. this is later undone in cmd
s/([\x00-\x1f\x80-\xff])/sprintf "\x{10e5df}%02x", ord $1/ge;
$_
}
=item $started = $mpv->start (argument...)
$self->{cmdcv}{++$reqid} = $cv;
my $cmd = $JSON_ENCODER->encode ({ command => ref $_[0] ? $_[0] : \@_, request_id => $reqid*1 });
# (un-)apply escape_binary hack
$cmd =~ s/\xf4\x8e\x97\x9f(..)/sprintf sprintf "\\x%02x", hex $1/ges; # f48e979f == 10e5df in utf-8
$trace->(">mpv" => $cmd);
$wbuf .= "$cmd\n";
my $mpv = AnyEvent::MPV->new (
on_key => sub {
my ($mpv, $key) = @_;
if ($key eq "letmeout") {
print "user pressed escape\n";
}
},
);
$mpv_>bind_key (ESC => "letmeout");
$mpv->cmd ("script-message", "osc-visibility", "never", "dummy");
$mpv->cmd ("set", "vid", "auto");
$mpv->cmd ("set", "aid", "auto");
$mpv->cmd ("set", "sid", "no");
$mpv->cmd ("set", "file-local-options/chapters-file", $mpv->escape_binary ("$mpv_path.chapters"));
$mpv->cmd ("loadfile", $mpv->escape_binary ($mpv_path));
$mpv->cmd ("script-message", "osc-visibility", "auto", "dummy");
Handling events makes the main bulk of video playback code. For example,
various ways of ending playback:
}
} elsif ($type eq "video/iso-bluray") {
$mpv->cmd (set => "bluray-device" => $path);
$mpv->cmd (loadfile => "bd://");
} else {
$mpv->cmd (loadfile => $mpv->escape_binary ($path));
}
After this, C<Gtk2::CV> waits for the file to be loaded, video to be
configured, and then queries the video size (to resize its own window)
and video format (to decide whether an audio visualizer is needed for
view release on metacpan or search on metacpan
lib/AnyEvent/MSN.pm view on Meta::CPAN
my $contacts = shift;
# XXX - Do something with these contacts
$s->_set_contacts($contacts);
my $ticket
= __html_unescape(
$s->contacts->{'soap:Body'}{'ABFindContactsPagedResponse'}
{'ABFindContactsPagedResult'}{'CircleResult'}
{'CircleTicket'});
$s->send('USR %d SHA A %s',
$s->tid, MIME::Base64::encode_base64($ticket, ''));
lib/AnyEvent/MSN.pm view on Meta::CPAN
#
if ($policy =~ m[MBI]) {
my $token = $s->auth_token('messengerclear.live.com')
; # or http://Passport.NET/tb
my $token_
= __html_escape($token->{'wst:RequestedSecurityToken'}
{'wsse:BinarySecurityToken'}{'content'});
$s->send('USR %d SSO S %s %s %s',
$s->tid,
$token->{'wst:RequestedSecurityToken'}
{'wsse:BinarySecurityToken'}{'content'},
lib/AnyEvent/MSN.pm view on Meta::CPAN
<UserTileLocation>0</UserTileLocation><FriendlyName>%s</FriendlyName><PSM>%s</PSM><RUM></RUM><RLT>0</RLT></s>'
. '<s n="IM"><Status>%s</Status><CurrentMedia></CurrentMedia></s>'
. '<sep n="PD"><ClientType>1</ClientType><EpName>%s</EpName><Idle>false</Idle><State>%s</State></sep>'
. '<sep n="PE" epid="%s"><VER>MSNMSGR:15.4.3508.1109</VER><TYP>1</TYP><Capabilities>2952790016:557056</Capabilities></sep>'
. '<sep n="IM"><Capabilities>2953838624:132096</Capabilities></sep>'
. '</user>', __html_escape($s->friendly_name),
__html_escape($s->personal_message),
$status,
__html_escape($s->location), $status, $s->guid;
my $out
= sprintf
qq[To: 1:%s\r\nRouting: 1.0\r\nFrom: 1:%s;epid=%s\r\n\r\nStream: 1\r\nFlags: ACK\r\nReliability: 1.0\r\n\r\nContent-Length: %d\r\nContent-Type: application/user+xml\r\nPublication: 1.0\r\nUri: /user\r\n\r\n%s],
$s->passport,
$s->passport, $s->guid, length($body), $body;
lib/AnyEvent/MSN.pm view on Meta::CPAN
catch { $s->_trigger_fatal_error(qq[parsing XML: $_]) };
$xml;
}
# Non-OOP utility functions
sub __html_escape {
my $x = shift;
$x =~ s[&][&]sg;
$x =~ s[<][<]sg;
$x =~ s[>][>]sg;
$x =~ s["]["]sg;
$x;
}
sub __html_unescape {
my $x = shift;
$x =~ s[<][<]sg;
$x =~ s[>][>]sg;
$x =~ s["]["]sg;
$x =~ s[&][&]sg;
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
lib/AnyEvent/Multilog.pm view on Meta::CPAN
has 'script' => (
is => 'ro',
isa => 'ArrayRef[Str]',
required => 1,
documentation => 'multilog "script", not escaped for the shell',
);
has '_job' => (
init_arg => undef,
reader => '_job',
lib/AnyEvent/Multilog.pm view on Meta::CPAN
This is an ArrayRef representing the multilog script that describes
how to log. See the L<multilog|multilog man page> for more
information on what this script is and how to write one.
Note that the shell is never invoked, so you don't need to escape
anything from the shell.
To select all lines, add a tai64n timestamp, and log to a directory
called "log", your script should be C<['t', '+*', './log']>.
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
bin/rltelnet view on Meta::CPAN
};
#$rl->set_signals;
$rl->unbind_key (9);
$rl->add_defun (telnet_escape => sub {
print "$rbuf\nEscape detected, exiting.\n";
exit 0;
}, 0x1d);
$| = 1;
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
inc/Test/Base/Filter.pm view on Meta::CPAN
local $Data::Dumper::Indent = 1;
local $Data::Dumper::Terse = 1;
Data::Dumper::Dumper(@_);
}
sub escape {
$self->assert_scalar(@_);
my $text = shift;
$text =~ s/(\\.)/eval "qq{$1}"/ge;
return $text;
}
view release on metacpan or search on metacpan
lib/AnyEvent/Run.pm view on Meta::CPAN
cmd => 'ps ax'
cmd => [ 'ps, 'ax' ]
cmd => sub { print "Hi, I'm $$\n" }
When launching an external command, using an arrayref is recommended so
that your command is properly escaped.
Take care when using coderefs on Windows, as your code will run in
a thread. Avoid using modules that are not thread-safe.
=item args
view release on metacpan or search on metacpan
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $Pod::Escapes::Name2character_number{$1}
? chr($Pod::Escapes::Name2character_number{$1})
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) {
inc/Module/Install/Metadata.pm view on Meta::CPAN
defined $2
? chr($2)
: defined $mapping->{$1}
? $mapping->{$1}
: do {
warn "Unknown escape: E<$1>";
"E<$1>";
};
}gex;
}
else {
view release on metacpan or search on metacpan
lib/AnyEvent/HTTP/Spark.pm view on Meta::CPAN
use MooX::Types::MooseLike::Base qw(:all);
use Data::Dumper;
use JSON qw(to_json from_json);
use HTTP::Request::Common qw(POST);
use Ref::Util qw(is_plain_arrayref is_plain_hashref);
use URI::Escape qw(uri_escape_utf8);
use namespace::clean;
use Scalar::Util qw(looks_like_number);
use AnyEvent;
BEGIN {
lib/AnyEvent/HTTP/Spark.pm view on Meta::CPAN
my $headers=$self->default_headers;
my @args;
while(my ($key,$value)=splice @list,0,2) {
push @args,uri_escape_utf8($key).'='.uri_escape_utf8($value);
}
my $args=join '&',@args;
$uri .=$args;
$uri=~ s/\?$//s;
lib/AnyEvent/HTTP/Spark.pm view on Meta::CPAN
my $headers=$self->default_headers;
my @args;
while(my ($key,$value)=splice @list,0,2) {
push @args,uri_escape_utf8($key).'='.uri_escape_utf8($value);
}
my $args=join '&',@args;
$uri .=$args;
my $get=new HTTP::Request(HEAD=>$uri,$self->default_headers);
lib/AnyEvent/HTTP/Spark.pm view on Meta::CPAN
my $headers=$self->default_headers;
my @args;
while(my ($key,$value)=splice @list,0,2) {
push @args,uri_escape_utf8($key).'='.uri_escape_utf8($value);
}
my $args=join '&',@args;
$uri .=$args;
my $get=new HTTP::Request(DELETE=>$uri,$self->default_headers);
view release on metacpan or search on metacpan
lib/AnyEvent/Stomper.pm view on Meta::CPAN
return unless $handle->{rbuf} =~ s/^(.+?)(?:${\(RE_EOL)}){2}//s;
( $cmd_name, my @header_strings ) = split( m/${\(RE_EOL)}/, $1 );
foreach my $header_str (@header_strings) {
my ( $name, $value ) = split( /:/, $header_str, 2 );
$headers->{ _unescape($name) } = _unescape($value);
}
next;
}
lib/AnyEvent/Stomper.pm view on Meta::CPAN
my $frame_str = $cmd->{name} . EOL;
while ( my ( $name, $value ) = each %{$cmd_headers} ) {
unless ( defined $value ) {
$value = '';
}
$frame_str .= _escape($name) . ':' . _escape($value) . EOL;
}
$frame_str .= EOL . "$body\0";
$self->{_handle}->push_write($frame_str);
lib/AnyEvent/Stomper.pm view on Meta::CPAN
@{ $self->{_temp_input_queue} },
@{ $self->{_input_queue} },
);
}
sub _escape {
my $str = shift;
$str =~ s/([\r\n:\\])/$ESCAPE_MAP{$1}/ge;
return $str;
}
sub _unescape {
my $str = shift;
$str =~ s/(\\[rnc\\])/$UNESCAPE_MAP{$1}/ge;
return $str;