view release on metacpan or  search on metacpan

lib/Apache2/TaintRequest.pm  view on Meta::CPAN

sub handler {
    my $r = shift;
    $r = Apache2::TaintRequest->new($r);

    my $querystring = $r->query_string();
    $r->print($querystring);    # html is escaped...

    $querystring =~ s/<script>//;
    $r->print($querystring);    # html is NOT escaped...
}

=cut

use Apache2::RequestRec;

lib/Apache2/TaintRequest.pm  view on Meta::CPAN

    $self{request} = $r;

    return \%self;
}

*escape_html = \&HTML::Entities::encode_entities;

sub print {
    my ( $self, @data ) = @_;

    foreach my $value (@data) {

        # Dereference scalar references.
        $value = $$value if ref $value eq 'SCALAR';

        # Escape any HTML content if the data is tainted.
        $value = escape_html($value) if tainted($value);
    }

    $self->{request}->SUPER::print(@data);
}

lib/Apache2/TaintRequest.pm  view on Meta::CPAN

=back

One of the harder problems facing web developers involves dealing with
potential cross site scripting attacks.  Frequently this involves many
calls to HTML::Entities::escape_html().

This module aims to automate this tedious process.  It overrides the
print mechanism in the mod_perl Apache module.  The new print method
tests each chunk of text for taintedness.  If it is tainted we assume
the worst and html-escape it before printing.

Note that this module requires that you have the line 

  PerlSwitches -T

 view release on metacpan or  search on metacpan

lib/Apache2/Translation/Admin/my.js  view on Meta::CPAN

  }
}

function update_header( counter, key, uri ) {
  if( uri==":PRE:" || uri==":LOOKUPFILE:" ) {
    Element.update( 'header'+counter, key.escapeHTML() );
  } else {
    Element.update( 'header'+counter,
		    key.escapeHTML()+" <img class=\"pfeil\" src=\"pfeil.gif\"> "+ uri.escapeHTML() );
  }
}

function xupdate( counter, o, focus ) {
  if(o) o.blur();

lib/Apache2/Translation/Admin/my.js  view on Meta::CPAN

	'	  ADM_NBLOCKS="1">'+
	'	<table class="tdc">'+
	'		<tr>'+
	'			<td class="tdcol1">New Key:</td>'+
	'			<td class="tdcol2">'+
	'				<input type="text" name="newkey" id="key'+next_counter+'" value="'+key.escapeHTML()+'">'+
	'			</td>'+
	'		</tr>'+
	(uri==":PRE:" || uri==":LOOKUPFILE:"
	 ? ('		<input type="hidden" name="newuri" id="uri'+next_counter+'" value="'+uri.escapeHTML()+'">')
	 : ('		<tr>'+
	    '			<td class="tdcol1">New Uri:</td>'+
	    '			<td class="tdcol2">'+
	    '				<input type="text" name="newuri" id="uri'+next_counter+'" value="'+uri.escapeHTML()+'">'+
	    '			</td>'+
	    '		</tr>'))+
	'		<tr><th colspan="2"><br>Action</th></tr>'+
	'		<tr class="tdc">'+
	'			<td ADM_BLOCK="0" ADM_ORDER="" ADM_ID=""'+

 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

usr/share/webapp-toolkit/extra/htdocs/admin/js/cookie.js  view on Meta::CPAN

	if (end == -1) {
		end = obj.length;
	}

	return unescape(obj.substring(beg + arg.length, end));
}

function setCookie(name, value, expires, path, domain, secure) {
	document.cookie = name + "="  + escape(value) +
		((expires) ? "; expires=" + expires.toGMTString() : "") +
		((path)    ? "; path="    + path                  : "") +
		((domain)  ? "; domain="  + domain                : "") +
		((secure)  ? "; secure"                           : "");
}

 view release on metacpan or  search on metacpan

lib/ApacheLog/Compressor.pm  view on Meta::CPAN

use Socket qw(inet_aton inet_ntoa);
use Date::Parse qw(str2time);
use List::Util qw(min);
use URI;
use URI::Escape qw(uri_unescape);
use DateTime;
use Encode qw(encode_utf8 decode_utf8 FB_DEFAULT is_utf8 FB_CROAK);
use POSIX qw{strftime};

our $VERSION = '0.005';

lib/ApacheLog/Compressor.pm  view on Meta::CPAN

				return $data->{url} = '' unless defined $data->{url};

				($data->{url}, $data->{query}) = split /\?/, $data->{url}, 2;
