—

              
package Text::MarkdownTable;
use strict;
use warnings;
use 5.010;
our $VERSION = '0.3.1';
use Moo;
use IO::File;
use IO::Handle::Util ();
has file => (
    is      => 'ro',
    lazy    => 1,
    default => sub { \*STDOUT },
);
has fh => (
    is      => 'ro',
    lazy    => 1,
    default => sub {
        my $fh = $_[0]->file;
        $fh = ref $fh 
            ? IO::Handle::Util::io_from_ref($fh) : IO::File->new($fh,"w");
        die "invalid option file" if !$fh;
        binmode $fh, $_[0]->encoding;
        $fh;
    }
);
has encoding => (
    is      => 'ro',
    default => sub { ':utf8' }
);
has fields => (
    is     => 'rw',
    trigger => 1,
);
# TODO: ensure that number of columns is number of fields
has columns => (
    is      => 'lazy',
    coerce  => \&_coerce_list,
    builder => sub { $_[0]->fields }
);
has widths => (
    is      => 'lazy',
    coerce  => \&_coerce_list,
    builder => sub {
        $_[0]->_fixed_width(0);
        return [map { defined($_) ? length $_ : 0 } @{$_[0]->columns}]
    },
);
has header => (
    is => 'rw', 
    default => sub { 1 }
);
has edges => (
    is => 'rw',
    default => sub { 1 },
);
has condense => (
    is => 'rw',
);
has streaming => (is => 'rwp');
has _fixed_width => (is => 'rw', default => sub { 1 });
# TODO: duplicated in Catmandu::Exporter::CSV fields-coerce
sub _coerce_list {
    if (ref $_[0]) {
        return $_[0] if ref $_[0] eq 'ARRAY';
        return [sort keys %{$_[0]}] if ref $_[0] eq 'HASH';
    }    
    return [split ',', $_[0]];
}
sub _trigger_fields {
    my ($self, $fields) = @_;
    $self->{fields} = _coerce_list($fields);
    if (ref $fields and ref $fields eq 'HASH') {
        $self->{columns} = [ map { $fields->{$_} // $_ } @{$self->{fields}} ];
    }
}
sub add {
    my ($self, $data) = @_;
    unless ($self->fields) {
        $self->{fields} = [ sort keys %$data ]
    }
    my $fields = $self->fields;
    my $widths = $self->widths; # may set 
    my $row = [ ];
    if (!$self->streaming and ($self->condense or $self->_fixed_width)) {
        $self->_set_streaming(1);
        $self->_print_header if $self->header;
    }
    foreach my $col (0..(@$fields-1)) {
        my $field = $fields->[$col];
        my $width = $widths->[$col];
        my $value = $data->{$field} // "";
        $value =~ s/[\n|]/ /g;
        my $w = length $value;
        if ($self->_fixed_width) {
            if (!$width or $w > $width) {
                if ($width > 5) {
                    $value = substr($value, 0, $width-3) . '...';
                } else {
                    $value = substr($value, 0, $width);
                }
            }
        } else {
            $widths->[$col] = $w if !$width or $w > $width;
        }
        push @$row, $value;
    }
    $self->_add_row($row);
    $self;
}
sub _add_row {
    my ($self, $row) = @_;
    if ($self->streaming) {
        $self->_print_row($row);
    } else {
        push @{$self->{_rows}}, $row;
    }
}
sub done {
    my ($self) = @_;
    if ($self->{_rows}) {
        $self->_print_header if $self->header;
        $self->_print_row($_) for @{$self->{_rows}};
    }
}
sub _print_header {
    my ($self) = @_;
    my $fh     = $self->fh;
    $self->_print_row($self->columns);
    if ($self->condense) {
        $self->_print_row([ map { '-' x length $_ } @{$self->columns} ]);
    } elsif ($self->edges) {
        print $fh '|'.('-' x ($_+2)) for @{$self->widths};
        print $fh "|\n";
    } else {
        print $fh substr(join('|',map { '-' x ($_+2) } @{$self->widths}),1,-1);
        print $fh "\n";
    }
}
has _row_format => (
    is      => 'lazy',
    builder => sub {
        if ( $_[0]->condense ) {
            join("|",map {"%s"} @{$_[0]->fields})."\n"
        } elsif ( $_[0]->edges ) {
            join("",map {"| %-".$_."s "} @{$_[0]->widths})."|\n";
        } else {
            join(" | ",map {"%-".$_."s"} @{$_[0]->widths})."\n";
        }
    }
);
sub _print_row {
    my ($self, $row) = @_;
    printf {$self->fh} $self->_row_format, @{$row};
}
1;
__END__
HideShow 151 lines of Pod
=head1 NAME
Text::MarkdownTable - Write Markdown syntax tables from data
=begin markdown
# STATUS
[![Build Status](https://travis-ci.org/nichtich/Text-MarkdownTable.png)](https://travis-ci.org/nichtich/Text-MarkdownTable)
[![Coverage Status](https://coveralls.io/repos/nichtich/Text-MarkdownTable/badge.png)](https://coveralls.io/r/nichtich/Text-MarkdownTable)
[![Kwalitee Score](http://cpants.cpanauthors.org/dist/Text-MarkdownTable.png)](http://cpants.cpanauthors.org/dist/Text-MarkdownTable)
=end markdown
=head1 SYNOPSIS
  my $table = Text::MarkdownTable->new;
  $table->add({one=>"a",two=>"table"});
  $table->add({one=>"is",two=>"nice"});
  $table->done;
  | one | two   |
  |-----|-------|
  | a   | table |
  | is  | nice  |
  Text::MarkdownTable->new( columns => ['X','Y','Z'], edges => 0 )
    ->add({a=>1,b=>2,c=>3})->done;
  X | Y | Z
  --|---|--
  1 | 2 | 3
   
=head1 DESCRIPTION
This module can be used to write data in tabular form, formatted in
MultiMarkdown syntax. The resulting format can be used for instance to display
CSV data or to include data tables in Markdown files. Newlines and vertical
bars in table cells are replaced by a space character and cell values can be
truncated.
=head1 CONFIGURATION
=over
=item file
Filename, GLOB, scalar reference or L<IO::Handle> to write to (default STDOUT).
=item fields
Array, hash reference, or comma-separated list of fields/columns.
=item columns
Column names. By default field names are used.
=item widths
Column widths. By default column widths are calculated automatically to the
width of the widest value. With given widths, the table is directly be written
without buffering and large table cell values are truncated.
=item header
Include header lines. Enabled by default.
=item edges
Include border before first column and after last column. Enabled by default.
Note that single-column tables don't not look like tables if edges are
disabled.
=item condense
Write table unbuffered in condense format:
  one|two
  ---|---
  a|table
  is|nice
Note that single-column tables are don't look like tables on condense format.
=back
=head1 METHODS
=over
=item add( $row )
Add a row as hash reference. Returns the table instance.
=item streaming
Returns whether rows are directly written or buffered until C<done> is called.
=item done
Finish and write the table unless it has already been written in C<streaming>
mode.
=back
=head1 SEE ALSO
See L<Catmandu::Exporter::Table> for an application of this module that can be
used to easily convert data to Markdown tables.
Similar table-generating modules include:
=over
=item L<Text::Table::Tiny>
=item L<Text::TabularDisplay>
=item L<Text::SimpleTable>
=item L<Text::Table>
=item L<Text::ANSITable>
=item L<Text::ASCIITable>
=item L<Text::UnicodeBox::Table>
=item L<Table::Simple>
=item L<Text::SimpleTable>
=item L<Text::SimpleTable::AutoWidth>
=back
=encoding utf8
=head1 AUTHOR
Jakob Voß E<lt>jakob.voss@gbv.deE<gt>
=head1 COPYRIGHT AND LICENSE
Copyright 2014- Jakob Voß
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
=cut