1Text::Table(3pm)      User Contributed Perl Documentation     Text::Table(3pm)
2
3
4

NAME

6       Text::Table - Organize Data in Tables
7

VERSION

9       version 1.135
10

SYNOPSIS

12           use Text::Table;
13           my $tb = Text::Table->new(
14               "Planet", "Radius\nkm", "Density\ng/cm^3"
15           );
16           $tb->load(
17               [ "Mercury", 2360, 3.7 ],
18               [ "Venus", 6110, 5.1 ],
19               [ "Earth", 6378, 5.52 ],
20               [ "Jupiter", 71030, 1.3 ],
21           );
22           print $tb;
23
24       This prints a table from the given title and data like this:
25
26         Planet  Radius Density
27                 km     g/cm^3
28         Mercury  2360  3.7
29         Venus    6110  5.1
30         Earth    6378  5.52
31         Jupiter 71030  1.3
32
33       Note that two-line titles work, and that the planet names are aligned
34       differently than the numbers.
35

DESCRIPTION

37       Organization of data in table form is a time-honored and useful method
38       of data representation.  While columns of data are trivially generated
39       by computer through formatted output, even simple tasks like keeping
40       titles aligned with the data columns are not trivial, and the one-shot
41       solutions one comes up with tend to be particularly hard to maintain.
42       Text::Table allows you to create and maintain tables that adapt to
43       alignment requirements as you use them.
44
45   Overview
46       The process is simple: you create a table (a Text::Table object) by
47       describing the columns the table is going to have.  Then you load lines
48       of data into the table, and finally print the resulting output lines.
49       Alignment of data and column titles is handled dynamically in
50       dependence on the data present.
51
52   Table Creation
53       In the simplest case, if all you want is a number of (untitled)
54       columns, you create an unspecified table and start adding data to it.
55       The number of columns is taken from the first line of data.
56
57       To specify a table you specify its columns.  A column description can
58       contain a title and alignment requirements for the data, both optional.
59       Additionally, you can specify how the title is aligned with the body of
60       a column, and how the lines of a multiline title are aligned among
61       themselves.
62
63       The columns are collected in the table in the order they are given.  On
64       data entry, each column corresponds to one data item, and in column
65       selection columns are indexed left to right, starting from 0.
66
67       Each title can be a multiline string which will be blank-filled to the
68       length of the longest partial line.  The largest number of title lines
69       in a column determines how many title lines the table has as a whole,
70       including the case that no column has any titles.
71
72       On output, columns are separated by a single blank.  You can control
73       what goes between columns by specifying separators between (or before,
74       or after) columns.  Separators don't contain any data and don't count
75       in column indexing.  They also don't accumulate: in a sequence of only
76       separators and no columns, only the last one counts.
77
78   Status Information
79       The width (in characters), height (in lines), number of columns, and
80       similar data about the table is available.
81
82   Data Loading
83       Table data is entered line-wise, each time specifying data entries for
84       all table columns.  A bulk loader for many lines at once is also
85       available.  You can clear the data from the table for re-use (though
86       you will more likely just create another table).
87
88       Data can contain colorizing escape sequences (as provided by
89       "Term::AnsiColor") without upsetting the alignment.
90
91   Table Output
92       The output area of a table is divided in the title and the body.
93
94       The title contains the combined titles from the table columns, if any.
95       Its content never changes with a given table, but it may be spread out
96       differently on the page through alignment with the data.
97
98       The body contains the data lines, aligned column-wise as specified, and
99       left-aligned with the column title.
100
101       Each of these is arranged like a Perl array (counting from 0) and can
102       be accessed in portions by specifying a first line and the number of
103       following lines.  Also like an array, giving a negative first line
104       counts from the end of the area.  The whole table, the title followed
105       by the body, can also be accessed in this manner.
106
107       The subdivisions are there so you can repeat the title (or parts of it)
108       along with parts of the body on output, whether for screen paging or
109       printout.
110
111       A rule line is also available, which is the horizontal counterpart to
112       the separator columns you specify with the table.  It is basically a
113       table line as it would appear if all data entries in the line were
114       empty, that is, a blank line except for where the column separators
115       have non-blank entries.  If you print it between data lines, it will
116       not disrupt the vertical separator structure as a plain blank line
117       would.  You can also request a solid rule consisting of any character,
118       and even one with the non-blank column separators replaced by a
119       character of your choice.  This way you can get the popular
120       representation of line-crossings like so:
121
122             |
123         ----+---
124             |
125
126   Warning Control
127       On table creation, some parameters are checked and warnings issued if
128       you allow warnings.  You can also turn warnings into fatal errors.
129