# Dodgy UTF8 handling, currently disabled - no guarantee that URLs are UTF8 anyway
#				if(length $data->{url}) {
				# URI::Escape's uri_unescape but in byte mode so we can check utf8 decoding manually
#					my $txt = $data->{url};
#					$txt = encode_utf8($txt); # turn OFF utf8
#					$txt =~ s/%([0-9A-Fa-f]{2})/pack("C1", hex($1))/ge; # expand
#					$txt = decode_utf8($txt); # turn ON utf8 where applicable
#					$data->{url} = $txt;
#				}
#				if(defined $data->{query} && length $data->{query}) {
				# URI::Escape's uri_unescape but in byte mode so we can check utf8 decoding manually
#					(my $txt = $data->{query}) =~ s/%([0-9A-Fa-f]{2})/pack("C1", hex($1))/eg;
#					$data->{query} = decode_utf8($txt, FB_DEFAULT);
#				}
			}
		},

 view release on metacpan or  search on metacpan

lib/Apertur/SDK/Resource/Sessions.pm  view on Meta::CPAN

use strict;
use warnings;

use JSON qw(encode_json);
use URI::Escape qw(uri_escape);

sub new {
    my ($class, %args) = @_;
    return bless { http => $args{http} }, $class;
}

lib/Apertur/SDK/Resource/Sessions.pm  view on Meta::CPAN

