view release on metacpan or search on metacpan
$noarch = 0 if grep { /\.(xs|c|cc|C)$/ } @files;
}
my %prefixes;
foreach (@files) {
my @path_components = split m[/], $_;
$prefixes{$path_components[0]}++;
if ($path_components[-1] eq 'META.yml') {
my $tar = new Archive::Tar;
$tar->read("$tmpdir/$tarball", 1);
view release on metacpan or search on metacpan
lib/RRDTool/OO.pm view on Meta::CPAN
#################################################
sub option_add {
#################################################
my($self, $method, @options) = @_;
my @parts = split m#/#, $method;
my $ref = $OPTIONS;
$ref = $ref->{$_} for @parts;
push @{ $ref->{optional} }, $_ for @options;
}
lib/RRDTool/OO.pm view on Meta::CPAN
$options = [] unless defined $options;
my %options_hash = (@$options);
my @parts = split m#/#, $method;
my $ref = $OPTIONS;
$ref = $ref->{$_} for @parts;
view release on metacpan or search on metacpan
lib/RTF/Writer/TableRowDecl.pm view on Meta::CPAN
# Pass thru (altho normally impossible)
} elsif( ref $alignments[0] ) {
@alignments = @{$alignments[0]}
# I.e., they passed align => [...]
} else {
@alignments = grep length($_), split m/(?:\s*,\s*)|\s+/, $alignments[0];
# I.e., they passed in align => 'sw c c t' or 'sw, c, t' or whatever.
}
my($x, $v, $h);
foreach my $spec (@alignments) {
lib/RTF/Writer/TableRowDecl.pm view on Meta::CPAN
my @widths = (undef, undef, undef, undef);
my @styles = (undef, undef, undef, undef);
my($dir, $width, $style);
my @specs = split m/(?:,|\s+)/, $spec;
foreach my $it (@specs) {
next unless $it;
unless( ($dir, $width, $style) = $it =~
view release on metacpan or search on metacpan
html/Foundry/Project/Wiki/lib/CGI/Kwiki/Formatter.pm view on Meta::CPAN
}
$_ = $self->lists_format($text);
}
$_;
}
split m!(^[0\*]+ .*?\n)(?=(?:[^0\*]|$))!ms, $text;
}
sub lists_format {
my ($self, $text) = @_;
return $text;
html/Foundry/Project/Wiki/lib/CGI/Kwiki/Formatter.pm view on Meta::CPAN
unless ($switch++ % 2) {
$_ = $self->paragraph_format($_);
}
$_;
}
split m!(\n\s*\n)!ms, $text;
}
sub paragraph_format {
my ($self, $text) = @_;
return '' if $text =~ /^[\s\n]*$/;
view release on metacpan or search on metacpan
lib/Razor2/String.pm view on Meta::CPAN
print "split_mime: returning total_len=" . length($mimepart) . "; hdrs=" . $hdrlen . ", body=" . length($$mailref) . "\n" if $debug;
return ( \$mimepart );
}
#
# Now we split mailref into hdr and body
# check hdr for nested mime (boundary)
#
my $orig_hdr = $hdr;
$hdr =~ s/\n\s+//sg; # merge multi-line headers
view release on metacpan or search on metacpan
lib/Regexp/Common/Email/Address.pm view on Meta::CPAN
package Regexp::Common::Email::Address;
# $Id: Address.pm,v 1.1 2005/01/06 16:10:10 cwest Exp $
use strict;
use vars qw[$VERSION];
$VERSION = sprintf "%d.%02d", split m/\./, (qw$Revision: 1.1 $)[1];
use Regexp::Common qw[pattern];
use Email::Address;
pattern name => [qw[Email Address]],
view release on metacpan or search on metacpan
t/archive.source.t view on Meta::CPAN
$record =~ m{\nFiles:\h*\n((?:\s+[^\n]+\n)+)}s or
die
qq|(ASK_DEBIAN) was requested, however that record\n\n| .
qq|${record}has no (Files:) line|;
$askdebian{$_}++
foreach map +( split m{\s} )[3], split m{\n}, $1 }}}
my %patterns = t::TestSuite::RCD_load_patterns;
plan tests =>
4 + @{$patterns{match_source_1_0}} +
4 + @{$patterns{match_source_3_0_native}} +
view release on metacpan or search on metacpan
lib/Regexp/Grammars.pm view on Meta::CPAN
# (?<PARAMLIST> \( \s* (?&PARAMS)? \s* \) | (?# NOTHING ) )
# (?<PARAMS> (?&PARAM) \s* (?: , \s* (?&PARAM) \s* )* ,? )
# (?<PARAM> (?&VAR) (?: \s* = \s* (?: (?&LITERAL) | (?&PARENCODE) ) )? )
# (?<LITERAL> (?&NUMBER) | (?&STRING) | (?&VAR) )
# (?<VAR> : (?&IDENT) )
my @defns = split m{
(< (obj|)(rule|token) \s*+ :
\s*+ ((?:${IDENT}::)*+) (?: ($IDENT) \s*+ = \s*+ )?+
($IDENT)
\s* >)
}xms, $grammar_spec;
view release on metacpan or search on metacpan
lib/Regexp/Optimizer.pm view on Meta::CPAN
sub _assemble {
my $str = shift;
return $str if $str !~ $re_optimize;
if ( $str !~ m/[(]/ms ) {
my $ra = Regexp::Assemble->new();
$ra->add( split m{[|]}, $str );
return $ra->as_string;
}
$str =~ s{$re_nested}{
no warnings 'uninitialized';
my $sub = $1;
view release on metacpan or search on metacpan
<body>
EOH
my $fhx = $fhtm . "_x";
my $done = 0;
if (grep { -x } map { "$_/pandoc" } grep { $_ && -d } split m/:+/ => $ENV{PATH}) {
say "Converting with pandoc";
system "pandoc", "-t", "html", "-o", $fhx, $fmd;
if (open my $xh, "<", $fhx) {
print $fh (<$xh>);
print $fh "</body></html>\n";
}
else {
warn "pandoc failed to create HTML\n";
}
}
if (!$done and grep { -x } map { "$_/cmark" } grep { $_ && -d } split m/:+/ => $ENV{PATH}) {
say "Converting with cmark";
if (my @h = `cmark -t html $fmd`) {
print $fh @h;
print $fh "</body></html>\n";
close $fh;
view release on metacpan or search on metacpan
lib/Remind/Parser.pm view on Meta::CPAN
else {
unless (defined $loc) {
die "Input does not contain file and line offsets; you must use option -p with remind";
}
my ($date, $special, $tag, $duration, $offset, $description) = split / +/, $_, 6;
my ($year, $month, $day) = split m{[-/]}, $date;
if ($self->strip_times && $description =~ s/^((\d\d?):(\d\d)([ap]m) )//) {
# Strip the time -- but then restore it if it doesn't match
# the offset in minutes
my ($stripped, $H, $M, $pm) = ($1, $2, $3, $4 eq 'pm');
$description = $stripped . $description
view release on metacpan or search on metacpan
lib/Remote/Perl/Client.pm view on Meta::CPAN
#
# Architecture: one persistent relay process, plus one executor per RUN.
# Client (relay) -- owns the protocol pipe; runs the select loop permanently.
# Executor -- runs the user script with real STDIN/STDOUT/STDERR pipes.
#
# This split means the protocol loop is never blocked by script I/O, enabling
# real-time stdout/stderr streaming and correct signal forwarding.
use Fcntl qw(F_SETFD FD_CLOEXEC O_RDWR);
use Socket qw(AF_UNIX SOCK_STREAM);
use POSIX qw(WNOHANG);
view release on metacpan or search on metacpan
lib/Repository/Simple/Util.pm view on Meta::CPAN
else {
$abs_path = $messy_path;
}
# Break into components
my @components = split m#/+#, $abs_path;
@components = ('', '') unless @components; # account for root
unshift @components, '' unless @components > 1;
# Manipulate the path components based upon each entry, work left-to-right
# to ensure proper handling of each component.
lib/Repository/Simple/Util.pm view on Meta::CPAN
if ($path eq '/') {
return '/';
}
else {
my @components = split m{/}, $path;
pop @components;
push @components, '' if @components == 1;
return join '/', @components;
}
}
lib/Repository/Simple/Util.pm view on Meta::CPAN
if ($path eq '/') {
return '/';
}
else {
my @components = split m{/}, $path;
return pop @components;
}
}
=back
view release on metacpan or search on metacpan
vendor/rocksdb/build_tools/gnu_parallel view on Meta::CPAN
$f =~ s:.*/\./:$workdir/:;
} elsif($f =~ m:^[^/]:) {
# foo/bar => workdir/foo/bar
$f = $workdir."/".$f;
}
my @subdirs = split m:/:, ::dirname($f);
my @rmdir;
my $dir = "";
for(@subdirs) {
$dir .= $_."/";
unshift @rmdir, ::shell_quote_file($dir);
view release on metacpan or search on metacpan
local/lib/perl5/Module/Build/Base.pm view on Meta::CPAN
@{ $self->rscan_dir($dir, $self->file_qr("\\.$type\$")) } };
}
sub localize_file_path {
my ($self, $path) = @_;
return File::Spec->catfile( split m{/}, $path );
}
sub localize_dir_path {
my ($self, $path) = @_;
return File::Spec->catdir( split m{/}, $path );
}
sub fix_shebang_line { # Adapted from fixin() in ExtUtils::MM_Unix 1.35
my ($self, @files) = @_;
my $c = ref($self) ? $self->{config} : 'Module::Build::Config';
view release on metacpan or search on metacpan
lib/Rose/HTML/Form.pm view on Meta::CPAN
name => 'hobbies',
choices => [ 'Chess', 'Checkers', 'Knitting' ],
default => 'Chess'
},
bday = => { type => 'date split mdy' }
);
}
...
lib/Rose/HTML/Form.pm view on Meta::CPAN
Returns true if a L<param|/param> exists that addresses the field named NAME or the L<Rose::HTML::Form::Field>-derived object FIELD, false otherwise.
This method is useful for determining if any query parameters exist that address a compound field. For example, a compound field named C<a.b.c.d> could be addressed by any one of the following query parameters: C<a>, C<a.b>, C<a.b.c>, or C<a.b.c.d>....
$form = Rose::HTML::Form->new;
$form->add_field(when => { type => 'datetime split mdyhms' });
$form->params({ 'when.date' => '2004-01-02' });
$form->param_exists_for_field('when'); # true
$form->param_exists_for_field('when.date'); # true
$form->param_exists_for_field('when.date.month'); # true
$form->param_exists_for_field('when.time.hour'); # false
$subform = Rose::HTML::Form->new;
$subform->add_field(subwhen => { type => 'datetime split mdyhms' });
$form->add_form(subform => $subform);
$form->params({ 'subform.subwhen.date' => '2004-01-02' });
$form->param_exists_for_field('subform.subwhen'); # true
view release on metacpan or search on metacpan
lib/Router/Dumb.pm view on Meta::CPAN
unless my $match = $route->check($str);
return $match;
}
my @parts = split m{/}, $str;
for my $candidate ($self->ordered_routes(
sub {
($_->part_count == @parts and $_->has_params)
or ($_->part_count <= @parts and $_->is_slurpy)
view release on metacpan or search on metacpan
lib/Router/Pygmy.pm view on Meta::CPAN
# return (name, \@args)
sub match {
my ( $this, $path ) = @_;
my @parts = grep { length($_) > 0 } split m{/}, $path;
my @args;
my $lookup = $this->{lookup};
while (@parts) {
view release on metacpan or search on metacpan
# Instruction.
} elsif ($tag_type =~ m/^\?/ms) {
$data =~ s/^<\?//ms;
$data =~ s/\s*\?>$//ms;
my ($target, $code) = split m/\s+/ms, $data, 2;
$self->{'output'}->(instruction($target, $code));
} else {
err "Unsupported tag type '$tag_type'.";
}
view release on metacpan or search on metacpan
xt/21_run.t view on Meta::CPAN
# pass a specific module to test,
# using e.g. "prove xt/21_run.t :: Test::SNMP::Info::MAU"
if (scalar @ARGV) { @found = @ARGV }
# cannot do this inline with findallmod
@found = sort { (scalar split m/::/, $a) <=> (scalar split m/::/, $b)
or
$a cmp $b } @found;
# my $total = scalar @found - scalar @BAD_MODULES;
# this did not work because @found can be a subset (e.g. via ARGV), so subtracting
view release on metacpan or search on metacpan
lib/SOAP/Transport/POP3.pm view on Meta::CPAN
my $method = ! $server->auth || $server->auth eq '*'
? 'login'
: $server->auth eq '+APOP'
? 'apop'
: Carp::croak "Unsupported authentication scheme '@{[$server->auth]}'";
$self->{_pop3server}->$method( split m{:}, $server->user() )
or Carp::croak "Can't authenticate to '@{[$server->host_port]}' with '$method' method"
if defined $server->user;
return $self;
}
view release on metacpan or search on metacpan
lib/SOAP/Transport/JABBER.pm view on Meta::CPAN
# nothing to do if new endpoint is the same as current one
return $self
if $self->SUPER::endpoint && $self->SUPER::endpoint eq $endpoint;
my $uri = URI->new($endpoint);
my ( $undef, $to, $resource ) = split m!/!, $uri->path, 3;
$self->Connect(
hostname => $uri->host,
port => $uri->port,
) or Carp::croak "Can't connect to @{[$uri->host_port]}: $!";
lib/SOAP/Transport/JABBER.pm view on Meta::CPAN
my ( $envelope, $endpoint, $encoding ) =
@parameters{qw(envelope endpoint encoding)};
$self->endpoint( $endpoint ||= $self->endpoint );
my ( $undef, $to, $resource ) = split m!/!, URI->new($endpoint)->path, 3;
# Create a Jabber info/query message
my $iq = new Net::Jabber::IQ();
$iq->SetIQ(
type => 'set',
lib/SOAP/Transport/JABBER.pm view on Meta::CPAN
$self->{_jabberserver}->Connect(
hostname => $uri->host,
port => $uri->port,
) or Carp::croak "Can't connect to @{[$uri->host_port]}: $!";
my ( $undef, $resource ) = split m!/!, $uri->path, 2;
my @result = $self->AuthSend(
username => $uri->user,
password => $uri->password,
resource => $resource || 'soapliteServer',
);
view release on metacpan or search on metacpan
lib/SOAP/WSDL.pm view on Meta::CPAN
my $body=$binding_operation->first_input()->first_body();
# {
if ($body->get_parts()) {
$method->{ parts } = []; # make sure it's empty
my $message_part_ref = $message->get_part();
for my $name ( split m{\s}xm , $body->get_parts() ) {
$name =~s{ \A [^:]+: }{}xm; # throw away ns prefix
# could probably made more efficient, but our lists are
# usually quite short
push @{ $method->{ parts } },
grep { $_->get_name() eq $name } @{ $message_part_ref };
view release on metacpan or search on metacpan
inc/inc_Module-Build/Module/Build/Base.pm view on Meta::CPAN
@{ $self->rscan_dir($dir, file_qr("\\.$type\$")) } };
}
sub localize_file_path {
my ($self, $path) = @_;
return File::Spec->catfile( split m{/}, $path );
}
sub localize_dir_path {
my ($self, $path) = @_;
return File::Spec->catdir( split m{/}, $path );
}
sub fix_shebang_line { # Adapted from fixin() in ExtUtils::MM_Unix 1.35
my ($self, @files) = @_;
my $c = ref($self) ? $self->{config} : 'Module::Build::Config';
view release on metacpan or search on metacpan
$fatpacked{"Parse/CPAN/Meta.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'PARSE_CPAN_META';
use 5.008001;use strict;package Parse::CPAN::Meta;our$VERSION='1.4414';use Exporter;use Carp 'croak';our@ISA=qw/Exporter/;our@EXPORT_OK=qw/Load LoadFile/;sub load_file {my ($class,$filename)=@_;my$meta=_slurp($filename);if ($filename =~ /\.ya?ml$/)...
PARSE_CPAN_META
$fatpacked{"Parse/PMFile.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'PARSE_PMFILE';
package Parse::PMFile;sub __clean_eval {eval $_[0]}use strict;use warnings;use Safe;use JSON::PP ();use Dumpvalue;use version ();use File::Spec ();our$VERSION='0.36';our$VERBOSE=0;our$ALLOW_DEV_VERSION=0;our$FORK=0;our$UNSAFE=$] < 5.010000 ? 1 : 0;...
read the file. It issued the following error: C< $err->{r} >},);$errors{$package}={open=>$err->{r},infile=>$pp->{infile},}}else {$pp->{version}="undef";$self->_verbose(1,qq{Parse::PMFile was not able to
parse the following line in that file: C< $err->{line} >
Note: the indexer is running in a Safe compartement and cannot
provide the full functionality of perl in the VERSION line. It
view release on metacpan or search on metacpan
0.19 2023-02-08
[Prerequirement Changes]
* SPVM 0.9691+ is needed.
0.18 2023-01-30
[New Features]
* Added the split method in the Regex class.
method split : string[] ($string : string, $limit = 0 : int);
0.17 2022-12-26
[Bug Fix]
view release on metacpan or search on metacpan
* Improve exception messages outputted from spvmdist command.
* The heading of a compilation error message is changed from [Compile Error] to [Compilation Error]
* Improve exception messages in operators.
* Improve exception messages in the instance method call.
[Test Improvement]
* Add a test for Fn#split method when a input is an empty string.
* Clean up tests for array operations.
* Clean up tests for type cast.
[Bug Fix]
* Fix a bug mention by "Segfault:compile_type_name" https://github.com/yuki-kimoto/SPVM/issues/554.
* Fix a bug that wrong static method call cause an segmentation fault.
* Removed INIT block in the SPVM::Global module. The global API is initialized at runtime when SPVM::api() is called at first.
[Build Process Bug Fix]
* Fixed the bug that the version of SPVM can't be parsed in SPVM.pm file.
0.9685 2022-01-26
[Imcompatible Changes]
* The default beheivior of the split method in the Fn class becomes the same as the split function in Perl.
the split method supports 0 limit and the default becomes 0.
[Before]
static method split : string[] ($separator : string, $string : string, $limit = -1 : int);
[After]
static method split : string[] ($separator : string, $string : string, $limit = 0 : int);
view release on metacpan or search on metacpan
lib/SQL/Abstract/More.pm view on Meta::CPAN
sub _where_field_IN {
my ($self, $k, $op, $vals) = @_;
# special algorithm if the key is multi-columns (contains a multicols_sep)
if ($self->{multicols_sep}) {
my @cols = split m[$self->{multicols_sep}], $k;
if (@cols > 1) {
if ($self->{has_multicols_in_SQL}) {
# DBMS accepts special SQL syntax for multicolumns
return $self->_multicols_IN_through_SQL(\@cols, $op, $vals);
}
view release on metacpan or search on metacpan
lib/SQL/Format.pm view on Meta::CPAN
sub sqlf {
my $format = shift;
my @bind;
my @tokens = split m#(%[ctwosj])(?=\W|$)#, $format;
for (my $i = 1; $i < @tokens; $i += 2) {
my $spec = $tokens[$i];
my $method = $SPEC_TO_METHOD_MAP->{$spec};
croak "'$spec' does not supported format" unless $method;
croak sprintf "missing arguments nummber of %i and '%s' format in sqlf",
view release on metacpan or search on metacpan
lib/SQL/YASP.pm view on Meta::CPAN
{$rv =~ s|''|'|sg}
elsif ($rv =~ s|^"(.*)"$|$1|s)
{$rv =~ s|""|"|sg}
# escapes
my @sets = split m|(\\.)|, $rv;
grep {
s|\\0|$nullchar|o;
s|\\z|$wineof|o;
s|\\t|\t|;