From: Jarkko Hietaniemi <jhi@iki.fi>
Date: Fri, 9 Feb 2001 22:29:20 +0000 (+0000)
Subject: Upgrade to Text-Tabs+Wrap-2001.0131 from David Muir Sharnoff.
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=3e2ea5df34c9b3a155c0705666fa94933c5227e2;p=p5sagit%2Fp5-mst-13.2.git

Upgrade to Text-Tabs+Wrap-2001.0131 from David Muir Sharnoff.

Didn't upgrade the fill.t since it has a dependency to File::Slurp
purely for debugging purposes, the actual test hasn't changed.

p4raw-id: //depot/perl@8754
---

diff --git a/lib/Text/Tabs.pm b/lib/Text/Tabs.pm
index 933f917..c431019 100644
--- a/lib/Text/Tabs.pm
+++ b/lib/Text/Tabs.pm
@@ -73,11 +73,11 @@ Text::Tabs -- expand and unexpand tabs per the unix expand(1) and unexpand(1)
 
 =head1 SYNOPSIS
 
-    use Text::Tabs;
+use Text::Tabs;
 
-    $tabstop = 4;
-    @lines_without_tabs = expand(@lines_with_tabs);
-    @lines_with_tabs = unexpand(@lines_without_tabs);
+$tabstop = 4;
+@lines_without_tabs = expand(@lines_with_tabs);
+@lines_with_tabs = unexpand(@lines_without_tabs);
 
 =head1 DESCRIPTION
 
diff --git a/lib/Text/Wrap.pm b/lib/Text/Wrap.pm
index 04efe19..579e09b 100644
--- a/lib/Text/Wrap.pm
+++ b/lib/Text/Wrap.pm
@@ -6,7 +6,7 @@ require Exporter;
 @EXPORT = qw(wrap fill);
 @EXPORT_OK = qw($columns $break $huge);
 
-$VERSION = 2000.06292219; #GMT
+$VERSION = 2001.0131;
 
 use vars qw($VERSION $columns $debug $break $huge);
 use strict;
@@ -15,7 +15,7 @@ BEGIN	{
 	$columns = 76;  # <= screen width
 	$debug = 0;
 	$break = '\s';
-	$huge = 'wrap'; # alternatively: 'die'
+	$huge = 'wrap'; # alternatively: 'die' or 'overflow'
 }
 
 use Text::Tabs qw(expand unexpand);
@@ -25,20 +25,25 @@ sub wrap
 	my ($ip, $xp, @t) = @_;
 
 	my $r = "";
-	my $t = expand(join(" ",@t));
+	my $tail = pop(@t);
+	my $t = expand(join("", (map { /\s+\Z/ ? ( $_ ) : ($_, ' ') } @t), $tail));
 	my $lead = $ip;
 	my $ll = $columns - length(expand($ip)) - 1;
 	my $nll = $columns - length(expand($xp)) - 1;
 	my $nl = "";
 	my $remainder = "";
 