sub delivery_status {
    my ($self, $uuid, %opts) = @_;
    my $path = "/api/v1/upload-sessions/$uuid/delivery-status";
    my %req_opts;
    if (defined $opts{poll_from}) {
        $path .= '?pollFrom=' . uri_escape($opts{poll_from});
        # Long-poll: server holds up to 5 min; give the request 6 min so the
        # server releases first under the happy path.
        $req_opts{timeout} = 360;
    }
    return $self->{http}->request('GET', $path, %req_opts);

lib/Apertur/SDK/Resource/Sessions.pm  view on Meta::CPAN

sub _build_query_string {
    my (%params) = @_;
    my @parts;
    for my $key (sort keys %params) {
        next unless defined $params{$key};
        push @parts, uri_escape($key) . '=' . uri_escape($params{$key});
    }
    return @parts ? '?' . join('&', @parts) : '';
}

1;

 view release on metacpan or  search on metacpan

lib/Apigee/Edge.pm  view on Meta::CPAN

use Carp;
use Mojo::UserAgent;
use Mojo::URL;
use Mojo::Util qw(b64_encode);
use URI::Escape qw/uri_escape/;

use vars qw/$errstr/;
sub errstr { return $errstr }

sub new {    ## no critic (ArgUnpacking)

lib/Apigee/Edge.pm  view on Meta::CPAN

    return $self->request('GET', "/o/" . $self->{org} . "/apps/$app_id");
}

sub get_apps_by_family {
    my ($self, $family) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/apps?appfamily=" . uri_escape($family));
}

sub get_apps_by_keystatus {
    my ($self, $keystatus) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/apps?keyStatus=" . uri_escape($keystatus));
}

sub get_apps_by_type {
    my ($self, $type) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/apps?apptype=" . uri_escape($type));
}

sub get_apps {    ## no critic (ArgUnpacking)
    my $self = shift;
    my %args = @_ % 2 ? %{$_[0]} : @_;

lib/Apigee/Edge.pm  view on Meta::CPAN

}

sub get_developer {
    my $self = shift;
    my ($email) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/developers/" . uri_escape($email));
}

sub delete_developer {
    my $self = shift;
    my ($email) = @_;
    return $self->request('DELETE', "/o/" . $self->{org} . "/developers/" . uri_escape($email));
}

sub get_app_developers {
    my $self = shift;
    my ($app) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/developers?app=" . uri_escape($app));
}

sub get_developers {
    my $self = shift;
    return $self->request('GET', "/o/" . $self->{org} . "/developers");
}

sub set_developer_status {
    my ($self, $email, $status);
    return $self->request('GET', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "?action=" . uri_escape($status));
}

sub update_developer {    ## no critic (ArgUnpacking)
    my $self  = shift;
    my $email = shift;
    my %args  = @_ % 2 ? %{$_[0]} : @_;
    $email or croak "email is required.";
    return $self->request('PUT', "/o/" . $self->{org} . "/developers/" . uri_escape($email), %args);
}

## Apps: Developer http://apigee.com/docs/api/apps-developer
sub change_app_status {
    my ($self, $email, $app) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps/" . uri_escape($app));
}

sub create_developer_app {    ## no critic (ArgUnpacking)
    my $self  = shift;
    my $email = shift;
    my %args  = @_ % 2 ? %{$_[0]} : @_;
    return $self->request('POST', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps", %args);
}

sub delete_developer_app {
    my ($self, $email, $app) = @_;
    return $self->request('DELETE', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps/" . uri_escape($app));
}

sub get_developer_app {
    my ($self, $email, $app) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps/" . uri_escape($app));
}

sub get_developer_apps {    ## no critic (ArgUnpacking)
    my $self  = shift;
    my $email = shift;
    $email or croak "email is required.";

    my %args = @_ % 2 ? %{$_[0]} : @_;
    my $url = Mojo::URL->new("/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps");
    $url->query(\%args) if %args;
    return $self->request('GET', $url->to_string);
}

sub update_developer_app {    ## no critic (ArgUnpacking)

lib/Apigee/Edge.pm  view on Meta::CPAN

    my $email = shift;
    my $app   = shift;
    my %args  = @_ % 2 ? %{$_[0]} : @_;
    $email or croak "email is required.";
    $app   or croak "app is required.";
    return $self->request('PUT', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps/" . uri_escape($app), %args);
}

sub get_count_of_developer_app_resource {
    my ($self, $email, $app, $entity) = @_;
    return $self->request('GET',
              "/o/"
            . $self->{org}
            . "/developers/"
            . uri_escape($email)
            . "/apps/"
            . uri_escape($app)
            . qq~?"query=count&entity=~
            . uri_escape($entity)
            . qq~"~);
}

sub regenerate_developer_app_key {    ## no critic (ArgUnpacking)
    my $self  = shift;
    my $email = shift;
    my $app   = shift;
    my %args  = @_ % 2 ? %{$_[0]} : @_;
    $email or croak "email is required.";
    $app   or croak "app is required.";
    return $self->request('POST', "/o/" . $self->{org} . "/developers/" . uri_escape($email) . "/apps/" . uri_escape($app), %args);
}

## API Products http://apigee.com/docs/api/api-products-1
sub create_api_product {              ## no critic (ArgUnpacking)
    my $self = shift;

lib/Apigee/Edge.pm  view on Meta::CPAN

sub update_api_product {              ## no critic (ArgUnpacking)
    my $self    = shift;
    my $product = shift;
    my %args    = @_ % 2 ? %{$_[0]} : @_;
    $product or croak "product is required.";
    return $self->request('PUT', "/o/" . $self->{org} . "/apiproducts/" . uri_escape($product), %args);
}

sub delete_api_product {
    my ($self, $product) = @_;
    return $self->request('DELETE', "/o/" . $self->{org} . "/apiproducts/" . uri_escape($product));
}

sub get_api_product {
    my ($self, $product) = @_;
    return $self->request('GET', "/o/" . $self->{org} . "/apiproducts/" . uri_escape($product));
}

sub get_api_products {    ## no critic (ArgUnpacking)
    my $self = shift;
    my %args = @_ % 2 ? %{$_[0]} : @_;

lib/Apigee/Edge.pm  view on Meta::CPAN

sub get_api_product_details {    ## no critic (ArgUnpacking)
    my $self    = shift;
    my $product = shift;
    my %args    = @_ % 2 ? %{$_[0]} : @_;
    my $url     = Mojo::URL->new("/o/" . $self->{org} . "/apiproducts/" . uri_escape($product));
    $url->query(\%args) if %args;
    return $self->request('GET', $url->to_string);
}

sub request {

lib/Apigee/Edge.pm  view on Meta::CPAN

=head2 request

The underlaying method to call Apigee when you see something is missing.

    $self->request('GET', "/o/$org_name/apps/$app_id");
    $self->request('DELETE', "/o/$org_name/developers/" . uri_escape($email));
    $self->request('POST', "/o/$org_name/developers", %args);
    $self->request('PUT', "/o/$org_name/developers/" . uri_escape($email), %args);

=head2 errstr

=head1 GITHUB

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

    newCONSTSUB()             NEED_newCONSTSUB             NEED_newCONSTSUB_GLOBAL
    newSVpvn_share()          NEED_newSVpvn_share          NEED_newSVpvn_share_GLOBAL
    PL_parser                 NEED_PL_parser               NEED_PL_parser_GLOBAL
    PL_signals                NEED_PL_signals              NEED_PL_signals_GLOBAL
    pv_display()              NEED_pv_display              NEED_pv_display_GLOBAL
    pv_escape()               NEED_pv_escape               NEED_pv_escape_GLOBAL
    pv_pretty()               NEED_pv_pretty               NEED_pv_pretty_GLOBAL
    sv_catpvf_mg()            NEED_sv_catpvf_mg            NEED_sv_catpvf_mg_GLOBAL
    sv_catpvf_mg_nocontext()  NEED_sv_catpvf_mg_nocontext  NEED_sv_catpvf_mg_nocontext_GLOBAL
    sv_setpvf_mg()            NEED_sv_setpvf_mg            NEED_sv_setpvf_mg_GLOBAL
    sv_setpvf_mg_nocontext()  NEED_sv_setpvf_mg_nocontext  NEED_sv_setpvf_mg_nocontext_GLOBAL

ppport.h  view on Meta::CPAN

DEFINEP|5.009005||Viu
DEFSV|5.004005|5.003007|p
DEFSV_set|5.010001|5.003007|p
delete_eval_scope|5.009004||xViu
delimcpy|5.004000|5.004000|n
delimcpy_no_escape|5.025005||Vni
DEL_NATIVE|5.017010||Viu
del_sv|5.005000||Viu
DEPENDS_PAT_MOD|5.013009||Viu
DEPENDS_PAT_MODS|5.013009||Viu
deprecate|5.011001||Viu

ppport.h  view on Meta::CPAN

putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p
pv_pretty|5.009004|5.003007|p
pv_uni_display|5.007003|5.007003|
pWARN_ALL|5.006000||Viu
pWARN_NONE|5.006000||Viu
pWARN_STD|5.006000||Viu

ppport.h  view on Meta::CPAN

#ifndef PERL_PV_PRETTY_REGPROP
#  define PERL_PV_PRETTY_REGPROP         PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
#endif

/* Hint: pv_escape
 * Note that unicode functionality is only backported to
 * those perl versions that support it. For older perl
 * versions, the implementation will fall back to bytes.
 */

#ifndef pv_escape
#if defined(NEED_pv_escape)
static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
static
#else
extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
#endif

#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)

#ifdef pv_escape
#  undef pv_escape
#endif
#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
#define Perl_pv_escape DPPP_(my_pv_escape)


char *
DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,
  const STRLEN count, const STRLEN max,
  STRLEN * const escaped, const U32 flags)
{
    const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\';
    const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc;
    char octbuf[32] = "%123456789ABCDF";
    STRLEN wrote = 0;

ppport.h  view on Meta::CPAN

            wrote++;
        }
        if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
            break;
    }
    if (escaped != NULL)
        *escaped= pv - str;
    return SvPVX(dsv);
}

#endif
#endif

ppport.h  view on Meta::CPAN

DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,
  const STRLEN max, char const * const start_color, char const * const end_color,
  const U32 flags)
{
    const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
    STRLEN escaped;

    if (!(flags & PERL_PV_PRETTY_NOCLEAR))
        sv_setpvs(dsv, "");

    if (dq == '"')

ppport.h  view on Meta::CPAN

        sv_catpvs(dsv, "<");

    if (start_color != NULL)
        sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color));

    pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR);

    if (end_color != NULL)
        sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color));

    if (dq == '"')
        sv_catpvs(dsv, "\"");
    else if (flags & PERL_PV_PRETTY_LTGT)
        sv_catpvs(dsv, ">");

    if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count)
        sv_catpvs(dsv, "...");

    return SvPVX(dsv);
}

 view release on metacpan or  search on metacpan