VERSION

131       version 1.135
132

SPECIFICATIONS

134   Column Specification
135       Each column specification is a single scalar.  Columns can be either
136       proper data columns or column separators.  Both can be specified either
137       as (possibly multi-line) strings, or in a more explicit form as hash-
138       refs.  In the string form, proper columns are given as plain strings,
139       and separators are given as scalar references to strings.  In hash
140       form, separators have a true value in the field "is_sep" while proper
141       columns don't have this field.
142
143       Columns as strings
144           A column is given as a column title (any number of lines),
145           optionally followed by alignment requirements.  Alignment
146           requirements start with a line that begins with an ampersand "&".
147           However, only the last such line counts as such, so if you have
148           title lines that begin with "&", just append an ampersand on a line
149           by itself as a dummy alignment section if you don't have one
150           anyway.
151
152           What follows the ampersand on its line is the alignment style (like
153           left, right, ... as described in "Alignment"), you want for the
154           data in this column.  If nothing follows, the general default auto
155           is used.  If you specify an invalid alignment style, it falls back
156           to left alignment.
157
158           The lines that follow can contain sample data for this column.
159           These are considered for alignment in the column, but never
160           actually appear in the output.  The effect is to guarantee a
161           minimum width for the column even if the current data doesn't
162           require it.  This helps dampen the oscillations in the appearance
163           of dynamically aligned tables.
164
165       Columns as Hashes
166           The format is
167
168               {
169                   title   => $title,
170                   align   => $align,
171                   sample  => $sample,
172                   align_title => $align_title,
173                   align_title_lines => $align_title_lines,
174               }
175
176           $title contains the title lines and $sample the sample data.  Both
177           can be given as a string or as an array-ref to the list of lines.
178           $align contains the alignment style (without a leading ampersand),
179           usually as a string.  You can also give a regular expression here,
180           which specifies regex alignment.  A regex can only be specified in
181           the hash form of a column specification.
182
183           In hash form you can also specify how the title of a column is
184           aligned with its body.  To do this, you specify the keyword
185           "align_title" with "left", "right" or "center".  Other alignment
186           specifications are not valid here.  The default is "left".
187
188           "align_title" also specifies how the lines of a multiline title are
189           aligned among themselves.  If you want a different alignment, you
190           can specify it with the key "align_title_lines".  Again, only
191           "left", "right" or "center" are allowed.
192
193           Do not put other keys than those mentioned above (title, align,
194           align_title, align_title_lines, and sample) into a hash that
195           specifies a column.  Most would be ignored, but some would confuse
196           the interpreter (in particular, is_sep has to be avoided).
197
198       Separators as strings
199           A separator must be given as a reference to a string (often a
200           literal, like "\' | '"), any string that is given directly
201           describes a column.
202
203           It is usually just a (short) string that will be printed between
204           table columns on all table lines instead of the default single
205           blank.  If you specify two separators (on two lines), the first one
206           will be used in the title and the other in the body of the table.
207
208       Separators as Hashes
209           The hash representation of a separator has the format
210
211               {
212                   is_sep => 1,
213                   title  => $title,
214                   body   => $body,
215               }
216
217           $title is the separator to be used in the title area and $body the
218           one for the body.  If only one is given, it will be used for both.
219           If none is given, a blank is used.  If one is shorter than the
220           other, it is blank filled on the right.
221
222           The value of "is_sep" must be set to a true value, this is the
223           distinguishing feature of a separator.
224
225   Alignment
226       The original documentation to Text::Aligner contains all the details on
227       alignment specification, but here is the rundown:
228
229       The possible alignment specifications are left, right, center, num and
230       point (which are synonyms), and auto.  The first three explain
231       themselves.
232
233       num (and point) align the decimal point in the data, which is assumed
234       to the right if none is present.  Strings that aren't numbers are
235       treated the same way, that is, they appear aligned with the integers
236       unless they contain a ".".  Instead of the decimal point ".", you can
237       also specify any other string in the form num(,), for instance.  The
238       string in parentheses is aligned in the data.  The synonym point for
239       num may be more appropriate in contexts that deal with arbitrary
240       strings, as in point(=>) (which might be used to align certain bits of
241       Perl code).
242
243       regex alignment is a more sophisticated form of point alignment.  If
244       you specify a regular expression, as delivered by "qr//", the start of
245       the match is used as the alignment point.  If the regex contains
246       capturing parentheses, the last submatch counts.  [The usefulness of
247       this feature is under consideration.]
248
249       auto alignment combines numeric alignment with left alignment.  Data
250       items that look like numbers, and those that don't, form two virtual
251       columns and are aligned accordingly: "num" for numbers and "left" for
252       other strings.  These columns are left-aligned with each other (i.e.
253       the narrower one is blank-filled) to form the final alignment.
254
255       This way, a column that happens to have only numbers in the data gets
256       num alignment, a column with no numbers appears left-aligned, and mixed
257       data is presented in a reasonable way.
258
259   Column Selection
260       Besides creating tables from scratch, they can be created by selecting
261       columns from an existing table.  Tables created this way contain the
262       data from the columns they were built from.
263
264       This is done by specifying the columns to select by their index (where
265       negative indices count backward from the last column).  The same column
266       can be selected more than once and the sequence of columns can be
267       arbitrarily changed.  Separators don't travel with columns, but can be
268       specified between the columns at selection time.
269
270       You can make the selection of one or more columns dependent on the data
271       content of one of them.  If you specify some of the columns in angle
272       brackets [...], the whole group is only included in the selection if
273       the first column in the group contains any data that evaluates to
274       boolean true.  That way you can de-select parts of a table if it
275       contains no interesting data.  Any column separators given in brackets
276       are selected or deselected along with the rest of it.
277

