"Fossies" - the Fresh Open Source Software Archive

Member "install-tl-20200916/tlpkg/tlperl/lib/TAP/Parser/YAMLish/Writer.pm" (10 Mar 2019, 5235 Bytes) of package /windows/misc/install-tl.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Perl source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 package TAP::Parser::YAMLish::Writer;
    2 
    3 use strict;
    4 use warnings;
    5 
    6 use base 'TAP::Object';
    7 
    8 our $VERSION = '3.42';
    9 
   10 my $ESCAPE_CHAR = qr{ [ \x00-\x1f \" ] }x;
   11 my $ESCAPE_KEY  = qr{ (?: ^\W ) | $ESCAPE_CHAR }x;
   12 
   13 my @UNPRINTABLE = qw(
   14   z    x01  x02  x03  x04  x05  x06  a
   15   x08  t    n    v    f    r    x0e  x0f
   16   x10  x11  x12  x13  x14  x15  x16  x17
   17   x18  x19  x1a  e    x1c  x1d  x1e  x1f
   18 );
   19 
   20 # new() implementation supplied by TAP::Object
   21 
   22 sub write {
   23     my $self = shift;
   24 
   25     die "Need something to write"
   26       unless @_;
   27 
   28     my $obj = shift;
   29     my $out = shift || \*STDOUT;
   30 
   31     die "Need a reference to something I can write to"
   32       unless ref $out;
   33 
   34     $self->{writer} = $self->_make_writer($out);
   35 
   36     $self->_write_obj( '---', $obj );
   37     $self->_put('...');
   38 
   39     delete $self->{writer};
   40 }
   41 
   42 sub _make_writer {
   43     my $self = shift;
   44     my $out  = shift;
   45 
   46     my $ref = ref $out;
   47 
   48     if ( 'CODE' eq $ref ) {
   49         return $out;
   50     }
   51     elsif ( 'ARRAY' eq $ref ) {
   52         return sub { push @$out, shift };
   53     }
   54     elsif ( 'SCALAR' eq $ref ) {
   55         return sub { $$out .= shift() . "\n" };
   56     }
   57     elsif ( 'GLOB' eq $ref || 'IO::Handle' eq $ref ) {
   58         return sub { print $out shift(), "\n" };
   59     }
   60 
   61     die "Can't write to $out";
   62 }
   63 
   64 sub _put {
   65     my $self = shift;
   66     $self->{writer}->( join '', @_ );
   67 }
   68 
   69 sub _enc_scalar {
   70     my $self = shift;
   71     my $val  = shift;
   72     my $rule = shift;
   73 
   74     return '~' unless defined $val;
   75 
   76     if ( $val =~ /$rule/ ) {
   77         $val =~ s/\\/\\\\/g;
   78         $val =~ s/"/\\"/g;
   79         $val =~ s/ ( [\x00-\x1f] ) / '\\' . $UNPRINTABLE[ ord($1) ] /gex;
   80         return qq{"$val"};
   81     }
   82 
   83     if ( length($val) == 0 or $val =~ /\s/ ) {
   84         $val =~ s/'/''/;
   85         return "'$val'";
   86     }
   87 
   88     return $val;
   89 }
   90 
   91 sub _write_obj {
   92     my $self   = shift;
   93     my $prefix = shift;
   94     my $obj    = shift;
   95     my $indent = shift || 0;
   96 
   97     if ( my $ref = ref $obj ) {
   98         my $pad = '  ' x $indent;
   99         if ( 'HASH' eq $ref ) {
  100             if ( keys %$obj ) {
  101                 $self->_put($prefix);
  102                 for my $key ( sort keys %$obj ) {
  103                     my $value = $obj->{$key};
  104                     $self->_write_obj(
  105                         $pad . $self->_enc_scalar( $key, $ESCAPE_KEY ) . ':',
  106                         $value, $indent + 1
  107                     );
  108                 }
  109             }
  110             else {
  111                 $self->_put( $prefix, ' {}' );
  112             }
  113         }
  114         elsif ( 'ARRAY' eq $ref ) {
  115             if (@$obj) {
  116                 $self->_put($prefix);
  117                 for my $value (@$obj) {
  118                     $self->_write_obj(
  119                         $pad . '-', $value,
  120                         $indent + 1
  121                     );
  122                 }
  123             }
  124             else {
  125                 $self->_put( $prefix, ' []' );
  126             }
  127         }
  128         else {
  129             die "Don't know how to encode $ref";
  130         }
  131     }
  132     else {
  133         $self->_put( $prefix, ' ', $self->_enc_scalar( $obj, $ESCAPE_CHAR ) );
  134     }
  135 }
  136 
  137 1;
  138 
  139 __END__
  140 
  141 =pod
  142 
  143 =head1 NAME
  144 
  145 TAP::Parser::YAMLish::Writer - Write YAMLish data
  146 
  147 =head1 VERSION
  148 
  149 Version 3.42
  150 
  151 =head1 SYNOPSIS
  152 
  153     use TAP::Parser::YAMLish::Writer;
  154     
  155     my $data = {
  156         one => 1,
  157         two => 2,
  158         three => [ 1, 2, 3 ],
  159     };
  160     
  161     my $yw = TAP::Parser::YAMLish::Writer->new;
  162     
  163     # Write to an array...
  164     $yw->write( $data, \@some_array );
  165     
  166     # ...an open file handle...
  167     $yw->write( $data, $some_file_handle );
  168     
  169     # ...a string ...
  170     $yw->write( $data, \$some_string );
  171     
  172     # ...or a closure
  173     $yw->write( $data, sub {
  174         my $line = shift;
  175         print "$line\n";
  176     } );
  177 
  178 =head1 DESCRIPTION
  179 
  180 Encodes a scalar, hash reference or array reference as YAMLish.
  181 
  182 =head1 METHODS
  183 
  184 =head2 Class Methods
  185 
  186 =head3 C<new>
  187 
  188  my $writer = TAP::Parser::YAMLish::Writer->new;
  189 
  190 The constructor C<new> creates and returns an empty
  191 C<TAP::Parser::YAMLish::Writer> object.
  192 
  193 =head2 Instance Methods
  194 
  195 =head3 C<write>
  196 
  197  $writer->write($obj, $output );
  198 
  199 Encode a scalar, hash reference or array reference as YAML.
  200 
  201     my $writer = sub {
  202         my $line = shift;
  203         print SOMEFILE "$line\n";
  204     };
  205     
  206     my $data = {
  207         one => 1,
  208         two => 2,
  209         three => [ 1, 2, 3 ],
  210     };
  211     
  212     my $yw = TAP::Parser::YAMLish::Writer->new;
  213     $yw->write( $data, $writer );
  214 
  215 
  216 The C< $output > argument may be:
  217 
  218 =over
  219 
  220 =item * a reference to a scalar to append YAML to
  221 
  222 =item * the handle of an open file
  223 
  224 =item * a reference to an array into which YAML will be pushed
  225 
  226 =item * a code reference
  227 
  228 =back
  229 
  230 If you supply a code reference the subroutine will be called once for
  231 each line of output with the line as its only argument. Passed lines
  232 will have no trailing newline.
  233 
  234 =head1 AUTHOR
  235 
  236 Andy Armstrong, <andy@hexten.net>
  237 
  238 =head1 SEE ALSO
  239 
  240 L<YAML::Tiny>, L<YAML>, L<YAML::Syck>, L<Config::Tiny>, L<CSS::Tiny>,
  241 L<http://use.perl.org/~Alias/journal/29427>
  242 
  243 =head1 COPYRIGHT
  244 
  245 Copyright 2007-2011 Andy Armstrong.
  246 
  247 This program is free software; you can redistribute
  248 it and/or modify it under the same terms as Perl itself.
  249 
  250 The full text of the license can be found in the
  251 LICENSE file included with this module.
  252 
  253 =cut
  254