script/rgb-to-ansi-bg-code  view on Meta::CPAN

    read_env => 0,
);

$cmdline->run;

# ABSTRACT: Convert RGB to ANSI color escape sequence to change background color
# PODNAME: rgb-to-ansi-bg-code

__END__

=pod

=encoding UTF-8

=head1 NAME

rgb-to-ansi-bg-code - Convert RGB to ANSI color escape sequence to change background color

=head1 VERSION

This document describes version 0.011 of rgb-to-ansi-bg-code (from Perl distribution App-ANSIColorUtils), released on 2025-03-18.

 view release on metacpan or  search on metacpan

script/_acme-cpanauthors  view on Meta::CPAN

#    my ($word, $is_cur_word, $after_ws) = @_;
#
#    #say "D:add_unquoted word=$word is_cur_word=$is_cur_word after_ws=$after_ws";
#
#    $word =~ s!^(~)(\w*)(/|\z) |  # 1) tilde  2) username  3) optional slash
#               \\(.)           |  # 4) escaped char
#               \$(\w+)            # 5) variable name
#              !
#                  $1 ? (not($after_ws) || $is_cur_word ? "$1$2$3" : _expand_tilde($2, $3)) :
#                      $4 ? $4 :
#                          ($is_cur_word ? "\$$5" : $ENV{$5})

