view release on metacpan or search on metacpan
lib/POE/Component/IRC/Plugin/WWW/Lipsum.pm view on Meta::CPAN
my $self = shift;
my $data_ref = shift;
my %args;
@args{ qw/amount what start html/ }
= map lc, split m|[/\s,]+|, $data_ref->{what};
$args{what} ||= 'words';
$args{amount} ||= '15';
if ( defined $args{html} and $args{html} =~ /yes/ ) {
view release on metacpan or search on metacpan
docs/rfc1459.html view on Meta::CPAN
behind that link.
Similarly, a QUIT message must be sent to the other connected servers
rest of the network on behalf of all clients behind that link. In
addition to this, all channel members of a channel which lost a
member due to the split must be sent a QUIT message.
If a server connection is terminated prematurely (e.g. the server on
the other end of the link died), the server which detects
this disconnection is required to inform the rest of the network
that the connection has closed and fill in the comment field
view release on metacpan or search on metacpan
lib/POE/Component/Server/IRC.pm view on Meta::CPAN
$args->[0] = 'l';
}
my $uid = $self->state_user_uid($nick);
my $watches = $self->{state}{uids}{$uid}{watches} || { };
my $list = 0;
ITEM: foreach my $item ( split m!,!, $args->[0] ) {
if ( $item =~ m!^\+! ) {
$item =~ s!^\+!!;
if ( keys %$watches >= $self->{config}{max_watch} ) {
push @$ref, ['512', $self->{config}{max_watch}];
next ITEM;
lib/POE/Component/Server/IRC.pm view on Meta::CPAN
my $sid = $self->server_sid();
my $server = $self->server_name();
my @local_users = map { $self->_state_uid_route( $_ ) }
grep { !$mode_u_set || $chanrec->{users}{$_} =~ /[oh]/ }
grep { $_ =~ m!^$sid! } keys %{ $chanrec->{users} };
my @mask_list = split m!\s+!, $masks;
my @marsk_list;
foreach my $marsk ( @mask_list ) {
my $mask = normalize_mask($marsk);
my $umask = uc_irc($mask);
next if $chanrec->{ $map{ $trype } }{$umask};
lib/POE/Component/Server/IRC.pm view on Meta::CPAN
$chan,
{
prefix => $server,
command => 'MODE',
colonify => 0,
params => [ $chan, split m! !, $modeline ],
},
$conn_id, '', '', 'chghost'
);
}
if ($rec->{away}) {
view release on metacpan or search on metacpan
lib/POE/Component/SmokeBox/Recent.pm view on Meta::CPAN
my %reply;
$reply{recent} = delete $self->{recent} if $self->{recent};
$reply{error} = delete $self->{error} if $self->{error};
$reply{context} = delete $self->{context} if $self->{context};
$reply{url} = delete $self->{url};
@{ $reply{recent} } = grep { my @parts = split m!/!; $parts[3] !~ m!^perl6$!i } @{ $reply{recent} };
my $event = delete $self->{event};
$kernel->post( $target, $event, \%reply );
$kernel->refcount_decrement( $target, __PACKAGE__ );
return;
}
view release on metacpan or search on metacpan
lib/POE/Filter/Transparent/SMTP.pm view on Meta::CPAN
The main purpose of this filter is to help
L<POE::Component::Client::SMTP> create transparent messages when
comunicating with an SMTP server. However the filter can be used by
any Perl SMTP client or server.
Internally it uses L<POE::Filter::Line> in order to split messages
into lines. Also as stated in the RFC every line it puts on the wire
is ended by <CRLF>.
When receiving data from the wire (as it is the case for an SMTP
server), lines should be separated with <CRLF> as the RFC
view release on metacpan or search on metacpan
lib/PPI/HTML/CodeFolder.pm view on Meta::CPAN
#
# force spans to end before line endings
#
$html=~s!(<br>\s*)</span>!</span>$1!g;
#
# split multiline comments into 2 spans: 1st line (in case its midline)
# and the remainder; note that the prior substitution avoids
# doing this to single line comments
#
$html=~s/(?!<br>\s+)(<span class=['"]comment['"]>[^<]+)<br>\n/$1<\/span><br>\n<span class="comment">/g;
#
view release on metacpan or search on metacpan
lib/PPI/Token/Number/Exp.pm view on Meta::CPAN
=cut
sub literal {
my $self = shift;
return if $self->{_error};
my ($mantissa, $exponent) = split m/e/i, $self->_literal;
my $neg = $mantissa =~ s/^\-//;
$mantissa =~ s/^\./0./;
$exponent =~ s/^\+//;
# Must cast exponent as numeric type, due to string type '00' exponent
view release on metacpan or search on metacpan
lib/PPIx/Grep.pm view on Meta::CPAN
sub _derive_ppi_classes {
my ($pattern) = @_;
my @ppi_classes;
foreach my $subpattern ( split m/,/xms, $pattern ) {
my $ppi_class = get_ppi_class($subpattern);
if (not $ppi_class) {
print
{_get_stderr()}
qq<Could not figure out what PPI::Element subclass to use for "$subpattern".\n>;
view release on metacpan or search on metacpan
lib/PPIx/Shorthand.pm view on Meta::CPAN
my $no_prefix = lc substr $ppi_class, $PPI_PREFIX_LENGTH;
$self->{$no_prefix} = $ppi_class;
$self->_add_plural($no_prefix, $ppi_class);
my @components = split m/::/xms, $no_prefix;
foreach my $separator ( qw< _ - . : >, $EMPTY_STRING ) {
my $shorthand = join $separator, @components;
$self->{$shorthand} = $ppi_class;
$self->_add_plural($shorthand, $ppi_class);
} # end foreach
view release on metacpan or search on metacpan
t/split-ppi-node-by-namespace.t view on Meta::CPAN
my $document = PPI::Document->new(\$source);
my %expanded_expected;
while ( my ($namespace, $strings) = each %{$expected_ref} ) {
$expanded_expected{$namespace} =
[ map { [ split m/ \n /xms ] } @{$strings} ];
} # end while
my $got = split_ppi_node_by_namespace($document);
my %got_expanded;
while ( my ($namespace, $ppi_doms) = each %{$got} ) {
view release on metacpan or search on metacpan
t/split_ppi_node_by_namespace.t view on Meta::CPAN
my %expanded_expected;
foreach my $namespace ( keys %{$expected_ref} ) {
my $strings = $expected_ref->{$namespace};
$expanded_expected{$namespace} =
[ map { [ split m/ \n /x ] } @{$strings} ];
}
my $got = split_ppi_node_by_namespace($document);
my %got_expanded;
foreach my $namespace ( keys %{$got} ) {
view release on metacpan or search on metacpan
a package and all of its prerequisites
- fixes for setting the version number in certain edge cases
(thanks to Serguei Trouchelle for the patch)
- if fetch_file() fails on assuming the argument passed is a
module, try it as a distribution.
- split methods used in PPM::Make to obtain meta information
about a distribution into PPM::Make::Meta
- split functions used in PPM::Make to obtain config information
into PPM::Make::Config
- if the author meta information is an array ref, dereference it
when writing the ppd file
view release on metacpan or search on metacpan
server/PPMServer.pm view on Meta::CPAN
# trim everything up to the first <SOFTPKG>
$searchsummaryastext =~ s/.*?<SOFTPKG/<SOFTPKG/s;
}
my $output = "<REPOSITORYSUMMARY>";
my @ppd_data = split m@</SOFTPKG>@o, $searchsummaryastext
unless @ppd_data;
foreach my $pkg (@ppd_data) {
if ($pkg =~ m@<${searchtag}>(.*)</${searchtag}>@s) {
next unless $1 =~ /${searchRE}/;
if ($pkg =~ m@<ARCHITECTURE.*${archname}.*?/>@s) {
view release on metacpan or search on metacpan
lib/Package/Pkg.pm view on Meta::CPAN
sub split {
my $self = shift;
my $target = shift;
return unless defined $target && length $target;
return split m/::/, $target;
}
sub split2 {
my $self = shift;
return unless my @split = $self->split( @_ );
view release on metacpan or search on metacpan
share/doc/wxwidgets.pod view on Meta::CPAN
=head2 Wx::SplitterWindow::GetSplitMode
int GetSplitMode() const
Gets the split mode.
See also
wxSplitterWindow::SetSplitMode, wxSplitterWindow::SplitVertically,
wxSplitterWindow::SplitHorizontally.
share/doc/wxwidgets.pod view on Meta::CPAN
=head2 Wx::SplitterWindow::SetSplitMode
void SetSplitMode(int mode)
Sets the split mode.
Parameters
mode
view release on metacpan or search on metacpan
lib/Padre/Wx/Panel/Debugger.pm view on Meta::CPAN
my $auto_values = $self->{client}->get_y_zero;
$auto_values =~ s/^([\$\@\%]\w+)/:;$1/xmg;
my @auto = split m/^:;/xm, $auto_values;
#remove ghost at begining
shift @auto;
# This is better I think, it's quicker
lib/Padre/Wx/Panel/Debugger.pm view on Meta::CPAN
my $var_regex = '!(INC|ENV|SIG)';
my $auto_values = $self->{client}->get_x_vars($var_regex);
$auto_values =~ s/^((?:[\$\@\%]\w+)|(?:[\$\@\%]\S+)|(?:File\w+))/:;$1/xmg;
my @auto = split m/^:;/xm, $auto_values;
#remove ghost at begining
shift @auto;
# This is better I think, it's quicker
view release on metacpan or search on metacpan
lib/Palm/Progect.pm view on Meta::CPAN
sub _db_name_from_filename {
my $filename = shift;
$filename =~ tr{\\}{/};
$filename =~ tr{:}{/};
$filename = (split m{/}, $filename)[-1];
$filename =~ s/^lbPG-//;
$filename =~ s/\..*?$//;
return $filename;
}
view release on metacpan or search on metacpan
lib/Parallel/Dragons.pm view on Meta::CPAN
sub daemon_name {
my $self = shift;
my $name = $self->sockfile;
($name) = (split m{/}, $name)[-1];
return "Dragons of $name";
}
sub check_daemon {
my $self = shift;
lib/Parallel/Dragons.pm view on Meta::CPAN
alarm(10);
my $input = <$conn>;
my @args = split m{\s+}, $input;
while (my $cmd = shift @args) {
$cmd = lc $cmd;
if ($daemon_commands{ $cmd } ) {
my @res = $daemon_commands{ $cmd }->(
view release on metacpan or search on metacpan
lib/Paranoid/Filesystem.pm view on Meta::CPAN
# Skip directories already present
next if -d $directory;
# Otherwise, split so we can backtrack to the first available
# subdirectory and start creating subdirectories from there
@parts = split m#/+#s, $directory;
$i = $parts[0] eq '' ? 1 : 0;
$i++ while $i < $#parts and -d join '/', @parts[ 0 .. $i ];
while ( $i <= $#parts ) {
$subdir = join '/', @parts[ 0 .. $i ];
unless ( -d $subdir ) {
view release on metacpan or search on metacpan
lib/Parse/BBCode.pm view on Meta::CPAN
# we have a string, compile
#warn __PACKAGE__.':'.__LINE__.": $key => $output\n";
if ($output =~ s/^(inline|block|url)://) {
$class = $1;
}
my @parts = split m!($re_split)!, $output;
#warn __PACKAGE__.':'.__LINE__.$".Data::Dumper->Dump([\@parts], ['parts']);
my @compiled;
for my $p (@parts) {
if ($p =~ m/$re_cmp/) {
my ($escape, $type) = ($1, $2);
lib/Parse/BBCode.pm view on Meta::CPAN
#warn __PACKAGE__.':'.__LINE__.$".Data::Dumper->Dump([\$in_url], ['in_url']);
#warn __PACKAGE__.':'.__LINE__.": ============= match $text\n";
my $tag;
my ($before, $tag1, $tag2, $after);
if ($re_classic and $re_short) {
($before, $tag1, $tag2, $after) = split m{
(?:
\[ ($re_short) (?=://)
|
\[ ($re_classic) (?=\b|\]|\=)
)
}ix, $text, 2;
}
elsif (! $re_classic and $re_short) {
($before, $tag1, $after) = split m{
\[ ($re_short) (?=://)
}ix, $text, 2;
}
elsif ($re_classic and !$re_short) {
($before, $tag2, $after) = split m{
\[ ($re_classic) (?=\b|\]|\=)
}ix, $text, 2;
}
{ no warnings;
# warn __PACKAGE__.':'.__LINE__.": $before, $tag1, $tag2, $after)\n";
view release on metacpan or search on metacpan
t/data/03modlist.data view on Meta::CPAN
'b',
'd',
'p',
'O',
'g',
'Yet another procmail alike for to split mail',
'THEDEVIL',
'19'
],
[
'Math::Evol',
view release on metacpan or search on metacpan
lib/Parse/CPAN/Perms.pm view on Meta::CPAN
$inheader = 0 if not m/ \S /x;
next;
}
chomp;
my ($module, $author, $perm) = split m/\s* , \s*/x;
$perms->{$module}->{$author} = $perm;
}
return $perms;
}
view release on metacpan or search on metacpan
lib/Parse/Crontab/Schedule/Entity.pm view on Meta::CPAN
my $reg = '('. join('|', map {quotemeta $_} $self->aliases).')';
$entity =~ s/$reg/$self->_aliases_map->{lc($1)}/eig;
}
for my $item (split /,/, $entity) {
my ($range_or_num, $increments) = split m!/!, $item, 2;
if ($increments) {
die 'entity not valid. (range is strange)' unless $self->_is_range($range_or_num);
my $count = 0;
for my $i ($self->_expand_range($range_or_num)) {
view release on metacpan or search on metacpan
lib/Parse/HTTP/UserAgent/Base/IS.pm view on Meta::CPAN
&& @{ $thing } > 0
&& $thing->[-1]
&& index( $thing->[-1], 'AppleWebKit' ) != NO_IMATCH
) {
# More stupidity: ua string is missing a closing paren
my($part, @rest) = split m{(AppleWebKit)}xms, $thing->[-1];
$thing->[-1] = $part;
@{ $others } = map { $self->trim( $_ ) }
split m{ (\QKHTML, like Gecko\E) }xms,
join q{}, @rest;
return 1;
}
return;
}
view release on metacpan or search on metacpan
lib/Parse/MIME.pm view on Meta::CPAN
# Java URLConnection class sends an Accept header that includes a single "*"
# Turn it into a legal wildcard.
$full_type = '*/*' if $full_type eq '*';
my ( $type, $subtype ) = _strip split m!/!, $full_type;
return ( $type, $subtype, \%param );
}
sub parse_media_range {
view release on metacpan or search on metacpan
examples/7.0.3/asup01.txt view on Meta::CPAN
access cache thread signals (scrub, fill) = (1382865, 12216)
access cache flushes during (scrub, fill, flush) = (0, 0, 0)
access cache harvests during (scrub, fill, flush) = (2619, 8, 0)
access cache name service errors causing not caches (ro/rw, root) = (0, 0)
access cache name service errors via invalid caches (ro/rw, root) = (0, 0)
assist queue (queued, split mbufs, drop for EAGAIN) = (2904, 3, 4)
RPCSEC_GSS context limit=0
current context count=0, maximum context count=0
context reclaim callbacks=0, context idle/expired scans=0
vm pressure callbacks=268441317
view release on metacpan or search on metacpan
lib/Parse/PMFile.pm view on Meta::CPAN
next;
}
# Check that package name matches case of file name
{
my (undef, $module) = split m{/lib/}, $self->{PMFILE}, 2;
if ($module) {
$module =~ s{\.pm\z}{};
$module =~ s{/}{::}g;
if (lc $module eq lc $package && $module ne $package) {
view release on metacpan or search on metacpan
lib/Parse/RPN.pm view on Meta::CPAN
=head2 a b SPLIT
return all splitted item of 'a' by the separator 'b'
'b' is a REGEX
!!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry
!!! if the split match on the beginning of string,
SPLIT return the matched value WITHOUT the empty string of the beginning
=cut
$dict{SPLIT} = sub {
lib/Parse/RPN.pm view on Meta::CPAN
=head2 a b SPLITI
return all splitted item of 'a' by the separator 'b'
'b' is a REGEX case insensitive
!!! becare, if you need to use : as a regex, you need to backslash to prevent overlap with new dictionary entry
!!! if the split match on the beginning of string,
SPLIT return the matched value WITHOUT the empty string of the beginning
=cut
$dict{SPLITI} = sub {
view release on metacpan or search on metacpan
lib/Parse/Services.pm view on Meta::CPAN
for my $line (split /^/, $content) {
$line =~ s/#.*//;
next unless $line =~ /\S/;
chomp $line;
my ($name, $port_proto, @aliases) = split /\s+/, $line;
my ($port, $proto) = split m!/!, $port_proto;
push @res, {
name => $name,
port => $port,
proto => $proto,
aliases => \@aliases,
view release on metacpan or search on metacpan
lib/Parse/Syslog/Line.pm view on Meta::CPAN
if( !$msg{program_sub} ) {
($msg{program_sub}) = ($remainder =~ /^(?:[\/\s])?([^\[(]+)/o);
}
}
if( $msg{program_name} !~ m{^/} && $msg{program_name} =~ tr{/}{} ) {
@msg{qw(program_name program_sub)} = split m{/}, $msg{program_name}, 2;
}
}
}
elsif( $raw_string =~ s/$RE{program_netapp}//o ) {
# Check for a [host thing.subthing:level]: tag