view release on metacpan or  search on metacpan

t/01_fillin.t  view on Meta::CPAN

use Template;

my $query = CGI->new({ foo => 'bar', bar => 'baz' });
my $tt = Template->new;

local $/ = '';
while (<DATA>) {
    my($test, $expect) = /^--test--\n(.*?)\n--expect--\n(.*?)\n$/s;
    my @expect = split /\n/, $expect;
    $tt->process(\$test, { query => $query }, \my $out);
    like $out, qr/$_/ for @expect;

 view release on metacpan or  search on metacpan

lib/Test/Group.pm  view on Meta::CPAN

                  no warnings "once";
                  local $Data::Dumper::Indent = 1;
                  local $Data::Dumper::Terse = 1;
                  Data::Dumper::Dumper($exn) } :
               "$exn" ? "$exn" : "a blank exception" );
        { local $/ = ""; chomp($exntext); }
        my $message = <<"MESSAGE";
Test ``$name'' died:
$exntext
MESSAGE
        if ($classstate_logfd) {

 view release on metacpan or  search on metacpan

lib/Test/LectroTest/FailureRecorder.pm  view on Meta::CPAN

sub _store {
    my ($self) = @_;
    my $file = $self->{file};
    $self->{cache} ||= do {
        open my $fh, $file or die "could not open $file: $!";
        local $/ = "";  # paragraph slurp mode
        my @recs = map eval($_), <$fh>;
        close $fh;
        \@recs;
    };
}

 view release on metacpan or  search on metacpan

lib/Test/MockCommand/ScalarReadline.pm  view on Meta::CPAN

	    $offset += ${$/};
	}
	return @out;
    }

    # paragraph mode: $/ = ''
    my $rs = $/;
    my $paras = 0;
    if ($rs eq '') {
	$rs = "\n\n";
	$paras = 1;

 view release on metacpan or  search on metacpan

lib/Test/MockFile/FileHandle.pm  view on Meta::CPAN

        my $read_len  = $reclen < $remaining ? $reclen : $remaining;
        $self->{'tell'} = $tell + $read_len;
        return substr( $contents, $tell, $read_len );
    }

    # Paragraph mode: $/ = '' — read paragraphs separated by blank lines
    if ( $/ eq '' ) {
        my $pos = $tell;

        # Skip leading newlines
        while ( $pos < $len && substr( $contents, $pos, 1 ) eq "\n" ) {

 view release on metacpan or  search on metacpan

bin/fribidi.pl  view on Meta::CPAN

    $Opts{$_} = 1 foreach (qw(levels dir ltov types hex));
}


# read paragraphs (and make perlcritic happy with 'local')
local $/ = '';
my $flags;
$flags = { break => $Opts{'break'} } if defined $Opts{'break'};
my $dir = $Opts{'rtl'} ? $Text::Bidi::Par::RTL 
                       : $Opts{'ltr'} ? $Text::Bidi::Par::LTR : undef;
while (<>) {

 view release on metacpan or  search on metacpan

lib/Text/Lossy.pm  view on Meta::CPAN

want to buffer the entire input before writing the (only) line to C<stdout>. The
newline at the end will allow downstream processes to work on new lines, too.
Otherwise, this filter is not quite as efficient as the L<whitespace> filter.

Any newlines in the middle of text are collapsed to a space, too. This is especially
useful if you are reading in "paragraph mode", e.g. C<$/ = ''>, as you will get
one long line per former paragraph.

=cut

sub whitespace_nl {

 view release on metacpan or  search on metacpan

t/01_mf.t  view on Meta::CPAN

use strict;
use Test::More tests => 25;
use Text::MessageFormat;

my @Tests = do {
    local $/ = '';
    map {
	my($name, $format, $args, $output) = split /\n/;
	$args = [ grep length, split /\|/, $args ];
	[ $name, $format, $args, $output ];
    } <DATA>;

 view release on metacpan or  search on metacpan

t/class.t  view on Meta::CPAN

# Tests
BEGIN { use_ok('Text::Tabulate'); }

# Load the data.
#$/ = '';	# paragraph mode.
#my @data = split(/\n/, <DATA>);
##ok($#data, 'data loaded');

# Test the routine.

 view release on metacpan or  search on metacpan

t/010_internals/017_render.t  view on Meta::CPAN

}

rmtree(cache_dir);
for(1 .. 2) {
    # must not depend on global variables
    local $/ = '';
    local $\ = "\n";

    my $tx = Text::Xslate->new(
        cache     => 1,
        path      => [path],

 view release on metacpan or  search on metacpan

lib/Tie/File.pm  view on Meta::CPAN

	"e p"
	"ky fli"
	"!\n"

An undefined value is not permitted as a record separator.  Perl's
special "paragraph mode" semantics (E<agrave> la C<$/ = "">) are not
emulated.

Records read from the tied array do not have the record separator
string on the end; this is to allow

 view release on metacpan or  search on metacpan

TwoLevelHash.pm  view on Meta::CPAN

	if (!open($FH,"$slh")) {
		croak "Cannot open $FH $slh: $!";
	}

local $/ = "";

my @records = <$FH>;

# Make sure comments at top of TLH file stay
my $comment;

 view release on metacpan or  search on metacpan

pod/mvfor  view on Meta::CPAN

#!/usr/local/bin/new/perl -w
use strict;

$/ = '';
$^I = '.bak';

my @undo;
my $edits = 0;
my $seen_NAME = 0;

 view release on metacpan or  search on metacpan

drawstate.source  view on Meta::CPAN

=cut

use UML::State;

$/                   = "";   # paragraph mode

my $node_data        = <>;
my $start_states     = <>;
my $accepting_states = <>;

 view release on metacpan or  search on metacpan

t/01decomposeWidth.t  view on Meta::CPAN

no utf8;

use Test::More tests => 1;
use Unicode::Precis::Utils qw(decomposeWidth);

my ($comp, $decomp) = do { local $/ = ''; <DATA> };
1 while chomp ($comp, $decomp);
is(decomposeWidth($comp), $decomp, $decomp);

__END__
　！＂＃＄％＆＇（）＊＋，－．／

 view release on metacpan or  search on metacpan

script/tcgrep  view on Meta::CPAN

    if ($opt{p} || $opt{P}) {
	@patterns = map {"(?m)$_"} @patterns;
    }

    $opt{p}   && ($/ = '');
    $opt{P}   && ($/ = eval(qq("$opt{P}")));     # for -P '%%\n'
    $opt{w}   && (@patterns = map {'\b' . $_ . '\b'} @patterns);
    $opt{'x'} && (@patterns = map {"^$_\$"} @patterns);
    if (@ARGV) {
	$Mult = 1 if ($opt{r} || (@ARGV > 1) || -d $ARGV[0]) && !$opt{h};

 view release on metacpan or  search on metacpan

t/WARC-Record-Logical-Block.t  view on Meta::CPAN

note('*' x 60);

# Verify READLINE (paragraph)
{
  local $/ = '';	# select paragraph mode

  my $xh = make_test_handle
    "abc\ndef\n\n\n\nghi\njkl\n\n", "mno\npqr\nstu\n\nvwx\nyz", "0\n\n123\n456";
  note_handle_state $xh;
  ## paragraph:  within segment

t/WARC-Record-Logical-Block.t  view on Meta::CPAN

# Verify READLINE (mixed modes)
{
  my $xh;
  {
    local $/ = '';	# ensure that handle is usable in paragraph mode
    $xh = make_test_handle "abc\n";
  }
  is(scalar <$xh>, "abc\n",	'read line to eof');
  local $/ = '';	# select paragraph mode
  ok((not defined scalar <$xh>),'read paragraph at eof');

  $/ = \4;		# select record mode
  $xh = make_test_handle '1234';
  is(scalar <$xh>, '1234',	'read record to eof');

 view release on metacpan or  search on metacpan

t/lib/LWP/UserAgent.pm  view on Meta::CPAN

# Mock helpers

sub _load_aliases {
	open my $fh, '<', 't/data/aliases.json' or
		die("Could not open alias file: $!");
	my $blob = do { local $/=''; <$fh> };
	close $fh;
	return decode_json($blob);
}

sub _gen_resp {

 view release on metacpan or  search on metacpan

lib/Win32/Backup/Robocopy.pm  view on Meta::CPAN

	# READ the configuration 
	my $json = JSON::PP->new->utf8->pretty->canonical;
	open my $fh, '<', $file or croak "unable to read $file";
	my $lines;
	{
		local $/ = '';
		$lines = <$fh>;
	}
	close $fh or croak "impossible to close $file";
	my $data;
	{ 

 view release on metacpan or  search on metacpan

t/context-persists.t  view on Meta::CPAN

is($wf0->context->param("name"), "hans", "wf0 context found");

{    # check for hans in persister file
    open(my $x, $file);
    ok($x, "persister file opened");
    local $/ = "";
    like(<$x>, qr/hans/, "found context in persister file");
}

### FETCH $id
my $wf1 = FACTORY->fetch_workflow("FOO", $wf0->id);

 view release on metacpan or  search on metacpan

examples/test1.pl  view on Meta::CPAN

open (TFH, '< ./INV.110.SAMPLE');
binmode(TFH);
my $edi;
while(<TFH>)
{
    $/ = '';
    chomp;
    $edi .= $_;
}
close(TFH);

 view release on metacpan or  search on metacpan

t/element_text.t  view on Meta::CPAN

print "1..2\n";

use XML::Checker::Parser;

$/=''; # records are now separated by an empty line

# first parse, a valid document
my $doc1=<DATA>;
my $p= new XML::Checker::Parser;
eval

 view release on metacpan or  search on metacpan

Lite/XHF.pm  view on Meta::CPAN

		});
}

sub tokenize {
  (my MY $self) = @_;
  local $/ = "";
  my $fh = $$self{cf_FH};
  unless ($self->{fh_configured}++) {
    if (not $self->{cf_bytes} and not $self->{cf_string}
	and $self->{cf_encoding}) {
      binmode $fh, ":encoding($self->{cf_encoding})";

 view release on metacpan or  search on metacpan

scripts/yatt.lib/YATT/XHF.pm  view on Meta::CPAN

  $self;
}

sub read_as_hashlist {
  my MY $reader = shift;
  local $/ = "";
  my $fh = $$reader{cf_FH};
  my @result;
  while (defined (my $paragraph = <$fh>)) {
    @{$$reader{cf_tokens}} = $reader->tokenize($paragraph)
      or next;

scripts/yatt.lib/YATT/XHF.pm  view on Meta::CPAN

sub read_as {
  (my MY $reader, my ($type)) = @_;
  my $sub = $reader->can("organize_as_$type")
    or croak "Unknown read_as type: $type";

  local $/ = "";
  my $fh = $$reader{cf_FH};
  until ($$reader{cf_tokens} && @{$$reader{cf_tokens}}) {
    defined (my $paragraph = <$fh>) or last;
    @{$$reader{cf_tokens}} = $reader->tokenize($paragraph)
  }

 view release on metacpan or  search on metacpan

t/02parse.t  view on Meta::CPAN

$h=iCal::Parser->new(start=>'20040101',tz=>$tz)->parse_files(@cals);
is_deeply($h,$VAR1,"multiple calendars (parse_files)");

my @s=();
{
    local $/='';
    my $i=0;
    foreach my $c (@cals) {
	$VAR1->{cals}[$i]{'X-WR-CALNAME'}='Calendar ' . ($i+1);
	++$i;
	open IN, "<$c" or die "Can't open $c, $!";

 view release on metacpan or  search on metacpan

Mpp/Text.pm  view on Meta::CPAN

  }
  $helpend =~ s/\@BASEVERSION\@/$BASEVERSION/;
  our $opts ||= $pod;
  print "\n";
  open my $fh, '<', "$Mpp::datadir/pod/$opts.pod" or die $!;
  my $opt = $/ = '';
  my $found;
  while( <$fh> ) {		# skip to before 1st opt
    $found = 1 if /Valid options are|^=head1 OPTIONS/;
    last if $found && /^=over/;
  }

 view release on metacpan or  search on metacpan

contrib/ldifsort.pl  view on Meta::CPAN

my $sorthier = $args{h};

die "usage: $0 -k keyattr [-acdhn] ldiffile\n"
	unless $keyattr && $ldiffile;

$/ = "";

open(LDIFH, $ldiffile) || die "$ldiffile: $!\n";

my $pos = 0;
my @valuepos;

 view release on metacpan or  search on metacpan

Porting/sort_perldiag.pl  view on Meta::CPAN

no locale;

my %items;
my $item_key;

$/ = '';

while (<>) {
  if (/^=item\s+(.+)/) {
    # new item

 view release on metacpan or  search on metacpan

Pod/Html.pm  view on Meta::CPAN

        $Htmlfileurl= "$Htmldir/" . substr( $Htmlfile, length( $Htmldir ) + 1);
    }

    # read the pod a paragraph at a time
    warn "Scanning for sections in input file(s)\n" if $Verbose;
    $/ = "";
    my @poddata  = <POD>;
    close(POD);

    # be eol agnostic
    for (@poddata) {

 view release on metacpan or  search on metacpan

benchmarks/app/MyPodHtml.pm  view on Meta::CPAN

        $Htmlfileurl= "$Htmldir/" . substr( $Htmlfile, length( $Htmldir ) + 1);
    }

    # read the pod a paragraph at a time
    warn "Scanning for sections in input file(s)\n" if $Verbose;
    $/ = "";
    my @poddata  = <POD>;
    close(POD);

    # be eol agnostic
    for (@poddata) {