script/_acme-cpanauthors  view on Meta::CPAN

#sub _add_double_quoted {
#    no warnings 'uninitialized';
#
#    my ($word, $is_cur_word) = @_;
#
#    $word =~ s!\\(.)           |  # 1) escaped char
#               \$(\w+)            # 2) variable name
#              !
#                  $1 ? $1 :
#                      ($is_cur_word ? "\$$2" : $ENV{$2})
#                          !egx;

script/_acme-cpanauthors  view on Meta::CPAN

#bash versions 4.2-4.3):
#
#1) quotes and backslashes are stripped (bash's `COMP_WORDS` contains all the
#   quotes and backslashes);
#
#2) quoted phrase that contains spaces, or phrase that contains escaped spaces is
#   parsed as a single word. For example:
#
#    command "First argument" Second\ argument
#
#   bash would split it as (represented as Perl):

script/_acme-cpanauthors  view on Meta::CPAN

#        # add things to words, etc
#        local point=... # calculate the new point
#        COMPREPLY=( `COMP_LINE="foo ${words[@]}" COMP_POINT=$point foo` )
#    }
#
#  To avoid these word-breaking characters to be split/grouped, we can escape
#  them with backslash or quote them, e.g.:
#
#    command "http://example.com:80" Foo\:\:Bar
#
#  which bash will parse as:

script/_acme-cpanauthors  view on Meta::CPAN

#    v => 1.1,
#    summary => 'Format completion for output (for shell)',
#    description => <<'_',
#
#Bash accepts completion reply in the form of one entry per line to STDOUT. Some
#characters will need to be escaped. This function helps you do the formatting,
#with some options.
#
#This function accepts completion answer structure as described in the `Complete`
#POD. Aside from `words`, this function also recognizes these keys:
#

script/_acme-cpanauthors  view on Meta::CPAN

#  array.
#
#* esc_mode
#
#  Escaping mode for entries. Either `default` (most nonalphanumeric characters
#  will be escaped), `shellvar` (like `default`, but dollar sign `$` will also be
#  escaped, convenient when completing environment variables for example),
#  `filename` (currently equals to `default`), `option` (currently equals to
#  `default`), or `none` (no escaping will be done).
#
#* word
#

script/_acme-cpanauthors  view on Meta::CPAN

#  ESCAPE_WORDS:
#    for my $entry (@$words) {
#        my $word    = ref($entry) eq 'HASH' ? $entry->{word}    : $entry;
#        my $summary = (ref($entry) eq 'HASH' ? $entry->{summary} : undef) // '';
#        if ($esc_mode eq 'shellvar') {
#            # escape $ also
#            $word =~ s!([^A-Za-z0-9,+._/:~-])!\\$1!g;
#        } elsif ($esc_mode eq 'none') {
#            # no escaping
#        } else {
#            # default

script/_acme-cpanauthors  view on Meta::CPAN

# format_completion($completion, $opts) -> str|array
#
#Format completion for output (for shell).
#
#Bash accepts completion reply in the form of one entry per line to STDOUT. Some
#characters will need to be escaped. This function helps you do the formatting,
#with some options.
#
#This function accepts completion answer structure as described in the C<Complete>
#POD. Aside from C<words>, this function also recognizes these keys:
#

script/_acme-cpanauthors  view on Meta::CPAN

#array.
#
#=item * esc_mode
#
#Escaping mode for entries. Either C<default> (most nonalphanumeric characters
#will be escaped), C<shellvar> (like C<default>, but dollar sign C<$> will also be
#escaped, convenient when completing environment variables for example),
#C<filename> (currently equals to C<default>), C<option> (currently equals to
#C<default>), or C<none> (no escaping will be done).
#
#=item * word
#

script/_acme-cpanauthors  view on Meta::CPAN

#bash versions 4.2-4.3):
#
#1) quotes and backslashes are stripped (bash's C<COMP_WORDS> contains all the
#   quotes and backslashes);
#
#2) quoted phrase that contains spaces, or phrase that contains escaped spaces is
#   parsed as a single word. For example:
#
# command "First argument" Second\ argument
#
#   bash would split it as (represented as Perl):

script/_acme-cpanauthors  view on Meta::CPAN