PUBLIC METHODS

279   Table Creation
280       new()
281               my $tb = Text::Table->new( $column, ... );
282
283           creates a table with the columns specified.  A column can be proper
284           column which contains and displays data, or a separator which tells
285           how to fill the space between columns.  The format of the
286           parameters is described under "Column Specification". Specifying an
287           invalid alignment for a column results in a warning if these are
288           allowed.
289
290           If no columns are specified, the number of columns is taken from
291           the first line of data added to the table.  The effect is as if you
292           had specified "Text::Table->new( ( '') x $n)", where $n is the
293           number of columns.
294
295       select()
296               my $sub = $tb->select( $column, ...);
297
298           creates a table from the listed columns of the table $tb, including
299           the data.  Columns are specified as integer indices which refer to
300           the data columns of $tb.  Columns can be repeated and specified in
301           any order.  Negative indices count from the last column.  If an
302           invalid index is specified, a warning is issued, if allowed.
303
304           As with "new()", separators can be interspersed among the column
305           indices and will be used between the columns of the new table.
306
307           If you enclose some of the arguments (column indices or separators)
308           in angle brackets "[...]" (technically, you specify them inside an
309           arrayref), they form a group for conditional selection.  The group
310           is only included in the resulting table if the first actual column
311           inside the group contains any data that evaluate to a boolean true.
312           This way you can exclude groups of columns that wouldn't contribute
313           anything interesting.  Note that separators are selected and de-
314           selected with their group.  That way, more than one separator can
315           appear between adjacent columns.  They don't add up, but only the
316           rightmost separator is used.  A group that contains only separators
317           is never selected.  [Another feature whose usefulness is under
318           consideration.]
319
320   Status Information
321       n_cols()
322               $tb->n_cols
323
324           returns the number of columns in the table.
325
326       width()
327               $tb->width
328
329           returns the width (in characters) of the table.  All table lines
330           have this length (not counting a final "\n" in the line), as well
331           as the separator lines returned by $tb->rule() and $b->body_rule().
332           The width of a table can potentially be influenced by any data item
333           in it.
334
335       height()
336               $tb->height
337
338           returns the total number of lines in a table, including title lines
339           and body lines. For orthogonality, the synonym table_height() also
340           exists.
341
342       table_height()
343           Same as "$table->height()".
344
345       title_height()
346               $tb->title_height
347
348           returns the number of title lines in a table.
349
350       body_height()
351               $tb->body_height
352
353           returns the number of lines in the table body.
354
355       colrange()
356               $tb->colrange( $i)
357
358           returns the start position and width of the $i-th column (counting
359           from 0) of the table.  If $i is negative, counts from the end of
360           the table.  If $i is larger than the greatest column index, an
361           imaginary column of width 0 is assumed right of the table.
362
363   Data Loading
364       add()
365               $tb->add( $col1, ..., $colN)
366
367           adds a data line to the table, returns the table.
368
369           $col1, ..., $colN are scalars that correspond to the table columns.
370           Undefined entries are converted to '', and extra data beyond the
371           number of table columns is ignored.
372
373           Data entries can be multi-line strings.  The partial strings all go
374           into the same column.  The corresponding fields of other columns
375           remain empty unless there is another multi-line entry in that
376           column that fills the fields.  Adding a line with multi-line
377           entries is equivalent to adding multiple lines.
378
379           Every call to add() increases the body height of the table by the
380           number of effective lines, one in the absence of multiline entries.
381
382       load()
383               $tb->load( $line, ...)
384
385           loads the data lines given into the table, returns the table.
386
387           Every argument to load() represents a data line to be added to the
388           table.  The line can be given as an array(ref) containing the data
389           items, or as a string, which is split on whitespace to retrieve the
390           data.  If an undefined argument is given, it is treated as an empty
391           line.
392
393       clear()
394               $tb->clear;
395
396           deletes all data from the table and resets it to the state after
397           creation.  Returns the table.  The body height of a table is 0
398           after clear().
399
400   Table Output
401       The three methods table(), title(), and body() are very similar.  They
402       access different parts of the printable output lines of a table with
403       similar methods.  The details are described with the table() method.
404
405       table()
406           The table() method returns lines from the entire table, starting
407           with the first title line and ending with the last body line.
408
409           In array context, the lines are returned separately, in scalar
410           context they are joined together in a single string.
411
412               my @lines = $tb->table;
413               my $line  = $tb->table( $line_number);
414               my @lines = $tb->table( $line_number, $n);
415
416           The first call returns all the lines in the table.  The second call
417           returns one line given by $line_number.  The third call returns $n
418           lines, starting with $line_number.  If $line_number is negative, it
419           counts from the end of the array.  Unlike the select() method,
420           table() (and its sister methods title() and body()) is protected
421           against large negative line numbers, it truncates the range
422           described by $line_number and $n to the existing lines.  If $n is 0
423           or negative, no lines are returned (an empty string in scalar
424           context).
425
426       stringify()
427           Returns a string representation of the table. This method is called
428           for stringification by overload.
429
430               my @table_strings = map { $_->stringify() } @tables;
431
432       title()
433           Returns lines from the title area of a table, where the column
434           titles are rendered.  Parameters and response to context are as
435           with table(), but no lines are returned from outside the title
436           area.
437
438       body()
439           Returns lines from the body area of a table, that is the part where
440           the data content is rendered, so that $tb->body( 0) is the first
441           data line.  Parameters and response to context are as with table().
442
443       rule()
444               $tb->rule;
445               $tb->rule( $char);
446               $tb->rule( $char, $char1);
447               $tb->rule( sub { my ($index, $len) = @_; },
448                          sub { my ($index, $len) = @_; },
449               );
450
451           Returns a rule for the table.
452
453           A rule is a line of table width that can be used between table
454           lines to provide visual horizontal divisions, much like column
455           separators provide vertical visual divisions.  In its basic form
456           (returned by the first call) it looks like a table line with no
457           data, hence a blank line except for the non-blank parts of any
458           column-separators.  If one character is specified (the second
459           call), it replaces the blanks in the first form, but non-blank
460           column separators are retained.  If a second character is
461           specified, it replaces the non-blank parts of the separators.  So
462           specifying the same character twice gives a solid line of table
463           width.  Another useful combo is "$tb->rule( '-', '+')", together
464           with separators that contain a single nonblank "|", for a popular
465           representation of line crossings.
466
467           rule() uses the column separators for the title section if there is
468           a difference.
469
470           If callbacks are specified instead of the characters, then they
471           receive the index of the section of the rule they need to render
472           and its desired length in characters, and should return the string
473           to put there. The indexes given are 0 based (where 0 is either the
474           left column separator or the leftmost cell) and the strings will be
475           trimmed or extended in the replacement.
476
477       body_rule()
478           body_rule() works like <rule()>, except the rule is generated using
479           the column separators for the table body.
480
481   Warning Control
482       warnings()
483               Text::Table->warnings();
484               Text::Table->warnings( 'on');
485               Text::Table->warnings( 'off'):
486               Text::Table->warnings( 'fatal'):
487
488           The warnings() method is used to control the appearance of warning
489           messages while tables are manipulated.  When Text::Table starts,
490           warnings are disabled.  The default action of warnings() is to turn
491           warnings on.  The other possible arguments are self-explanatory.
492           warnings() can also be called as an object method ("$tb->warnings(
493           ...)").
494

