@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;
$columns = 76; # <= screen width
$debug = 0;
$break = '\s';
- $huge = 'wrap'; # alternatively: 'die'
+ $huge = 'wrap'; # alternatively: 'die' or 'overflow'
}
use Text::Tabs qw(expand unexpand);
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 {
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;
}
# 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;
=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>
-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.
+ use Text::Wrap
+
+ $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
projects / p5sagit/p5-mst-13.2.git / blobdiff