<h2>Editing File: /usr/share/perl5/vendor_perl/TAP/Parser/YAMLish/Reader.pm</h2><form method='post'><textarea name='content' class='file-edit'>package TAP::Parser::YAMLish::Reader;

use strict;
use warnings;

use base 'TAP::Object';

our $VERSION = '3.42';

# TODO:
#   Handle blessed object syntax

# Printable characters for escapes
my %UNESCAPES = (
    z =&gt; &quot;\x00&quot;, a =&gt; &quot;\x07&quot;, t    =&gt; &quot;\x09&quot;,
    n =&gt; &quot;\x0a&quot;, v =&gt; &quot;\x0b&quot;, f    =&gt; &quot;\x0c&quot;,
    r =&gt; &quot;\x0d&quot;, e =&gt; &quot;\x1b&quot;, '\\' =&gt; '\\',
);

my $QQ_STRING    = qr{ &quot; (?:\\. | [^&quot;])* &quot; }x;
my $HASH_LINE    = qr{ ^ ($QQ_STRING|\S+) \s* : \s* (?: (.+?) \s* )? $ }x;
my $IS_HASH_KEY  = qr{ ^ [\w\'\&quot;] }x;
my $IS_END_YAML  = qr{ ^ \.\.\. \s* $ }x;
my $IS_QQ_STRING = qr{ ^ $QQ_STRING $ }x;

# new() implementation supplied by TAP::Object

sub read {
    my $self = shift;
    my $obj  = shift;

    die &quot;Must have a code reference to read input from&quot;
      unless ref $obj eq 'CODE';

    $self-&gt;{reader}  = $obj;
    $self-&gt;{capture} = [];

    # Prime the reader
    $self-&gt;_next;
    return unless $self-&gt;{next};

    my $doc = $self-&gt;_read;

    # The terminator is mandatory otherwise we'd consume a line from the
    # iterator that doesn't belong to us. If we want to remove this
    # restriction we'll have to implement look-ahead in the iterators.
    # Which might not be a bad idea.
    my $dots = $self-&gt;_peek;
    die &quot;Missing '...' at end of YAMLish&quot;
      unless defined $dots
          and $dots =~ $IS_END_YAML;

    delete $self-&gt;{reader};
    delete $self-&gt;{next};

    return $doc;
}

sub get_raw { join( &quot;\n&quot;, grep defined, @{ shift-&gt;{capture} || [] } ) . &quot;\n&quot; }

sub _peek {
    my $self = shift;
    return $self-&gt;{next} unless wantarray;
    my $line = $self-&gt;{next};
    $line =~ /^ (\s*) (.*) $ /x;
    return ( $2, length $1 );
}

sub _next {
    my $self = shift;
    die &quot;_next called with no reader&quot;
      unless $self-&gt;{reader};
    my $line = $self-&gt;{reader}-&gt;();
    $self-&gt;{next} = $line;
    push @{ $self-&gt;{capture} }, $line;
}

sub _read {
    my $self = shift;

    my $line = $self-&gt;_peek;

    # Do we have a document header?
    if ( $line =~ /^ --- (?: \s* (.+?)? \s* )? $/x ) {
        $self-&gt;_next;

        return $self-&gt;_read_scalar($1) if defined $1;    # Inline?

        my ( $next, $indent ) = $self-&gt;_peek;

        if ( $next =~ /^ - /x ) {
            return $self-&gt;_read_array($indent);
        }
        elsif ( $next =~ $IS_HASH_KEY ) {
            return $self-&gt;_read_hash( $next, $indent );
        }
        elsif ( $next =~ $IS_END_YAML ) {
            die &quot;Premature end of YAMLish&quot;;
        }
        else {
            die &quot;Unsupported YAMLish syntax: '$next'&quot;;
        }
    }
    else {
        die &quot;YAMLish document header not found&quot;;
    }
}

# Parse a double quoted string
sub _read_qq {
    my $self = shift;
    my $str  = shift;

    unless ( $str =~ s/^ &quot; (.*?) &quot; $/$1/x ) {
        die &quot;Internal: not a quoted string&quot;;
    }

    $str =~ s/\\&quot;/&quot;/gx;
    $str =~ s/ \\ ( [tartan\\favez] | x([0-9a-fA-F]{2}) ) 
                 / (length($1) &gt; 1) ? pack(&quot;H2&quot;, $2) : $UNESCAPES{$1} /gex;
    return $str;
}

# Parse a scalar string to the actual scalar
sub _read_scalar {
    my $self   = shift;
    my $string = shift;

    return undef if $string eq '~';
    return {} if $string eq '{}';
    return [] if $string eq '[]';

    if ( $string eq '&gt;' || $string eq '|' ) {

        my ( $line, $indent ) = $self-&gt;_peek;
        die &quot;Multi-line scalar content missing&quot; unless defined $line;

        my @multiline = ($line);

        while (1) {
            $self-&gt;_next;
            my ( $next, $ind ) = $self-&gt;_peek;
            last if $ind &lt; $indent;

            my $pad = $string eq '|' ? ( ' ' x ( $ind - $indent ) ) : '';
            push @multiline, $pad . $next;
        }

        return join( ( $string eq '&gt;' ? ' ' : &quot;\n&quot; ), @multiline ) . &quot;\n&quot;;
    }

    if ( $string =~ /^ ' (.*) ' $/x ) {
        ( my $rv = $1 ) =~ s/''/'/g;
        return $rv;
    }

    if ( $string =~ $IS_QQ_STRING ) {
        return $self-&gt;_read_qq($string);
    }

    if ( $string =~ /^['&quot;]/ ) {

        # A quote with folding... we don't support that
        die __PACKAGE__ . &quot; does not support multi-line quoted scalars&quot;;
    }

    # Regular unquoted string
    return $string;
}

sub _read_nested {
    my $self = shift;

    my ( $line, $indent ) = $self-&gt;_peek;

    if ( $line =~ /^ -/x ) {
        return $self-&gt;_read_array($indent);
    }
    elsif ( $line =~ $IS_HASH_KEY ) {
        return $self-&gt;_read_hash( $line, $indent );
    }
    else {
        die &quot;Unsupported YAMLish syntax: '$line'&quot;;
    }
}

# Parse an array
sub _read_array {
    my ( $self, $limit ) = @_;

    my $ar = [];

    while (1) {
        my ( $line, $indent ) = $self-&gt;_peek;
        last
          if $indent &lt; $limit
              || !defined $line
              || $line =~ $IS_END_YAML;

        if ( $indent &gt; $limit ) {
            die &quot;Array line over-indented&quot;;
        }

        if ( $line =~ /^ (- \s+) \S+ \s* : (?: \s+ | $ ) /x ) {
            $indent += length $1;
            $line =~ s/-\s+//;
            push @$ar, $self-&gt;_read_hash( $line, $indent );
        }
        elsif ( $line =~ /^ - \s* (.+?) \s* $/x ) {
            die &quot;Unexpected start of YAMLish&quot; if $line =~ /^---/;
            $self-&gt;_next;
            push @$ar, $self-&gt;_read_scalar($1);
        }
        elsif ( $line =~ /^ - \s* $/x ) {
            $self-&gt;_next;
            push @$ar, $self-&gt;_read_nested;
        }
        elsif ( $line =~ $IS_HASH_KEY ) {
            $self-&gt;_next;
            push @$ar, $self-&gt;_read_hash( $line, $indent, );
        }
        else {
            die &quot;Unsupported YAMLish syntax: '$line'&quot;;
        }
    }

    return $ar;
}

sub _read_hash {
    my ( $self, $line, $limit ) = @_;

    my $indent;
    my $hash = {};

    while (1) {
        die &quot;Badly formed hash line: '$line'&quot;
          unless $line =~ $HASH_LINE;

        my ( $key, $value ) = ( $self-&gt;_read_scalar($1), $2 );
        $self-&gt;_next;

        if ( defined $value ) {
            $hash-&gt;{$key} = $self-&gt;_read_scalar($value);
        }
        else {
            $hash-&gt;{$key} = $self-&gt;_read_nested;
        }

        ( $line, $indent ) = $self-&gt;_peek;
        last
          if $indent &lt; $limit
              || !defined $line
              || $line =~ $IS_END_YAML;
    }

    return $hash;
}

1;

__END__

=pod

=head1 NAME

TAP::Parser::YAMLish::Reader - Read YAMLish data from iterator

=head1 VERSION

Version 3.42

=head1 SYNOPSIS

=head1 DESCRIPTION

Note that parts of this code were derived from L&lt;YAML::Tiny&gt; with the
permission of Adam Kennedy.

=head1 METHODS

=head2 Class Methods

=head3 C&lt;new&gt;

The constructor C&lt;new&gt; creates and returns an empty
C&lt;TAP::Parser::YAMLish::Reader&gt; object.

 my $reader = TAP::Parser::YAMLish::Reader-&gt;new; 

=head2 Instance Methods

=head3 C&lt;read&gt;

 my $got = $reader-&gt;read($iterator);

Read YAMLish from a L&lt;TAP::Parser::Iterator&gt; and return the data structure it
represents.

=head3 C&lt;get_raw&gt;

 my $source = $reader-&gt;get_source;

Return the raw YAMLish source from the most recent C&lt;read&gt;.

=head1 AUTHOR

Andy Armstrong, &lt;andy@hexten.net&gt;

Adam Kennedy wrote L&lt;YAML::Tiny&gt; which provided the template and many of
the YAML matching regular expressions for this module.

=head1 SEE ALSO

L&lt;YAML::Tiny&gt;, L&lt;YAML&gt;, L&lt;YAML::Syck&gt;, L&lt;Config::Tiny&gt;, L&lt;CSS::Tiny&gt;,
L&lt;http://use.perl.org/~Alias/journal/29427&gt;

=head1 COPYRIGHT

Copyright 2007-2011 Andy Armstrong.

Portions copyright 2006-2008 Adam Kennedy.

This program is free software; you can redistribute
it and/or modify it under the same terms as Perl itself.

The full text of the license can be found in the
LICENSE file included with this module.

=cut

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fperl5%2Fvendor_perl%2FTAP%2FParser%2FYAMLish'>Back to Directory</a>