VERSION

496       This document pertains to Text::Table version 1.127
497

BUGS

499       o   auto alignment doesn't support alternative characters for the
500           decimal point.  This is actually a bug in the underlying
501           Text::Aligner by the same author.
502

AUTHOR

504   MAINTAINER
505       Shlomi Fish, <http://www.shlomifish.org/> - CPAN ID: "SHLOMIF".
506
507   ORIGINAL AUTHOR
508           Anno Siegel
509           CPAN ID: ANNO
510           siegel@zrz.tu-berlin.de
511           http://www.tu-berlin.de/~siegel
512
514       Copyright (c) 2002 Anno Siegel. All rights reserved.  This program is
515       free software; you can redistribute it and/or modify it under the terms
516       of the ISC license.
517
518       (This program had been licensed under the same terms as Perl itself up
519       to version 1.118 released on 2011, and was relicensed by permission of
520       its originator).
521
522       The full text of the license can be found in the LICENSE file included
523       with this module.
524

SEE ALSO

526       Text::Table::Tiny supports a simple model for generating text tables,
527       with some flexibility on the look of the table.
528
529       Text::Table::Manifold provides a much richer interface for defining
530       tables. The SEE ALSO section of its documentation lists a lot more
531       table modules on CPAN.
532
533       Text::Aligner can be used to align text on a line-by-line basis.
534

