view release on metacpan or  search on metacpan

lib/Perl6/Export/Attrs.pm  view on Meta::CPAN

    for my $attr (@attrs) {

        ($attr||=q{}) =~ s/\A Export (?: \( (.*) \) )? \z/$1||q{}/exms
            or next ATTR;

        my @tagsets = grep {length $_} split m/ \s+,?\s* | ,\s* /xms, $attr;

        my (undef, $file, $line) = caller(1);
        $file =~ s{.*/}{}xms;

        if (my @bad_tags = grep {!m/\A :$IDENT \z/xms} @tagsets) {

 view release on metacpan or  search on metacpan

lib/Perl6/Perldoc/Parser.pm  view on Meta::CPAN

    # Work out what's in the TOC (including the =item/=item1 alias)...
    my $requested_types = $placement_obj->{target};
       $requested_types =~ s{\A \s* toc: \s*}{}xms;
    my %toc_wants; 
       @toc_wants{ split m/\s+/, $requested_types } = ();
    if (exists $toc_wants{item} || exists $toc_wants{item1}) {
       @toc_wants{qw< item item1 >} = ();
    }

    # Build flat list of tocitems into nested toclists...

lib/Perl6/Perldoc/Parser.pm  view on Meta::CPAN

    # Remove top/bottom border...
    $text =~ s{\A ($ROW_SEP_LINE)}{}xms;     my $top_sep    = $1 || q{};
    $text =~ s{\n ($ROW_SEP_LINE) \Z}{}xms;  my $bottom_sep = $1 || q{};

    # Decompose into separated rows...
    my ($first_row, $first_sep, @rest) = split m{($ROW_SEP_LINE)}xms, $text;
    my $has_head = @rest != 0 && $first_sep =~ $NWS_ROW_SEP;

    my @rows = @rest == 0 ? (split m{(\n)}xms, $text)
             : @rest == 1 && !$bottom_sep ?
                            ($first_row, $first_sep, split m{(\n)}xms, $rest[0])
             :              ($first_row, $first_sep, @rest)
             ;

    my @separators = ($top_sep, @rows[grep {$_%2!=0} 0..$#rows], $bottom_sep);
    my @cells      = @rows[grep {$_%2==0} 0..$#rows];

 view release on metacpan or  search on metacpan

docs/feather/~/gen.pl  view on Meta::CPAN

</p>
<ul>
END

my @dir = glob "/home/*/public_html/*";
my @users = keys %{ { map { (split m[/])[2] => undef } @dir } };

print { $fh } qq[<li><a href="/~$_/">$_</a></li>\n] for sort @users;

print { $fh } <<'END';
</ul>

 view release on metacpan or  search on metacpan

lib/Perl6/Str.pm  view on Meta::CPAN

    }
}

sub _split_markings {
    my $char = Unicode::Normalize::NFKD(shift);
    return split m//, $char, 2;
}

sub _copy_markings {
    my ($source, $pattern) = @_;
    my (undef, $accents) = _split_markings($pattern);

 view release on metacpan or  search on metacpan

lib/PerlIO/via/LineNumber.pm  view on Meta::CPAN

    # local copies of format and increment
    my ( $format, $increment )= @{ $_[0] }{ qw(format increment ) };

    # print all lines with line number, die if print fails
    foreach ( split m#(?<=$/)#, $_[1] ) {
        return -1
          if !print { $_[2] } sprintf( $format, $_[0]->{line}, $_ );
        $_[0]->{line} += $increment;
    }

 view release on metacpan or  search on metacpan

lib/PerlIO/via/PrepareCP1251.pm  view on Meta::CPAN

sub WRITE {
    my ( undef, $line, $handle ) = @_;
    utf8::decode $line;
    my $out = join q{},
        map { _convert_symbol($_) }
        split m//, $line;
    return ( print {$handle} $out ) ? length($line) : -1;
}

=pod

 view release on metacpan or  search on metacpan

lib/PerlIO/via/SeqIO.pm  view on Meta::CPAN

	$self->{eot} = 0;
	for ($self->{mode}) {
	    m/r/ && do {
		$self->{source} =
		    Bio::SeqIO->new( -fh=>$fh, -format=>$self->{format} );
		$self->{format} ||= (split m/::/,ref($self->{source}))[-1];
		last;
	    };
	    m/w|a/ && do {
		$self->set_write_format($self->{format});
		last;

lib/PerlIO/via/SeqIO.pm  view on Meta::CPAN

# subhandle, but delegate the work back to the 
# via class (is this Laziness, or laziness?)

sub AUTOLOAD {
    my ($self,@args) = @_;
    my $func = lc ((split m/::/, $AUTOLOAD)[-1]);
    # specials
    $func = uc $func if $func =~ /destroy/;

    for ($func) {
	# delegate these back to the via object:

 view release on metacpan or  search on metacpan

t/001_roundtrip.t  view on Meta::CPAN

}
print $tmph $last, "\n";
ok $tmph->close, "flush and put the lid down";
my $data;
gunzip $tmpf => \$data;
is( (split m{$/},$data)[0], $first, "first entry roundtrip" );
is( (split m{$/},$data)[-1], $last, "last entry roundtrip");
my $works = "It works!";
gzip \$works => $tmpf;
undef $tmph;
ok open($tmph, "<:via(gzip)", $tmpf), "open tempfile for decompressed reading";
is( my $a = <$tmph>, "It works!", "reading roundtrip" );

 view release on metacpan or  search on metacpan

bin/col  view on Meta::CPAN

while (<>) {
    # chop trailing characters not followed by a linefeed of any kind
    s/^(.*(?:\x0A|\e$re[0])|).*$/$1/sxo if $opt_t;

    my @chars = split m//;

    my $i;
    for ($i=0; $i<=$#chars; ++$i) {
        my $c = $chars[$i];

 view release on metacpan or  search on metacpan

lib/Perlito5X/File/Spec/OS2.pm  view on Meta::CPAN

}


sub splitdir {
    my ($self,$directories) = @_ ;
    split m|[\\/]|, $directories, -1;
}


sub catpath {
    my ($self,$volume,$directory,$file) = @_;

 view release on metacpan or  search on metacpan

lib/Pinto/Config.pm  view on Meta::CPAN

    # Some folks tend to put quotes around multi-value configuration
    # parameters, even though they shouldn't.  Be kind and remove them.
    my $sources = $self->sources;
    $sources =~ s/ ['"] //gx;

    return map { URI->new($_) } split m{ \s+ }mx, $sources;
}

#------------------------------------------------------------------------------

sub directories {

 view release on metacpan or  search on metacpan

lib/Plack/App/Directory/Apaxy.pm  view on Meta::CPAN

    for my $child (@children) {
        my $file = $child->{path};
        my $stat = $child->{stat};

        my $basename = $file->basename;
        my $url      = join '/', map { uri_escape($_) } split m{/}, $dir_url . $basename;

        my $mime_type;
        my $alt;
        my $icon;
        my $size;

 view release on metacpan or  search on metacpan

lib/Plack/App/Directory/Markdown.pm  view on Meta::CPAN

        my $is_dir = -d $file;
        next if !$is_dir && !$self->is_markdown($file);

        my @stat = stat _;

        $url = join '/', map {uri_escape($_)} split m{/}, $url;

        if ($is_dir) {
            $basename .= "/";
            $url      .= "/";
        }

 view release on metacpan or  search on metacpan

lib/Plack/App/Directory/Template.pm  view on Meta::CPAN

    if ($urlpath !~ m{/$}) {
        return $self->return_dir_redirect($env);
    }

    $urlpath = join('/', map {uri_escape($_)} split m{/}, $urlpath).'/';

    my $dh = DirHandle->new($dir);
    my @children;
    while (defined(my $ent = $dh->read)) {
        next if $ent eq '.' or $ent eq '..';

 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/Plack/App/TemplatedDirectory.pm  view on Meta::CPAN

		my ($ext) = $basename =~m/\.(\w*)$/;
 
        my $is_dir = -d $file;
        my @stat = stat _;
 
        $url = join '/', map {uri_escape($_)} split m{/}, $url;
 
        if ($is_dir) {
            $basename .= "/";
            $url      .= "/";
        }

 view release on metacpan or  search on metacpan

lib/Plack/Middleware/Auth/Htpasswd.pm  view on Meta::CPAN

    my $dir = Path::Class::Dir->new($self->file_root);
    my @htpasswd = $path ne '/'
        ? reverse
          map { $_->file('.htpasswd')->stringify }
          map { $dir = $dir->subdir($_) }
          split m{/}, $path
        : ($dir->file('.htpasswd')->stringify);

    for my $htpasswd (@htpasswd) {
        next unless -f $htpasswd && -r _;
        return $self->_check_password($htpasswd, $user, $pass);

 view release on metacpan or  search on metacpan

lib/Plack/Middleware/Debug/RefCounts.pm  view on Meta::CPAN

    }
    $all = undef;

    my %diff_list;
    foreach my $id (keys %$Arena_Refs) {
        my ($type, $addr) = split m!/!, $id, 2;
        my $cmp = $Arena_Refs->{$id};

        # Process the diff list
        $diff_list{$type}   //= [0,0,0];
        $diff_list{$type}[0] += $cmp;              # diff

 view release on metacpan or  search on metacpan

lib/Plack/Middleware/DirListing.pm  view on Meta::CPAN

    my $url = $env->{PATH_INFO} . $ent;

    my $is_dir = -d $file;
    my @stat = stat _;

    $url = join '/', map {uri_escape($_)} split m{/}, $url;

    if ($is_dir) {
      $ent .= "/";
      $url .= "/";
    }

 view release on metacpan or  search on metacpan

lib/Plack/App/Directory.pm  view on Meta::CPAN

        my $url = $dir_url . $basename;

        my $is_dir = -d $file;
        my @stat = stat _;

        $url = join '/', map {uri_escape($_)} split m{/}, $url;

        if ($is_dir) {
            $basename .= "/";
            $url      .= "/";
        }

 view release on metacpan or  search on metacpan

lib/Pod/Elemental/Transformer/Splint.pm  view on Meta::CPAN

    my $attribute_renderers = [];
    my $method_renderers = [];


    if(exists $args->{'attribute_renderer'}) {
        my @renderers = split m{,\s+}, $args->{'attribute_renderer'};

        for my $renderer (@renderers) {
            my($format, $class) = split m/=/, $renderer;
            push @{ $attribute_renderers } => { for => $format, class => $class };
        }
        $args->{'attribute_renderer'} = $attribute_renderers;
    }
    if(exists $args->{'method_renderer'}) {
        my @renderers = split m{,\s+}, $args->{'method_renderer'};

        for my $renderer (@renderers) {
            my($format, $class) = split m/=/, $renderer;
            $renderer = { for => $format, class => $class };
            push @{ $method_renderers } => { for => $format, class => $class };
        }
        $args->{'method_renderer'} = $method_renderers;
    }

lib/Pod/Elemental/Transformer/Splint.pm  view on Meta::CPAN

    foreach my $child (@{ $node->children }) {

        my $line_start = substr($child->content, 0 => length ($self->command_name) + 1);
        next CHILD if $line_start ne sprintf '%s ', $self->command_name;

        my($prefix, $action, $param, $data) = split m/\h+/, $child->content, 4;

        if($action eq 'classname' && defined $param) {
            eval "use $param";
            die "Can't use $param: $@" if $@;

 view release on metacpan or  search on metacpan

lib/Pod/Elemental/Transformer/SynHi.pm  view on Meta::CPAN

#pod =cut

sub standard_code_block {
  my ($self, $html) = @_;

  my @lines = split m{<br(?:\s*/)>|\n}, $html;

  # The leading nbsp below, in generating $code, is to try to get indentation
  # to appear in feed readers, which to not respect white-space:pre or the pre
  # element. The use of <br> instead of newlines is for the same reason.
  # -- rjbs, 2009-12-10

 view release on metacpan or  search on metacpan

Example.pm  view on Meta::CPAN

			# =begin text as commented text.
			if ($child->body =~ m/^text/ms) {
				$child_pod .= join "\n",
					map { ' #'.$_ }
					split m/\n/ms,
					($child->children)[0]->pod;
				$child_pod .= "\n\n";
				$first_node = 0;

			# Skip =begin html and other unsupported sections.

 view release on metacpan or  search on metacpan

lib/Pod/HtmlEasy/Parser.pm  view on Meta::CPAN

    # creates ...{TITLE}, and leaves it undef, so that it will be
    # picked up here when the paragraph following is processed.
    if (    ( exists $parser->{POD_HTMLEASY}{TITLE} )
        and ( not defined $parser->{POD_HTMLEASY}{TITLE} ) )
    {
        my @lines = split m{\n}smx, $text;
        my $tmp_text = shift @lines;
        if ( not defined $tmp_text ) { return $text; }
        $tmp_text =~ s{$RE{ws}{crop}}{}gsmx;   # delete surrounding whitespace
        $parser->{POD_HTMLEASY}{TITLE} = $tmp_text;
        $parser->{POD_HTMLEASY}{INFO_COUNT}++;

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

 v0.03 (2003/09/13)
       [ja]ドキュメント加筆
       [en] write much of documents
       [ja] ドキュメントを mlpod に分離
       [en] split mlpod documents into .mlpod files from .pm and .pod files
       MultiLang::Html
         o [ja] css,madeの指定がないときにはタグの生成も抑制するように
           [en] when css,made omitted, correspond html-tag not generate too
         o [ja] 非 ASCII 文字をアンカーにできるように実装
           [en] non-ascii chars can be used as anchor id

 view release on metacpan or  search on metacpan

lib/Pod/Perldoc.pm  view on Meta::CPAN

sub opt_M_with { # specify formatter class name(s)
  my($self, $classes) = @_;
  return unless defined $classes and length $classes;
  DEBUG > 4 and print "Considering new formatter classes -M$classes\n";
  my @classes_to_add;
  foreach my $classname (split m/[,;]+/s, $classes) {
    next unless $classname =~ m/\S/;
    if( $classname =~ m/^(\w+(::\w+)+)$/s ) {
      # A mildly restrictive concept of what modulenames are valid.
      push @classes_to_add, $1; # untaint
    } else {

 view release on metacpan or  search on metacpan

lib/Pod/SAX.pm  view on Meta::CPAN

	$page    = '';
	$section = $1;
    }
    else                          # all other cases
    {
	($page, $section) = split m(/), $text, 2;
	
	# to quiet -w
	defined $page    or $page    = '';
	defined $section or $section = '';
	

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

 splitter

     $parser->splitter($splitter);

    The $splitter is an instance of Text::HumanComputerWords, or something
    that implements a split method exactly like it does. It is used to
    split text into human and computer words. The default is reasonable for
    Perl.

METHODS

 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

lib/Pod/Simple/HTML.pm  view on Meta::CPAN

}

sub resolve_pod_page_link_batch_mode {
  my($self, $to) = @_;
  DEBUG > 1 and print STDERR " During batch mode, resolving $to ...\n";
  my @path = grep length($_), split m/::/s, $to, -1;
  unless( @path ) { # sanity
    DEBUG and print STDERR "Very odd!  Splitting $to gives (nil)!\n";
    return undef;
  }
  $self->batch_mode_rectify_path(\@path);