#    # add things to words, etc
#    local point=... # calculate the new point
#    COMPREPLY=( C<COMP_LINE="foo ${words[@]}" COMP_POINT=$point foo> )
#}
#
#To avoid these word-breaking characters to be split/grouped, we can escape
#them with backslash or quote them, e.g.:
#
#command "http://example.com:80" Foo\:\:Bar
#
#which bash will parse as:

script/_acme-cpanauthors  view on Meta::CPAN

#                        modify_answer(answer=>$fres, suffix=>"=");
#                        $fres->{path_sep} = "=";
#                        # XXX actually not entirely correct, we want normal
#                        # escaping but without escaping "=", maybe we should
#                        # allow customizing, e.g. esc_mode=normal, dont_esc="="
#                        # (list of characters to not escape)
#                        $fres->{esc_mode} = "none";
#                        goto RETURN_RES;
#                    }
#                } else {
#                    $fres = complete_arg_val(

script/_acme-cpanauthors  view on Meta::CPAN

#  )x;
#
## note: order is important here, brace encloses the other
#our $RE_WILDCARD_BASH =
#    qr(
#          # non-escaped brace expression, with at least one comma
#          (?P<bash_brace>
#              (?<!\\)(?P<slashes_before_bash_brace>\\\\)*\{
#              (?P<bash_brace_content>
#                  $re_bash_brace_element(?:, $re_bash_brace_element )+
#              )
#              (?<!\\)(?:\\\\)*\}
#          )
#      |
#          # non-escaped brace expression, to catch * or ? or [...] inside so
#          # they don't go to below pattern, because bash doesn't consider them
#          # wildcards, e.g. '/{et?,us*}' expands to '/etc /usr', but '/{et?}'
#          # doesn't expand at all to /etc.
#          (?P<literal_brace_single_element>
#              (?<!\\)(?:\\\\)*\{
#              $re_bash_brace_element
#              (?<!\\)(?:\\\\)*\}
#          )
#      |
#          (?P<bash_class>
#              # non-empty, non-escaped character class
#              (?<!\\)(?:\\\\)*\[
#              (?:  \\\\ | \\\[ | \\\] | [^\\\[\]] )+
#              (?<!\\)(?:\\\\)*\]
#          )
#      |
#          (?P<bash_joker>
#              # non-escaped * and ?
#              (?<!\\)(?:\\\\)*(?:\*\*?|\?)
#          )
#      |
#          (?P<sql_joker>
#              # non-escaped % and ?
#              (?<!\\)(?:\\\\)*[%_]
#          )
#      |
#          (?P<literal>
#              [^\\\[\]\{\}*?%_]+

script/_acme-cpanauthors  view on Meta::CPAN

#           }
#
#        } elsif (defined($p = $m{literal_brace_single_element})) {
#            push @res, quotemeta($p);
#        } elsif (defined($p = $m{bash_class})) {
#            # XXX no need to escape some characters?
#            push @res, $p;
#        } elsif (defined($p = $m{sql_joker})) {
#            push @res, quotemeta($p);
#        } elsif (defined($p = $m{literal})) {
#            push @res, quotemeta($p);

script/_acme-cpanauthors  view on Meta::CPAN

# $bool = contains_wildcard($wildcard_str)
#
#Return true if C<$str> contains wildcard pattern. Wildcard patterns include
#I<joker> such as C<*> (meaning zero or more of any characters) and C<?> (exactly
#one of any character), I<character class> C<[...]>, and I<brace> C<{...,}>
#(brace expansion). A pattern can be escaped using a bacslash so it becomes
#literal, e.g. C<foo\*> does not contain wildcard because it's C<foo> followed by
#a literal asterisk C<*>.
#
#Aside from the abovementioned wildcard patterns, bash does other types of
#expansions/substitutions too, but these are not considered wildcard. These

script/_acme-cpanauthors  view on Meta::CPAN

#
#Convert bash wildcard to SQL pattern. This includes:
#
#=over
#
#=item * converting unescaped C<*> to C<%>
#
#=item * converting unescaped C<?> to C<_>
#
#=item * escaping unescaped C<%>
#
#=item * escaping unescaped C<_>
#
#=back
#
#Unsupported constructs will cause the function to die.
#

 view release on metacpan or  search on metacpan

lib/App/Adenosine.pm  view on Meta::CPAN

# ABSTRACT: Handy CLI HTTP tool

use URI;
use Getopt::Long qw(:config pass_through no_ignore_case);
use File::Path 'mkpath';
use URI::Escape 'uri_escape';
use File::Spec::Functions 'splitpath';
use Path::Class;
use Text::ParseWords;
use Scalar::Util 'blessed';
use Module::Runtime 'use_module';