EXAMPLES

536   center align and Unicode output
537           #!/usr/bin/perl
538
539           use strict;
540           use warnings;
541           use utf8;
542
543           use Text::Table ();
544
545           binmode STDOUT, ':encoding(utf8)';
546
547           my @cols = qw/First Last/;
548           push @cols,
549               +{
550               title => "Country",
551               align => "center",
552               };
553           my $sep = \'│';
554
555           my $major_sep = \'║';
556           my $tb        = Text::Table->new( $sep, " Number ", $major_sep,
557               ( map { +( ( ref($_) ? $_ : " $_ " ), $sep ) } @cols ) );
558
559           my $num_cols = @cols;
560
561           $tb->load( [ 1, "Mark",    "Twain",   "USA", ] );
562           $tb->load( [ 2, "Charles", "Dickens", "Great Britain", ] );
563           $tb->load( [ 3, "Jules",   "Verne",   "France", ] );
564
565           my $make_rule = sub {
566               my ($args) = @_;
567
568               my $left      = $args->{left};
569               my $right     = $args->{right};
570               my $main_left = $args->{main_left};
571               my $middle    = $args->{middle};
572
573               return $tb->rule(
574                   sub {
575                       my ( $index, $len ) = @_;
576
577                       return ( '─' x $len );
578                   },
579                   sub {
580                       my ( $index, $len ) = @_;
581
582                       my $char = (
583                             ( $index == 0 )             ? $left
584                           : ( $index == 1 )             ? $main_left
585                           : ( $index == $num_cols + 1 ) ? $right
586                           :                               $middle
587                       );
588
589                       return $char x $len;
590                   },
591               );
592           };
593
594           my $start_rule = $make_rule->(
595               {
596                   left      => '┌',
597                   main_left => '╥',
598                   right     => '┐',
599                   middle    => '┬',
600               }
601           );
602
603           my $mid_rule = $make_rule->(
604               {
605                   left      => '├',
606                   main_left => '╫',
607                   right     => '┤',
608                   middle    => '┼',
609               }
610           );
611
612           my $end_rule = $make_rule->(
613               {
614                   left      => '└',
615                   main_left => '╨',
616                   right     => '┘',
617                   middle    => '┴',
618               }
619           );
620
621           print $start_rule, $tb->title,
622               ( map { $mid_rule, $_, } $tb->body() ), $end_rule;
623
624       This emits the following output:
625
626           ┌────────╥───────┬───────┬─────────────┐
627           │ Number ║ First │ Last  │Country      │
628           ├────────╫───────┼───────┼─────────────┤
629           │1       ║Mark   │Twain  │     USA     │
630           ├────────╫───────┼───────┼─────────────┤
631           │2       ║Charles│Dickens│Great Britain│
632           ├────────╫───────┼───────┼─────────────┤
633           │3       ║Jules  │Verne  │   France    │
634           └────────╨───────┴───────┴─────────────┘
635

