From: Jarkko Hietaniemi <jhi@iki.fi>
Date: Sun, 30 Sep 2001 13:37:59 +0000 (+0000)
Subject: Upgrade to Text-Tabs+Wrap-2001.0929 from David Muir Sharnoff.
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=37a581db7e8c594db4c6ef42b6fe4d8a81fc4ca3;p=p5sagit%2Fp5-mst-13.2.git

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

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

diff --git a/MANIFEST b/MANIFEST
index 5f45512..46a72f3 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1210,6 +1210,7 @@ lib/Text/ParseWords.t		See if Text::ParseWords works
 lib/Text/Soundex.pm		Perl module to implement Soundex
 lib/Text/Soundex.t		See if Soundex works
 lib/Text/Tabs.pm		Do expand and unexpand
+lib/Text/TabsWrap/CHANGELOG	ChangeLog for Tabs+Wrap
 lib/Text/TabsWrap/t/fill.t	See if Text::Wrap::fill works
 lib/Text/TabsWrap/t/tabs.t	See if Text::Tabs works
 lib/Text/TabsWrap/t/wrap.t	See if Text::Wrap::wrap works
diff --git a/lib/Text/TabsWrap/CHANGELOG b/lib/Text/TabsWrap/CHANGELOG
new file mode 100644
index 0000000..7f0720a
--- /dev/null
+++ b/lib/Text/TabsWrap/CHANGELOG
@@ -0,0 +1,74 @@
+= 2001/09/29
+
+Philip Newton <Philip.Newton@gmx.net> sent in a clean patch that
+added support for defining words differently; that prevents 
+Text::Wrap from untainting strings; and that fixes a documentation
+bug.
+
+So that fill.t can be used in the version included in the perl
+distribution, fill.t no longer uses File::Slurp.
+
+Both Sweth Chandramouli <svc@sweth.net> and Drew Degentesh 
+<ddegentesh@daed.com> both objected to the automatic unexpand
+that Text::Wrap does on its results.  Drew sent a patch which
+has been integrated.
+
+Way back in '97, Joel Earl <jrearl@VNET.IBM.COM> asked that
+it be possible to use a line separator other than \n when
+adding new lines.  There is now support for that.
+
+= 2001/01/30
+
+Bugfix by Michael G Schwern <schwern@pobox.com>: don't add extra
+whitespace when working one an array of input (as opposed to a 
+single string).
+
+Performance rewrite: use m/\G/ rather than s///.
+
+You can now specify that words that are too long to wrap can simply
+overflow the line.  Feature requested by James Hoagland 
+<hoagland@SiliconDefense.com> and by John Porter <jdporter@min.net>.
+
+Documentation changes from Rich Bowen <Rich@cre8tivegroup.com>.
+
+= 1998/11/29
+
+Combined Fill.pm into Wrap.pm.  It appears there are versions of
+Wrap.pm with fill in them.
+
+= 1998/11/28
+
+Over the last couple of years, many people sent in various
+rewrites of Text::Wrap.  I should have done something about
+updating it long ago.  If someone wants to take it over from
+me, discuss it in perl-porters.  I'll be happy to hand it
+over.
+
+Anyway, I have a bunch of people to thank.  I didn't
+use what any of them sent in, but I did take ideas from
+all of them.  Many sent in complete new implamentations.
+
+	Ivan Brawley <ibrawley@awadi.com.au> 
+
+	Jacqui Caren <Jacqui.Caren@ig.co.uk>
+
+	Jeff Kowalski <jeff.kowalski@autodesk.com>
+
+	Allen Smith <easmith@beatrice.rutgers.edu>
+
+	Sullivan N. Beck <sbeck@cise.ufl.edu>
+
+The end result is a very slight change in the API.  There
+is now an additional package variable: $Text::Wrap::huge.
+When $huge is set to 'die' then long words will cause 
+wrap() to die.  When it is set to 'wrap', long words will
+be wrapped.  The default is 'wrap'.
+
+<shout>LONG WORDS WILL NOW BE WRAPPED BY DEFAULT</shout>.  
+This is a change in behavior.
+
+At the bottom of Text::Wrap, there was a function (fill())
+sitting there unpublished.  There was a note that Tim Pierce
+had a faster version, but a search on CPAN failed to turn it
+up.  Text::Fill is now available.
+
diff --git a/lib/Text/TabsWrap/t/fill.t b/lib/Text/TabsWrap/t/fill.t
index 5ff3850..3d5b98f 100755
--- a/lib/Text/TabsWrap/t/fill.t
+++ b/lib/Text/TabsWrap/t/fill.t
@@ -75,8 +75,8 @@ while (@tests) {
 		print "ok $tn\n";
 	} elsif ($rerun) {
 		my $oi = $in;
-		open(F,">#o") and do { print F $back; close(F) };
-		open(F,">#e") and do { print F $out;  close(F) };
+ 		write_file("#o", $back);
+ 		write_file("#e", $out);
 		foreach ($in, $back, $out) {
 			s/\t/^I\t/gs;
 			s/\n/\$\n/gs;
@@ -96,3 +96,15 @@ while (@tests) {
 	}
 	$tn++;
 }
+
+sub write_file
+{
+	my ($f, @data) = @_;
+
+	local(*F);
+
+	open(F, ">$f") || die "open >$f: $!";
+	(print F @data) || die "write $f: $!";
+	close(F) || die "close $f: $!";
+	return 1;
+}
diff --git a/lib/Text/Wrap.pm b/lib/Text/Wrap.pm
index 3c88508..8dd1f6c 100644
--- a/lib/Text/Wrap.pm
+++ b/lib/Text/Wrap.pm
@@ -6,9 +6,10 @@ require Exporter;
 @EXPORT = qw(wrap fill);
 @EXPORT_OK = qw($columns $break $huge);
 
-$VERSION = 2001.0131;
+$VERSION = 2001.0929;
 
-use vars qw($VERSION $columns $debug $break $huge);
+use vars qw($VERSION $columns $debug $break $huge $unexpand $tabstop
+	$separator);
 use strict;
 
 BEGIN	{
@@ -16,6 +17,9 @@ BEGIN	{
 	$debug = 0;
 	$break = '\s';
 	$huge = 'wrap'; # alternatively: 'die' or 'overflow'
+	$unexpand = 1;
+	$tabstop = 8;
+	$separator = "\n";
 }
 
 use Text::Tabs qw(expand unexpand);
@@ -24,25 +28,34 @@ sub wrap
 {
 	my ($ip, $xp, @t) = @_;
 
+	local($Text::Tabs::tabstop) = $tabstop;
 	my $r = "";
 	my $tail = pop(@t);
-	my $t = expand(join("", (map { /\s+\Z/ ? ( $_ ) : ($_, ' ') } @t), $tail));
+	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 = "";
 
+	use re 'taint';
+
 	pos($t) = 0;
 	while ($t !~ /\G\s*\Z/gc) {
-		if ($t =~ /\G([^\n]{0,$ll})($break|\Z(?!\n))/xmgc) {
-			$r .= unexpand($nl . $lead . $1);
+		if ($t =~ /\G([^\n]{0,$ll})($break|\z)/xmgc) {
+			$r .= $unexpand 
+				? unexpand($nl . $lead . $1)
+				: $nl . $lead . $1;
 			$remainder = $2;
 		} 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);
+			$r .= $unexpand 
+				? unexpand($nl . $lead . $1)
+				: $nl . $lead . $1;
+			$remainder = $separator;
+		} elsif ($huge eq 'overflow' && $t =~ /\G([^\n]*?)($break|\z)/xmgc) {
+			$r .= $unexpand 
+				? unexpand($nl . $lead . $1)
+				: $nl . $lead . $1;
 			$remainder = $2;
 		} elsif ($huge eq 'die') {
 			die "couldn't wrap '$t'";
@@ -52,7 +65,7 @@ sub wrap
 			
 		$lead = $xp;
 		$ll = $nll;
-		$nl = "\n";
+		$nl = $separator;
 	}
 	$r .= $remainder;
 
@@ -128,21 +141,54 @@ B<Example 3>
 
 =head1 DESCRIPTION
 
-Text::Wrap::wrap() is a very simple paragraph formatter.  It formats a
+C<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.
 
+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 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().
+
+=head1 OVERRIDES
+
+C<Text::Wrap::wrap()> has a number of variables that control its behavior.
+Because other modules might be using C<Text::Wrap::wrap()> it is suggested
+that you leave these variables alone!  If you can't do that, then 
+use C<local($Text::Wrap::VARIABLE) = YOURVALUE> when you change the
+values so that the original value is restored.  This C<local()> trick
+will not work if you import the variable into your own namespace.
+
 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>.  
 
+It is possible to control which characters terminate words by
+modifying C<$Text::Wrap::break>. Set this to a string such as
+C<'[\s:]'> (to break before spaces or colons) or a pre-compiled regexp
+such as C<qr/[\s']/> (to break before spaces or apostrophes). The
+default is simply C<'\s'>; that is, words are terminated by spaces.
+(This means, among other things, that trailing punctuation  such as
+full stops or commas stay with the word they are "attached" to.)
+
 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.
 
+C<Text::Wrap::wrap()> starts its work by expanding all the tabs in its
+input into spaces.  The last thing it does it to turn spaces back
+into tabs.  If you do not want tabs in your results, set 
+C<$Text::Wrap::unexapand> to a false value.  Likewise if you do not
+want to use 8-character tabstops, set C<$Text::Wrap::tabstop> to
+the number of characters you do want for your tabstops.
+
+If you want to separate your lines with something other than C<\n>
+then set C<$Text::Wrap::seporator> to your preference.
+
 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
@@ -150,17 +196,7 @@ This behavior can be overridden by setting C<$huge> to
 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 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
+Historical notes: 'die' used to be the default value of
 C<$huge>.  Now, 'wrap' is the default value.
 
 =head1 EXAMPLE