lib/App/Adenosine.pm  view on Meta::CPAN

      push @extra, '-I' if $action eq 'HEAD';

      my $_path = $uri_base;
      $_path =~ s/\*/$path/;

      $query = uri_escape($query) if $quote;

      push @extra, $self->host_method_config( $self->host($uri_base), $action );

      $query = "?$query" if $query;

 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/MojoX/Aliyun.pm  view on Meta::CPAN

    );

    # say Dumper(\%auth_params); use Data::Dumper;

    # Thanks to https://github.com/lemontv/AliyunPerlLib/blob/master/Aliyun/Auth.pm
    my %dumb = %auth_params; $dumb{Timestamp} = uri_escape($dumb{Timestamp});
    my @tmps = map { join('=', $_, $dumb{$_}) } sort keys(%dumb);
    my $StringToSign = join("&",  @tmps);
    $StringToSign = join('&', $method, uri_escape($path), uri_escape($StringToSign));
    my $Signature = hmac_sha1_base64($StringToSign, $self->access_secret . '&');
    $auth_params{Signature} = $Signature . '=';

    my $tx = $self->ua->build_tx($method => $url => form => \%auth_params );
    $tx = $self->ua->start($tx);

 view release on metacpan or  search on metacpan

lib/App/AltSQL.pm  view on Meta::CPAN

The hostname the model is connected to

=item B<%%>

An escaped percent sign

=item B<%c{...}>

A L<Term::ANSIColor> color name.  The value will be passed directly to the C<color> method.

 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/ArduinoBuilder/System.pm  view on Meta::CPAN