SUPPORT

637   Websites
638       The following websites have more information about this module, and may
639       be of help to you. As always, in addition to those websites please use
640       your favorite search engine to discover more resources.
641
642       •   MetaCPAN
643
644           A modern, open-source CPAN search engine, useful to view POD in
645           HTML format.
646
647           <https://metacpan.org/release/Text-Table>
648
649       •   RT: CPAN's Bug Tracker
650
651           The RT ( Request Tracker ) website is the default bug/issue
652           tracking system for CPAN.
653
654           <https://rt.cpan.org/Public/Dist/Display.html?Name=Text-Table>
655
656       •   CPANTS
657
658           The CPANTS is a website that analyzes the Kwalitee ( code metrics )
659           of a distribution.
660
661           <http://cpants.cpanauthors.org/dist/Text-Table>
662
663       •   CPAN Testers
664
665           The CPAN Testers is a network of smoke testers who run automated
666           tests on uploaded CPAN distributions.
667
668           <http://www.cpantesters.org/distro/T/Text-Table>
669
670       •   CPAN Testers Matrix
671
672           The CPAN Testers Matrix is a website that provides a visual
673           overview of the test results for a distribution on various
674           Perls/platforms.
675
676           <http://matrix.cpantesters.org/?dist=Text-Table>
677
678       •   CPAN Testers Dependencies
679
680           The CPAN Testers Dependencies is a website that shows a chart of
681           the test results of all dependencies for a distribution.
682
683           <http://deps.cpantesters.org/?module=Text::Table>
684
685   Bugs / Feature Requests
686       Please report any bugs or feature requests by email to "bug-text-table
687       at rt.cpan.org", or through the web interface at
688       <https://rt.cpan.org/Public/Bug/Report.html?Queue=Text-Table>. You will
689       be automatically notified of any progress on the request by the system.
690
691   Source Code
692       The code is open to the world, and available for you to hack on. Please
693       feel free to browse it and play with it, or whatever. If you want to
694       contribute patches, please send me a diff or prod me to pull from your
695       repository :)
696
697       <https://github.com/shlomif/Text-Table>
698
699         git clone git://github.com/shlomif/Text-Table.git
700

