From: Jarkko Hietaniemi 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 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 and Drew Degentesh + 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 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 : 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 + and by John Porter . + +Documentation changes from Rich Bowen . + += 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 + + Jacqui Caren + + Jeff Kowalski + + Allen Smith + + Sullivan N. Beck + +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'. + +LONG WORDS WILL NOW BE WRAPPED BY DEFAULT. +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 =head1 DESCRIPTION -Text::Wrap::wrap() is a very simple paragraph formatter. It formats a +C 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 has a number of variables that control its behavior. +Because other modules might be using C it is suggested +that you leave these variables alone! If you can't do that, then +use C when you change the +values so that the original value is restored. This C 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 (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 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 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 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 will return a list of lines and -C will return a list of paragraphs. - -Historical notes: Older versions of C and C 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