view release on metacpan or search on metacpan
lib/App/Sysadmin/Log/Simple/HTTP.pm view on Meta::CPAN
# ABSTRACT: a HTTP (maybe RESTful?) logger for App::Sysadmin::Log::Simple
our $VERSION = '0.009'; # VERSION
use Carp;
use HTTP::Tiny;
use URI::Escape qw(uri_escape);
our $HTTP_TIMEOUT = 10;
sub new {
view release on metacpan or search on metacpan
share/test/asciitable/ascii7.org view on Meta::CPAN
| 013 | 11 | 0B | VT '\v' (vertical tab) |
| 014 | 12 | 0C | FF '\f' (form feed) |
| 015 | 13 | 0D | CR '\r' (carriage ret) |
| 016 | 14 | 0E | SO (shift out) |
| 017 | 15 | 0F | SI (shift in) |
| 020 | 16 | 10 | DLE (data link escape) |
| 021 | 17 | 11 | DC1 (device control 1) |
| 022 | 18 | 12 | DC2 (device control 2) |
| 023 | 19 | 13 | DC3 (device control 3) |
| 024 | 20 | 14 | DC4 (device control 4) |
| 025 | 21 | 15 | NAK (negative ack.) |
| 026 | 22 | 16 | SYN (synchronous idle) |
| 027 | 23 | 17 | ETB (end of trans. blk) |
| 030 | 24 | 18 | CAN (cancel) |
| 031 | 25 | 19 | EM (end of medium) |
| 032 | 26 | 1A | SUB (substitute) |
| 033 | 27 | 1B | ESC (escape) |
| 034 | 28 | 1C | FS (file separator) |
| 035 | 29 | 1D | GS (group separator) |
| 036 | 30 | 1E | RS (record separator) |
| 037 | 31 | 1F | US (unit separator) |
| 040 | 32 | 20 | SPACE |
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/App/Tailor.pm view on Meta::CPAN
Modifier rules are applied to each line of input B<SECOND>.
=head2 colorize
Accepts a regex which, when matched, will cause the entire match to be
colorized using ANSI color escapes. The second argument is a list of color
labels to be applied. See L<Term::ANSIColor/Function-Interface> for acceptable
labels.
# "foo" has fg:red, bg:white
colorize qr/foo/ => qw(red on_white);
view release on metacpan or search on metacpan
lib/App/Tarotplane/Cards.pm view on Meta::CPAN
# Truncate whitespace
$card->{Term} =~ s/\s+/ /g;
$card->{Definition} =~ s/\s+/ /g;
## Now interpret some escape codes
# '\:' -> ':'
$card->{Term} =~ s/\\:/:/g;
$card->{Definition} =~ s/\\:/:/g;
# '\n' -> line break
lib/App/Tarotplane/Cards.pm view on Meta::CPAN
# Skip comments and blanks
my $first = substr $l, 0, 1;
next if $first eq '#' or $first eq "\n";
# Substitute '\\' now so that '\\:' does not count as an escaped colon.
# The null byte is added so that the subsequent substitutions do not
# try to replace any '\\' escaped backslash.
$l =~ s/\\\\/\\\0/g;
if ($state == CARD_TERM) {
# Does card contain non-escaped colon?
if ($l =~ /(^|[^\\]):/) {
my (undef,
$te,
$de
) = split(/(^.*[^\\]):/, $l, 2);
view release on metacpan or search on metacpan
lib/App/Task.pm view on Meta::CPAN
);
return $rv;
}
sub _escape {
my ( $str, $leave_slashes ) = @_;
$str =~ s/\\/\\\\/g unless $leave_slashes;
$str =~ s/\n/\\n/g;
$str =~ s/\t/\\t/g;
lib/App/Task.pm view on Meta::CPAN
my $task = $code;
my $type = ref($code);
if ( $type eq 'ARRAY' ) {
my $disp = join " ", map {
my $copy = "$_";
$copy = _escape( $copy, 1 );
if ( $copy =~ m/ / ) { $copy =~ s/'/\\'/g; $copy = "'$copy'" }
$copy
} @{$code};
if ( $ENV{App_Task_DRYRUN} ) {
$task = sub { print "(DRYRUN) ＞＿ $disp\n" };
lib/App/Task.pm view on Meta::CPAN
$task = $cmdhr->{fatal} ? sub { _sys( @{$code} ) or die "`$disp` did not exit cleanly: $?\n" } : sub { _sys( @{$code} ) };
}
}
elsif ( !$type ) {
my $disp = _escape( $code, 0 );
if ( $ENV{App_Task_DRYRUN} ) {
$task = sub { print "(DRYRUN) ＞＿ $disp\n" };
}
else {
$task = $cmdhr->{fatal} ? sub { _sys($code) or die "`$disp` did not exit cleanly: $?\n" } : sub { _sys($code) };
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/App/TemplateServer.pm view on Meta::CPAN
);
};
method _render_template($req) {
my $context = $self->_mk_context($req);
my $template = uri_unescape($req->uri->path);
$template =~ s{^/}{};
my $content = $self->provider->render_template($template, $context);
return _success($content);
};
view release on metacpan or search on metacpan
lib/Templer/Plugin/Dollar.pm view on Meta::CPAN
=for example begin
<html>
<head>
<title>${title escape="html"}</title>
<meta name='author' content='${author} ${email escape=url}'/>
</head>
<body>
</body>
</html>
lib/Templer/Plugin/Dollar.pm view on Meta::CPAN
the transformation. The third line of the example is for instance transformed
as
=for example begin
<title><tmpl_var name="title" escape="html"></title>
=for example end
=cut
view release on metacpan or search on metacpan
Revision history for App-Termcast
0.13 2014-09-16
- Use a less intrusive (and more easily parsable) escape sequence for
metadata. I believe terminals should just ignore this if it ends up
actually getting sent to the terminal instead of stripped out by the
termcast server, but let me know if this isn't the case.
0.12 2012-03-15
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/App/Test/Generator.pm view on Meta::CPAN
if($module && length($module) && ($module ne 'builtin')) {
_validate_module($module, $schema_file);
}
# $module/$function are spliced unescaped into generated test
# source below (use_ok, new_ok, ->$function, $module::$function)
# — reject anything that isn't identifier-shaped before that happens.
_assert_identifier($module, 'module', package => 1) if defined($module) && length($module);
# sensible defaults
lib/App/Test/Generator.pm view on Meta::CPAN
# name) before it is spliced into generated
# test source as a bareword, package name,
# method name, or variable name rather than
# a quoted string literal. Schema-derived
# names (module, function, transform names)
# are spliced unescaped at the call sites
# that use this guard, so an unvalidated
# name could otherwise break out of the
# generated source and inject arbitrary
# Perl into a file that L<prove> will run.
#
lib/App/Test/Generator.pm view on Meta::CPAN
# q_wrap
#
# Purpose: Wrap a string in the most readable
# q{} form that does not require escaping,
# falling back to single-quoted form with
# escaped apostrophes if no delimiter is
# available.
#
# Entry: $s - the string to wrap. May be undef.
# Exit: Returns a Perl source-code fragment that
# evaluates to the original string value,
lib/App/Test/Generator.pm view on Meta::CPAN
# Must use != $INDEX_NOT_FOUND rather than > 0 since
# the delimiter may legitimately appear at position 0
return "q$d$s$d" if index($s, $d) == $INDEX_NOT_FOUND;
}
# Last resort — single-quoted string with escaped apostrophes
(my $esc = $s) =~ s/'/\\'/g;
return "'$esc'";
}
# --------------------------------------------------
lib/App/Test/Generator.pm view on Meta::CPAN
#
# Purpose: Escape a string for safe inclusion
# inside a single-quoted Perl string
# literal in generated test code.
#
# Entry: $s - the string to escape.
# Exit: Returns the escaped string, or an
# empty string if $s is undef.
#
# Notes: NUL byte replacement produces the
# two-character sequence \0 which is
# only correct when the result is used
lib/App/Test/Generator.pm view on Meta::CPAN
# Return empty string for undef — callers that need
# 'undef' literal should use perl_quote instead
return '' unless defined $s;
# Escape backslashes first so later substitutions
# don't double-escape already-escaped sequences
$s =~ s/\\/\\\\/g;
# Escape apostrophes so they don't terminate the
# surrounding single-quoted string literal
$s =~ s/'/\\'/g;
# Escape common control characters to their
# printable two-character escape sequences
$s =~ s/\n/\\n/g;
$s =~ s/\r/\\r/g;
$s =~ s/\t/\\t/g;
$s =~ s/\f/\\f/g;
lib/App/Test/Generator.pm view on Meta::CPAN
# Skip non-hashref field specs — scalar types
# like 'string' have no generator sub-structure
next unless ref($spec) eq 'HASH';
# $field is spliced unescaped into the generated
# LectroTest generator spec by
# _schema_to_lectrotest_generator() — reject anything
# that isn't identifier-shaped first.
_assert_identifier($field, 'input field name');
lib/App/Test/Generator.pm view on Meta::CPAN
if(defined($spec->{'matches'})) {
my $pattern = $spec->{'matches'};
# Compile the pattern safely rather than splicing the raw
# string into qr/$pattern/ — the raw form lets a pattern
# containing an unescaped '/' break out of the qr//
# delimiter and inject arbitrary Perl into the generated
# test. regexp_pattern() decomposes the already-compiled
# Regexp object back into pattern text that is guaranteed
# to be a self-contained regex body, safe to re-embed.
my $compiled = ref($pattern) eq 'Regexp' ? $pattern : eval { qr/$pattern/ };
lib/App/Test/Generator.pm view on Meta::CPAN
my $pattern = $output_spec->{'matches'};
# See the matching comment in _schema_to_lectrotest_generator —
# compile first and re-embed via regexp_pattern() rather than
# splicing the raw string into qr/$pattern/, which would let
# an unescaped '/' break out of the delimiter.
my $compiled = ref($pattern) eq 'Regexp' ? $pattern : eval { qr/$pattern/ };
if($@ || !defined($compiled)) {
carp "Invalid matches pattern '$pattern' for transform '$transform_name': $@";
} else {
my ($pat, $mods) = regexp_pattern($compiled);