AUTHOR

702       Shlomi Fish <shlomif@cpan.org>
703

BUGS

705       Please report any bugs or feature requests on the bugtracker website
706       <https://github.com/shlomif/Text-Table/issues>
707
708       When submitting a bug or request, please include a test-file or a patch
709       to an existing test-file that illustrates the bug or desired feature.
710
712       This software is Copyright (c) 2002 by Anno Siegel and others.
713
714       This is free software, licensed under:
715
716         The ISC License
717

SUPPORT

719   Websites
720       The following websites have more information about this module, and may
721       be of help to you. As always, in addition to those websites please use
722       your favorite search engine to discover more resources.
723
724       •   MetaCPAN
725
726           A modern, open-source CPAN search engine, useful to view POD in
727           HTML format.
728
729           <https://metacpan.org/release/Text-Table>
730
731       •   RT: CPAN's Bug Tracker
732
733           The RT ( Request Tracker ) website is the default bug/issue
734           tracking system for CPAN.
735
736           <https://rt.cpan.org/Public/Dist/Display.html?Name=Text-Table>
737
738       •   CPANTS
739
740           The CPANTS is a website that analyzes the Kwalitee ( code metrics )
741           of a distribution.
742
743           <http://cpants.cpanauthors.org/dist/Text-Table>
744
745       •   CPAN Testers
746
747           The CPAN Testers is a network of smoke testers who run automated
748           tests on uploaded CPAN distributions.
749
750           <http://www.cpantesters.org/distro/T/Text-Table>
751
752       •   CPAN Testers Matrix
753
754           The CPAN Testers Matrix is a website that provides a visual
755           overview of the test results for a distribution on various
756           Perls/platforms.
757
758           <http://matrix.cpantesters.org/?dist=Text-Table>
759
760       •   CPAN Testers Dependencies
761
762           The CPAN Testers Dependencies is a website that shows a chart of
763           the test results of all dependencies for a distribution.
764
765           <http://deps.cpantesters.org/?module=Text::Table>
766
767   Bugs / Feature Requests
768       Please report any bugs or feature requests by email to "bug-text-table
769       at rt.cpan.org", or through the web interface at
770       <https://rt.cpan.org/Public/Bug/Report.html?Queue=Text-Table>. You will
771       be automatically notified of any progress on the request by the system.
772
773   Source Code
774       The code is open to the world, and available for you to hack on. Please
775       feel free to browse it and play with it, or whatever. If you want to
776       contribute patches, please send me a diff or prod me to pull from your
777       repository :)
778
779       <https://github.com/shlomif/Text-Table>
780
781         git clone git://github.com/shlomif/Text-Table.git
782

AUTHOR

784       Shlomi Fish <shlomif@cpan.org>
785

BUGS

787       Please report any bugs or feature requests on the bugtracker website
788       <https://github.com/shlomif/Text-Table/issues>
789
790       When submitting a bug or request, please include a test-file or a patch
791       to an existing test-file that illustrates the bug or desired feature.
792
794       This software is Copyright (c) 2002 by Anno Siegel and others.
795
796       This is free software, licensed under:
797
798         The ISC License
799
800
801
802perl v5.38.0                      2023-07-21                  Text::Table(3pm)
Impressum