view release on metacpan or search on metacpan
lib/App/Pimpd/Transfer.pm view on Meta::CPAN
@tracks = map { $config{music_directory} . '/' . $_->file } @tracks;
if(remote_host()) {
for(@tracks) {
#$_ = escape($_);
_scp($_, $destination);
}
}
else {
for(@tracks) {
#$_ = escape($_);
if(copy($_, $destination)) {
printf("%40.40s => %s\n", basename($_), $destination);
}
else {
warn("cp_album: $!");
lib/App/Pimpd/Transfer.pm view on Meta::CPAN
return;
}
sub _scp {
my($source, $dest) = @_;
$source = escape($source);
system('scp', '-r',
"-P $config{ssh_port}",
qq($config{ssh_host}:$source), $dest
) == 0;# or confess("scp: $!");
view release on metacpan or search on metacpan
t/000-report-versions.t view on Meta::CPAN
# Error storage
$YAML::Tiny::errstr = '';
}
# Printable characters for escapes
my %UNESCAPES = (
z => "\x00", a => "\x07", t => "\x09",
n => "\x0a", v => "\x0b", f => "\x0c",
r => "\x0d", e => "\x1b", '\\' => '\\',
);
view release on metacpan or search on metacpan
script/platform-info view on Meta::CPAN
# allow_blessed convert_blessed relaxed allow_unknown
# allow_tags
# );
# my @pp_bit_properties = qw(
# allow_singlequote allow_bignum loose
# allow_barekey escape_slash as_nonblessed
# );
#
# if ( OLD_PERL ) {
# my $helper = $] >= 5.006 ? 'JSON::PP::Compat5006' : 'JSON::PP::Compat5005';
# eval qq| require $helper |;
script/platform-info view on Meta::CPAN
# my $canonical;
# my $allow_blessed;
# my $convert_blessed;
#
# my $indent_length;
# my $escape_slash;
# my $bignum;
# my $as_nonblessed;
# my $allow_tags;
#
# my $depth;
script/platform-info view on Meta::CPAN
# $depth = 0;
#
# my $props = $self->{PROPS};
#
# ($ascii, $latin1, $utf8, $indent, $canonical, $space_before, $space_after, $allow_blessed,
# $convert_blessed, $escape_slash, $bignum, $as_nonblessed, $allow_tags)
# = @{$props}[P_ASCII .. P_SPACE_AFTER, P_ALLOW_BLESSED, P_CONVERT_BLESSED,
# P_ESCAPE_SLASH, P_ALLOW_BIGNUM, P_AS_NONBLESSED, P_ALLOW_TAGS];
#
# ($max_depth, $indent_length) = @{$self}{qw/max_depth indent_length/};
#
script/platform-info view on Meta::CPAN
#
# sub string_to_json {
# my ($self, $arg) = @_;
#
# $arg =~ s/([\x22\x5c\n\r\t\f\b])/$esc{$1}/g;
# $arg =~ s/\//\\\//g if ($escape_slash);
# $arg =~ s/([\x00-\x08\x0b\x0e-\x1f])/'\\u00' . unpack('H2', $1)/eg;
#
# if ($ascii) {
# $arg = JSON_PP_encode_ascii($arg);
# }
script/platform-info view on Meta::CPAN
# }
#}
#
#{
#
# my %escapes = (
# b => "\x8",
# t => "\x9",
# n => "\xA",
# f => "\xC",
# r => "\xD",
script/platform-info view on Meta::CPAN
#
# return $s;
# }
# elsif($ch eq '\\'){
# next_chr();
# if(exists $escapes{$ch}){
# $s .= $escapes{$ch};
# }
# elsif($ch eq 'u'){
# my $u = '';
#
# for(1..4){
script/platform-info view on Meta::CPAN
#
# }
# else{
# unless ($loose) {
# $at -= 2;
# decode_error('illegal backslash escape sequence in string');
# }
# $s .= $ch;
# }
# }
# 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/Pod.pm view on Meta::CPAN
#
=head2 trim
Trim a line to fit the terminal width.
Handles also escape codes within the line.
=cut
sub trim {
my ( $line ) = @_;
state $esc = qr{ \033\[ [\d;]+ m }x;
state $data = qr{ (?: (?!$esc) . )++ }x;
state $data_or_escape = qr{ (?<data>$data) | (?<esc>$esc) }x;
state $term_width = Pod::Query::get_term_width();
state $replacement = " ...";
state $width_raw = $term_width - length( $replacement );
state $base_width = $width_raw >= 0 ? $width_raw : 0; # To avoid negatives.
# Figure out the total len of the line (uncolored).
my $total_chars = 0;
my @detailed_line_parts;
while ( $line =~ /$data_or_escape/g ) {
my $part = {%+};
$total_chars += $part->{len} = length( $part->{data} // "" );
push @detailed_line_parts, $part;
}
lib/App/Pod.pm view on Meta::CPAN
my @parts;
my $size_exceeded;
my $so_far_len = 0;
for my $part ( @detailed_line_parts ) {
# Handle escape codes.
if ( not $part->{len} ) {
push @parts, $part->{esc}; # Add escapes back.
last if $size_exceeded; # Done.
next;
}
# Handle trailing escapes.
last if $size_exceeded;
# Trim line if it would be too long.
if ( $so_far_len + $part->{len} > $base_width ) {
$size_exceeded = 1; # Still need to possibly add a trailing escape.
# Limit line to allowed width.
$part->{data} = substr(
$part->{data},
0,
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/TAP/Parser/Iterator/Worker/SSH.pm view on Meta::CPAN
my $self = shift;
my $commands = $self->SUPER::initialize_worker_command;
my $hostname = TAP::Parser::SourceHandler::Worker::SSH->get_next_host();
my $cwd = File::Spec->rel2abs('.');
my $escaped_command = "cd $cwd;" . $commands->[0];
$escaped_command =~ s/'/'"'"'/g;
$commands->[0] = "ssh $hostname '" . $escaped_command . "'";
$self->{host} = $hostname;
return $commands;
}
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/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/QuoteCC/Output/C.pm view on Meta::CPAN
Template->new->process(
\$template,
{
quotes => $quotes,
size => scalar(@$quotes),
escape => sub {
my $text = shift;
$text =~ s/"/\\"/g;
my $was = $text;
$text =~ s/\\(\$)/\\\\$1/g;
given ($text) {
lib/App/QuoteCC/Output/C.pm view on Meta::CPAN
#include <unistd.h>
#include <sys/time.h>
const char* const quotes[[% size %]] = {
[% FOREACH quote IN quotes
%] [% escape(quote) %],
[% END
%]};
/* returns random integer between min and max, inclusive */
const int rand_range(const int min, const int max)
view release on metacpan or search on metacpan
${main::in_package . '::REPL::env'} = PadWalker::peek_my(0)
EOE
# ----------------------------------------------------------------------
# More magic. This finds the final statement of some Perl, wherever
# that statement may be (even if its result cannot escape the overall
# evaluation), and saves its value in $App::REPL::ret
#--
$App::REPL::ret = '';
{ my $f = PPI::Find->new(sub { shift->isa('PPI::Statement') });
sub save_ret {
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/Raider/FileTools.pm view on Meta::CPAN
my ($path) = @_;
my $p = path($path);
if ($root) {
$p = $p->is_absolute ? $p : $root->child($path);
$p = $p->absolute;
die "Path escapes root: $p\n" unless $root->subsumes($p);
}
return $p;
};
my $server = MCP::Server->new(name => 'app-raider-files', version => '1.0');
view release on metacpan or search on metacpan
lib/App/Rangeops/Command/clean.pm view on Meta::CPAN
@lines = @{ App::Rangeops::Common::sort_links( \@lines ) };
}
#----------------------------#
# Links of nearly identical ranges escaped from merging
#----------------------------#
if ( $opt->{replace} ) {
print STDERR "==> Remove self links\n" if $opt->{verbose};
my @same_pair_lines = map {
view release on metacpan or search on metacpan
lib/App/RecordStream/Executor.pm view on Meta::CPAN
__FORMAT_TEXT__
Use {{search_string}} to look for a string in the keys of a record, use /
to nest keys. You can nest into arrays by using an index. If you are
vivifying arrays (if the array doesn't exist, prefix your key with # so
that an array rather than a hash will be created to put a / in your key,
escape it twice, i.e. \\/
This is exactly the same as a key spec that is always prefaced with a @,
see 'man recs' for more info on key specs
__FORMAT_TEXT__
view release on metacpan or search on metacpan
lib/App/RemoteCommand.pm view on Meta::CPAN
my $pid = $ssh->system({async => 1}, "rm", "-f", $name);
return ($pid, undef);
};
@command = (@prefix, $name, $self->{script_arg}->@*);
} else {
my $escape = qr{[^a-zA-Z0-9/_:%\.-]};
@command = (
@prefix,
($self->{command}->@* == 1 && $self->{command}[0] =~ $escape ? ("bash", "-c") : ()),
$self->{command}->@*,
);
}
DEBUG and logger "execute %s", join(" ", map { qq('$_') } @command);
push @ssh_cmd, sub ($ssh) {
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/Repository.pm view on Meta::CPAN
* Param: $file string
* Param: $options named
* Param: replace boolean rows should replace existing rows based on unique indexes
* Param: field_sep char character which separates the fields in the file (can by "\t")
* Param: field_quote char character which optionally encloses the fields in the file (i.e. '"')
* Param: field_escape char character which escapes the quote chars within quotes (i.e. "\")
* Return: void
* Throws: App::Exception::Repository
* Since: 0.01
Sample Usage:
lib/App/Repository.pm view on Meta::CPAN
&App::sub_entry if ($App::trace);
my ($self, $table, $columns, $file, $options) = @_;
$columns = $self->_get_default_columns($table) if (!$columns);
my $field_sep = $options->{field_sep} || ",";
my $field_quote = $options->{field_quote};
my $field_escape = $options->{field_escape};
open(App::Repository::DBI::FILE, "< $file") || die "Unable to open $file for reading: $!";
my (@row, $quoted_field_regexp, $field_regexp);
while (<App::Repository::DBI::FILE>) {
chomp;
lib/App/Repository.pm view on Meta::CPAN
* Param: $options named
* Param: columns ARRAY names of columns of the fields in the file
* Param: replace boolean rows should replace existing rows based on unique indexes
* Param: field_sep char character which separates the fields in the file (can by "\t")
* Param: field_quote char character which optionally encloses the fields in the file (i.e. '"')
* Param: field_escape char character which escapes the quote chars within quotes (i.e. "\")
* Return: void
* Throws: App::Exception::Repository
* Since: 0.01
Sample Usage:
lib/App/Repository.pm view on Meta::CPAN
my ($self, $table, $columns, $file, $options) = @_;
$columns = $self->_get_default_columns($table) if (!$columns);
my $rows = $self->get_rows($table, {}, $columns);
my $field_sep = $options->{field_sep} || ",";
my $field_quote = $options->{field_quote};
my $field_escape = $options->{field_escape};
open(App::Repository::DBI::FILE, "> $file") || die "Unable to open $file for writing: $!";
my ($i, $value);
foreach my $row (@$rows) {
if ($field_quote) {
for ($i = 0; $i <= $#$row; $i++) {
print App::Repository::DBI::FILE $field_sep if ($i > 0);
$value = $row->[$i];
if ($value =~ /$field_sep/) {
if ($field_escape) {
$value =~ s/$field_escape/$field_escape$field_escape/g;
$value =~ s/$field_quote/$field_escape$field_quote/g;
}
print App::Repository::DBI::FILE $field_quote, $value, $field_quote;
}
else {
print App::Repository::DBI::FILE $value;
lib/App/Repository.pm view on Meta::CPAN
my $maxrows = $options->{maxrows};
my $null_value = $options->{null_value};
$null_value = '\N' if (!defined $null_value);
my $field_sep = $options->{field_sep} || ",";
my $field_quote = $options->{field_quote} || "";
my $field_escape = $options->{field_escape} || "";
die "TODO: field_escape not yet implemented" if ($field_escape);
my $fieldsep_regexp = ($field_sep eq "|") ? '\|' : $field_sep;
my $quoted_field_regexp = "$field_sep?$field_quote([^$field_quote]*)$field_quote";
my $field_regexp = "$field_sep?([^$field_sep]*)";
my $num_cols = $#$cols + 1;
my $rows_read = 0;
lib/App/Repository.pm view on Meta::CPAN
my ($num_values_read, $line, $line_remainder, $row);
while (<$fh>) {
chomp;
$line = $_;
if ($line) {
if (!$field_quote && !$field_escape) {
$row = [ map { $_ eq $null_value ? undef : $_ } split(/$fieldsep_regexp/, $line) ];
$num_values_read = $#$row + 1;
}
else {
$num_values_read = 0;
view release on metacpan or search on metacpan
lib/App/RoboBot/Network/Mattermost.pm view on Meta::CPAN
# a regular message.
return if lc($nick->name) eq lc($self->nick->name);
my $raw_msg = exists $post->{'message'} && defined $post->{'message'} ? $post->{'message'} : '';
# Unescape a couple things
$raw_msg =~ s{\&}{&}g;
$raw_msg =~ s{\<}{<}g;
$raw_msg =~ s{\>}{>}g;
my $message = App::RoboBot::Message->new(
view release on metacpan or search on metacpan
lib/App/RouterColorizer.pm view on Meta::CPAN
# IPv6
$line =~ s/ ( (?<! [a-fA-F0-9:\-]) $IPV6CIDR (?! [\w:\.\/]) ) /$self->_ipv6ify($1)/egxx;
# Numbers
# We need to make sure we don't highlight undesirably, such as in an
# escape sequence.
$line =~ s/ (
(?<! [:\.0-9]) (?<! \e \[) (?<! \e \[\?)
[0-9]+ (?! [:0-9])
) /$self->_numerify($1)/egxx;
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/RunCron.pm view on Meta::CPAN
=head2 logfile
If logfile is specified, stdout and stderr of the command will be logged to the file so that it could be used for later inspection.
If not specified, the outputs will not be logged.
The logfile can be a C<strftime> format. eg. '%Y-%m-%d.log'. (NOTICE: '%' must be escaped in crontab.)
=head2 reporter|error_reporter|common_reporter
C<common_reporter> is optional, processing after C<(error_)?reporter> is handled.
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/Sandy/Command/Genome.pm view on Meta::CPAN
=item B<--join-paired-ends>
By default, paired-end reads are put into two different files,
I<prefix_R[12]_001.fastq(\.gz)?>. If the user wants both outputs
together, she can pass this option.
If the B<--id> does not have the escape character %R, it is
automatically included right after the first field (blank separated values)
as in I<id/%R> - which resolves to I<id/1> or I<id/2>.
It is necessary to distinguish which read is R1/R2
=item B<--compression-level>
lib/App/Sandy/Command/Genome.pm view on Meta::CPAN
e.g. SR123.1_chr1_P_1001_1101
See B<Format>
=item B<Format>
A string B<Format> is a combination of literal and escape characters similar to the way I<printf> works.
That way, the user has the freedom to customize the fastq sequence identifier to fit her needs. Valid
escape characteres are:
B<Common escape characters>
----------------------------------------------------------------------------
Escape Meaning
----------------------------------------------------------------------------
%i instrument id composed by SR + PID
lib/App/Sandy/Command/Genome.pm view on Meta::CPAN
%b read end position regarding reference genome ***
%v genomic variation position ***
----------------------------------------------------------------------------
*** specific for genomic variation (genome simulation only)
B<Paired-end specific escape characters>
----------------------------------------------------------------------------
Escape Meaning
----------------------------------------------------------------------------
%T mate read start position
lib/App/Sandy/Command/Genome.pm view on Meta::CPAN
And in order to learn how to add your custom quality-profile, see:
$ sandy quality add --help
Sequence identifiers (first lines of fastq entries) may be customized in output using
a format string passed by the user. This format is a combination of literal and escaped
characters, in a similar fashion to that used in C programming language’s printf function.
For example, let’s simulate a paired-end sequencing and add the read length, read position
and mate position into all sequence identifiers:
$ sandy genome \
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/SeismicUnixGui/misc/control.pm view on Meta::CPAN
sub set_first_name {
my ($self) = @_;
my ( $first_name, $suffix, $file_name );
# split by the escaped period
$file_name = $control->{_file_name};
( $first_name, $suffix ) = split( /\./, $file_name );
$control->{_first_name} = $first_name;
# print("control,set_first_name,is: $control->{_first_name}\n");
lib/App/SeismicUnixGui/misc/control.pm view on Meta::CPAN
my $first_name;
my $suffix;
# print("control,file_name,is: $control->{_file_name}\n");
# split by the escaped period
my $file_name = $control->{_file_name};
( $first_name, $suffix ) = split( /\./, $file_name );
$control->{_first_name} = $first_name;
# print("control,first_name,is: $first_name\n");
view release on metacpan or search on metacpan
lib/App/Sets.pm view on Meta::CPAN
LOGDIE "only file op file [op file...] "
. "with multiple parameters (@args)...\n"
unless @args % 2;
my @chunks;
while (@args) {
push @chunks, escape(shift @args);
push @chunks, shift @args if @args;
}
$input = join ' ', @chunks;
} ## end if (@args > 1)
else {
lib/App/Sets.pm view on Meta::CPAN
print {*STDOUT} "\n" if $config{trim};
}
return;
} ## end sub run
sub escape {
my ($text) = @_;
$text =~ s{(\W)}{\\$1}gmxs;
return $text;
}
view release on metacpan or search on metacpan
lib/App/SilverSplash.pm view on Meta::CPAN
sub make_post_url {
my ( $class, $splash_url, $dest_url ) = @_;
$dest_url = URI::Escape::uri_escape($dest_url);
my $separator = ($splash_url =~ m/\?/) ? '&' : '?';
my $location = $splash_url . $separator . "url=$dest_url";
return $location;