# Splits a given command line string into individual arguments.
# Returns the array of individual arguments.
#
# This approach is very primitive. However both Parse::CommandLine and
# Text::ParseWords have the same issue that they consider that a backslash can
# escape any character, which is wrong on Windows (C:\foo is not C:foo).
# Also Text::Balanced, is not well suited for this case where we can have
# unquoted pieces of text.
#
# Ideally, we would use whatever Perl uses to split a command into word as
# per https://perldoc.perl.org/functions/exec, but this does not seem to be
# exposed
#
# TODO: support escaped quotes (that are not quoting arguments) as well as,
# maybe, quotes interrupting unquoted arguments.
sub split_cmd {
  my ($cmd) = @_;
  my @cmd;
  while ($cmd =~ m/ \G \s* (?: (['"])(?<p>.*?)\1 | (?<p>[^ ]+) ) /gx) {

 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/Minilla/ModuleMaker/InlineMakeMaker.pm  view on Meta::CPAN

    local $Data::Dumper::Useqq = 1;
    local $Data::Dumper::Purity = 1;
    local $Data::Dumper::Indent = 1;
    local $Data::Dumper::Sortkeys = 1;
    my $content = get_data_section('Makefile.PL');
    my $mt = Text::MicroTemplate->new(template => $content, escape_func => sub { $_[0] });
    my $src = $mt->build->($project);
    spew_raw('Makefile.PL', $src);
}
sub prereqs {
    my ($self, $project) = @_;

 view release on metacpan or  search on metacpan

lib/App/BackupPlan.pm  view on Meta::CPAN

E<lt>sourceDirE<gt>. This is specified by a string of type C<n[dmy]>, where n is a number and the 
second letter is either C<d> for days, C<m> for months or C<y> for years. Internally, C<1m = 30d>
and C<1y = 360d>, wihtout considering months of 28 or 31 days. 

=item * B<E<lt>sourceDirE<gt>> The path for the directory structure to be backed up. It requires
a B<CDATA> xml tag to escape the slashes in the full path.

=item * B<E<lt>targetDirE<gt>> The path for the destination directory where backup files are stored. It requires
a B<CDATA> xml tag to escape the slashes in the full path. Typically this will be a single location on the disk,
and hence the same for all tasks and specified in the E<lt>defaultE<gt> section.

=back

=back

 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

META.yml  view on Meta::CPAN

  perl: v5.14.0
  strict: 0
  vars: 0
  warnings: 0
resources:
  repository: git://github.com/27escape/App-Basis-ConvertText2-UtfTransform.git
version: 0.4.0

 view release on metacpan or  search on metacpan

lib/App/Basis/ConvertText2.pm  view on Meta::CPAN

    * charts
    * barcodes and qrcodes
    * and many others

See 
https://github.com/27escape/App-Basis-ConvertText2/blob/master/README.md
for more information.

=head1 Todo

Consider adding plugins for 

lib/App/Basis/ConvertText2.pm  view on Meta::CPAN

    foreach my $k ( keys %{ $self->replace() } ) {
        next if ( !$self->{replace}->{$k} );

        # in the text the variables to be replaced are surrounded by %
        # zero width look behind to make sure the variable name has
        # not been escaped _%VARIABLE% should be left alone
        $content =~ s/(?<!_)%$k%/$self->{replace}->{$k}/gsm;
    }

    return $content;
}

 view release on metacpan or  search on metacpan

META.yml  view on Meta::CPAN

  Try::Tiny: 0
  perl: v5.12.0
  strict: 0
  warnings: 0
resources:
  repository: git://github.com/27escape/App-Basis-Email.git
version: 0.3

 view release on metacpan or  search on metacpan

META.yml  view on Meta::CPAN

  feature: '0'
  perl: v5.10.0
  strict: '0'
  warnings: '0'
resources:
  repository: git://github.com/27escape/App-Basis-Queue.git
version: 000.600.100
x_serialization_backend: 'YAML::Tiny version 1.70'

 view release on metacpan or  search on metacpan

META.yml  view on Meta::CPAN

  strict: '0'
  utf8::all: '0'
  vars: '0'
  warnings: '0'
resources:
  repository: git://github.com/27escape/App-Basis.git
version: '1.2'

 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

scripts/colorplus  view on Meta::CPAN

 colorplus [-0] [-n N|-3|-4] [-c colorname] [-e N[,N[,N..]]] [-l N] [-s REGEX] [-t N] [-/ char]
 colorplus [--help [opt|en]] [--version]

=head1 DESCRIPTION

Put colors (ASCII color escape sequnces) parts on text data such as numerical parts, 
columns cyclically, text matching specific regular expressions. Useful to look around
CSV/TSV files with a pager LESS (less -R).

=head1 OPTIONS

=over 4

=item B<-0> 

Remove colors (remove all the ASCII color escape sequences). 

=item B<-n> N

Put colors on numerical characters. Every neighboring N digits from the bottom of a numerical 
character sequence has a same color. Cyan, green, yellow are used to colorize. 

scripts/colorplus  view on Meta::CPAN

Same as the specification B<-n 4>.

=item B<-c> colorname

Speficy the colorname. It can be "blue", "red", "yellow", and also "on_while", "underline" and so on.
See the ASCII color escape sequences.

=item B<-e> N,N,...

Any operation by "colorplus" is exemplified on the lines specified by the number(s) beginning from 1. 
-0 is also cancelled on the specified lines, thus in this case, the input color on the specified line 

 view release on metacpan or  search on metacpan

bin/bfg  view on Meta::CPAN

=head1 DESCRIPTION

This program combines the power of three Unix tools (in their GNU versions): bool, find and grep to provide a way to search by filenames and/or by file contents using boolean expressions. Internaly, all boolean expressions with regexps/strings are tr...

Complex searches using B<grep> are very painful and B<bool> have lots of limitations and complex escape rules. B<bfg> simplify these searches by using more clear syntax and better performance in some cases.

For example, to search

    first AND second AND third AND fourth AND NOT fifth

bin/bfg  view on Meta::CPAN

Show only filenames.

=item * --slash-as-delim, -s

Inhibt operators and parentheses interpretation insid slashes. To use literal slashes, escape them with a backslash.

=back

=head1 EXAMPLES

 view release on metacpan or  search on metacpan

share/de-de.dis  view on Meta::CPAN

display \x000B 1378 #11^Kvertical tabulation
display \x000C 12378 #12^Lform feed
display \x000D 13478 #13^Mcarriage return
display \x000E 134578 #14^Nshift out
display \x000F 13578 #15^Oshift in
display \x0010 123478 #16^Pdata link escape
display \x0011 1234578 #17^Qdevice control one
display \x0012 123578 #18^Rdevice control two
display \x0013 23478 #19^Sdevice control three
display \x0014  234578 #20^Tdevice control four
display \x0015 13678 #21^Unegative acknowledge
display \x0016 123678 #22^Vsynchronous idle
display \x0017  245678 #23^Wend of transmission block
display \x0018 134678 #24^Xcancel
display \x0019 1345678 #25^Yend of medium
display \x001A 135678 #26^Zsubstitute
display \x001B  24678 #27^[escape
display \x001C 125678 #28^\file separator
display \x001D 1245678 #29^]group separator
display \x001E 4578 #30^^record separator
display \x001F 45678 #31^_unit separator