-	while ($t !~ /^\s*$/) {
-		if ($t =~ s/^([^\n]{0,$ll})($break|\Z(?!\n))//x) {
+	pos($t) = 0;
+	while ($t !~ /\G\s*\Z/gc) {
+		if ($t =~ /\G([^\n]{0,$ll})($break|\Z(?!\n))/xmgc) {
 			$r .= unexpand($nl . $lead . $1);
 			$remainder = $2;
-		} elsif ($huge eq 'wrap' && $t =~ s/^([^\n]{$ll})//) {
+		} elsif ($huge eq 'wrap' && $t =~ /\G([^\n]{$ll})/gc) {
 			$r .= unexpand($nl . $lead . $1);
 			$remainder = "\n";
+		} elsif ($huge eq 'overflow' && $t =~ /\G([^\n]*?)($break|\Z(?!\n))/xmgc) {
+			$r .= unexpand($nl . $lead . $1);
+			$remainder = $2;
 		} elsif ($huge eq 'die') {
 			die "couldn't wrap '$t'";
 		} else {
@@ -53,11 +58,13 @@ sub wrap
 
 	print "-----------$r---------\n" if $debug;
 
-	print "Finish up with '$lead', '$t'\n" if $debug;
+	print "Finish up with '$lead'\n" if $debug;
 
-	$r .= $lead . $t if $t ne "";
+	$r .= $lead . substr($t, pos($t), length($t)-pos($t))
+		if pos($t) ne length($t);
 
 	print "-----------$r---------\n" if $debug;;
+
 	return $r;
 }
 
@@ -76,7 +83,8 @@ sub fill
 	# if paragraph_indent is the same as line_indent, 
 	# separate paragraphs with blank lines
 
-	return join ($ip eq $xp ? "\n\n" : "\n", @para);
+	my $ps = ($ip eq $xp) ? "\n\n" : "\n";
+	return join ($ps, @para);
 }
 
 1;
@@ -88,38 +96,73 @@ Text::Wrap - line wrapping to form simple paragraphs
 
 =head1 SYNOPSIS 
 
+B<Example 1>
+
 	use Text::Wrap
 
+	$initial_tab = "\t";	# Tab before first line
+	$subsequent_tab = "";	# All other lines flush left
+
 	print wrap($initial_tab, $subsequent_tab, @text);
 	print fill($initial_tab, $subsequent_tab, @text);
 
+	@lines = wrap($initial_tab, $subsequent_tab, @text);
+
+	@paragraphs = fill($initial_tab, $subsequent_tab, @text);
+
+B<Example 2>
+
 	use Text::Wrap qw(wrap $columns $huge);
 
-	$columns = 132;
+	$columns = 132;		# Wrap at 132 characters
 	$huge = 'die';
 	$huge = 'wrap';
+	$huge = 'overflow';
 
-=head1 DESCRIPTION
+B<Example 3>
+	
+	use Text::Wrap
 
-Text::Wrap::wrap() is a very simple paragraph formatter.  It formats a
-single paragraph at a time by breaking lines at word boundaries.
-Indentation is controlled for the first line ($initial_tab) and
-all subsequent lines ($subsequent_tab) independently.  
+	$Text::Wrap::columns = 72;
+	print wrap('', '', @text);
 
-Lines are wrapped at $Text::Wrap::columns columns.  
-$Text::Wrap::columns should be set to the full width of your output device.
+=head1 DESCRIPTION
 
-When words that are longer than $columns are encountered, they
-are broken up.  Previous versions of wrap() die()ed instead.
-To restore the old (dying) behavior, set $Text::Wrap::huge to
-'die'.
+Text::Wrap::wrap() is a very simple paragraph formatter.  It formats a
+single paragraph at a time by breaking lines at word boundries.
+Indentation is controlled for the first line (C<$initial_tab>) and
+all subsquent lines (C<$subsequent_tab>) independently.  Please note: 
+C<$initial_tab> and C<$subsequent_tab> are the literal strings that will
+be used: it is unlikley you would want to pass in a number.
+
+Lines are wrapped at C<$Text::Wrap::columns> columns.  C<$Text::Wrap::columns>
+should be set to the full width of your output device.  In fact,
+every resulting line will have length of no more than C<$columns - 1>.  
+
+Beginner note: In example 2, above C<$columns> is imported into
+the local namespace, and set locally.  In example 3,
+C<$Text::Wrap::columns> is set in its own namespace without importing it.
+
+When words that are longer than C<$columns> are encountered, they
+are broken up.  C<wrap()> adds a C<"\n"> at column C<$columns>.
+This behavior can be overridden by setting C<$huge> to
+'die' or to 'overflow'.  When set to 'die', large words will cause
+C<die()> to be called.  When set to 'overflow', large words will be
+left intact.  
 
 Text::Wrap::fill() is a simple multi-paragraph formatter.  It formats
 each paragraph separately and then joins them together when it's done.  It
-will destroy any whitespace in the original text.  It breaks text into
+will destory any whitespace in the original text.  It breaks text into
 paragraphs by looking for whitespace after a newline.  In other respects
 it acts like wrap().
 
+When called in list context, C<wrap()> will return a list of lines and 
+C<fill()> will return a list of paragraphs.
+
+Historical notes: Older versions of C<wrap()> and C<fill()> always 
+returned strings.  Also, 'die' used to be the default value of
+C<$huge>.  Now, 'wrap' is the default value.
+
 =head1 EXAMPLE
 
 	print wrap("\t","","This is a bit of text that forms 
diff --git a/t/lib/texttabs.t b/t/lib/texttabs.t
index ea9012c..132625d 100755
--- a/t/lib/texttabs.t
+++ b/t/lib/texttabs.t
@@ -1,28 +1,141 @@
-#!./perl
+#!/usr/old/bin/perl5.004_01 -w
 
 BEGIN {
     chdir 't' if -d 't';
     @INC = '../lib';
 }
 
-print "1..3\n";
+@tests = (split(/\nEND\n/s, <<DONE));
+TEST 1 u
+                x
+END
+		x
+END
+TEST 2 e
+		x
+END
+                x
+END
+TEST 3 e
+	x
+		y
+			z
+END
+        x
+                y
+                        z
+END
+TEST 4 u
+        x
+                y
+                        z
+END
+	x
+		y
+			z
+END
+TEST 5 u
+This    Is      a       test    of      a       line with many embedded tabs
+END
+This	Is	a	test	of	a	line with many embedded tabs
+END
+TEST 6 e
+This	Is	a	test	of	a	line with many embedded tabs
+END
+This    Is      a       test    of      a       line with many embedded tabs
+END
+TEST 7 u
+            x
+END
+	    x
+END
+TEST 8 e
+	
+		
+   	
 
-use Text::Tabs;
+           
+END
+        
+                
+        
+
+           
+END
+TEST 9 u
+           
+END
+	   
+END
+TEST 10 u
+	
+		
+   	
+
+           
+END
+	
+		
+	
+
+	   
+END
+TEST 11 u
+foobar                  IN	A		140.174.82.12
+
+END
+foobar			IN	A		140.174.82.12
 
-$tabstop = 4;
+END
+DONE
 
-$s1 = "foo\tbar\tb\tb";
-$s2 = expand $s1;
-$s3 = unexpand $s2;
+$| = 1;
 
-print "not " unless $s2 eq "foo bar b   b";
-print "ok 1\n";
+print "1..";
+print @tests/2;
+print "\n";
 
-print "not " unless $s3 eq "foo bar b\tb";
-print "ok 2\n";
+use Text::Tabs;
+
+$rerun = $ENV{'PERL_DL_NONLAZY'} ? 0 : 1;
+
+$tn = 1;
+while (@tests) {
+	my $in = shift(@tests);
+	my $out = shift(@tests);
 
+	$in =~ s/^TEST\s*(\d+)?\s*(\S+)?\n//;
 
-$tabstop = 8;
+	if ($2 eq 'e') {
+		$f = \&expand;
+		$fn = 'expand';
+	} else {
+		$f = \&unexpand;
+		$fn = 'unexpand';
+	}
 
-print "not " unless unexpand("                    foo") eq "\t\t    foo";
-print "ok 3\n";
+	my $back = &$f($in);
+
+	if ($back eq $out) {
+		print "ok $tn\n";
+	} elsif ($rerun) {
+		my $oi = $in;
+		foreach ($in, $back, $out) {
+			s/\t/^I\t/gs;
+			s/\n/\$\n/gs;
+		}
+		print "------------ input ------------\n";
+		print $in;
+		print "\$\n------------ $fn -----------\n";
+		print $back;
+		print "\$\n------------ expected ---------\n";
+		print $out;
+		print "\$\n-------------------------------\n";
+		$Text::Tabs::debug = 1;
+		my $back = &$f($in);
+		exit(1);
+	} else {
+		print "not ok $tn\n";
+	}
+	$tn++;
+}
diff --git a/t/lib/textwrap.t b/t/lib/textwrap.t
index af24036..fee6ce0 100755
--- a/t/lib/textwrap.t
+++ b/t/lib/textwrap.t
@@ -4,7 +4,6 @@ BEGIN {
     chdir 't' if -d 't';
     @INC = '../lib';
 }
-use Text::Wrap qw(&wrap);
 
 @tests = (split(/\nEND\n/s, <<DONE));
 TEST1
@@ -84,21 +83,57 @@ END
  a123456789b123456789c123456789d123456789e123456789f123456789g123456789g123
  4567
 END
+TEST10
+my mother once said
+"never eat paste my darling"
+would that I heeded
+END
+   my mother once said
+ "never eat paste my darling"
+ would that I heeded
+END
+TEST11
+This_is_a_word_that_is_too_long_to_wrap_we_want_to_make_sure_that_the_program_does_not_crash_and_burn
+END
+   This_is_a_word_that_is_too_long_to_wrap_we_want_to_make_sure_that_the_pr
+ ogram_does_not_crash_and_burn
+END
+TEST12
+This
+
+Has
+
+Blank
+
+Lines
+
+END
+   This
+ 
+ Has
+ 
+ Blank
+ 
+ Lines
+
+END
 DONE
 
 
 $| = 1;
 
-print "1..", @tests/2, "\n";
+print "1..", 1 +@tests, "\n";
 
 use Text::Wrap;
 
 $rerun = $ENV{'PERL_DL_NONLAZY'} ? 0 : 1;
 
 $tn = 1;
-while (@tests) {
-	my $in = shift(@tests);
-	my $out = shift(@tests);
+
+@st = @tests;
+while (@st) {
+	my $in = shift(@st);
+	my $out = shift(@st);
 
 	$in =~ s/^TEST(\d+)?\n//;
 
@@ -126,4 +161,49 @@ while (@tests) {
 		print "not ok $tn\n";
 	}
 	$tn++;
+
+}
+
+@st = @tests;
+while(@st) {
+	my $in = shift(@st);
+	my $out = shift(@st);
+
+	$in =~ s/^TEST(\d+)?\n//;
+
+	my @in = split("\n", $in, -1);
+	@in = ((map { "$_\n" } @in[0..$#in-1]), $in[-1]);
+	
+	my $back = wrap('   ', ' ', @in);
+
+	if ($back eq $out) {
+		print "ok $tn\n";
+	} elsif ($rerun) {
+		my $oi = $in;
+		foreach ($in, $back, $out) {
+			s/\t/^I\t/gs;
+			s/\n/\$\n/gs;
+		}
+		print "------------ input2 ------------\n";
+		print $in;
+		print "\n------------ output2 -----------\n";
+		print $back;
+		print "\n------------ expected2 ---------\n";
+		print $out;
+		print "\n-------------------------------\n";
+		$Text::Wrap::debug = 1;
+		wrap('   ', ' ', $oi);
+		exit(1);
+	} else {
+		print "not ok $tn\n";
+	}
+	$tn++;
 }
+
+$Text::Wrap::huge = 'overflow';
+
+my $tw = 'This_is_a_word_that_is_too_long_to_wrap_we_want_to_make_sure_that_the_program_does_not_crash_and_burn';
+my $w = wrap('zzz','yyy',$tw);
+print (($w eq "zzz$tw") ? "ok $tn\n" : "not ok $tn");
+$tn++;
+