File Coverage

blib/lib/Paludis/ResumeState/Serialization/Grammar.pm

Criterion	Covered	Total	%
statement	28	28	100.0
branch	6	6	100.0
condition			n/a
subroutine	9	9	100.0
pod	1	1	100.0
total	44	44	100.0

use strict;
use warnings;

package Paludis::ResumeState::Serialization::Grammar;
BEGIN {
  $Paludis::ResumeState::Serialization::Grammar::AUTHORITY = 'cpan:KENTNL';
}
{
  $Paludis::ResumeState::Serialization::Grammar::VERSION = '0.01000410';
}

# ABSTRACT: A Regexp::Grammars grammar for parsing Paludis Resume-states

use Regexp::Grammars;
use Regexp::Grammars::Common::String;


our $CLASS_CALLBACK;
our $LIST_CALLBACK;

{
  ## no critic ( ProhibitMultiplePackages )
  package    # Hide
    Paludis::ResumeState::Serialization::Grammar::FakeClass;

  package    # Hide
    Paludis::ResumeState::Serialization::Grammar::FakeList;
}

sub _classize {
  my ( $name, $parameters, $parameters_list, $extra ) = @_;
  if ( defined $CLASS_CALLBACK ) {
    return $CLASS_CALLBACK->( $name, $parameters, $parameters_list, $extra );
  }
  bless $parameters, __PACKAGE__ . '::FakeClass';
  $parameters->{_classname} = $name;
  return $parameters;
}

sub _listize {
  my ($parameters) = @_;
  if ( defined $LIST_CALLBACK ) {
    return $LIST_CALLBACK->($parameters);
  }
  bless $parameters, __PACKAGE__ . '::FakeArray';
  return $parameters;
}

my $t;


sub grammar {
  _build_grammar() unless defined $t;
  return $t;
}

sub _build_grammar {
  ## no critic ( RegularExpressions )
  $t = qr{








        @

        \(\)

    (?{
        if( ref $MATCH{parameters} ){
            my @parameters = @{$MATCH{parameters}};
            my %hash;
            my @list;
            my %extra = ();
            my $i;
            for( @parameters ){
                $hash{$_->{label}} = $_->{value};
                push @list, [ $_->{label} , $_->{value} ];
                $i++;
            }
            if( scalar keys %hash  == $i ){
                $extra{pid} = $MATCH{pid};
                $MATCH = Paludis::ResumeState::Serialization::Grammar::_classize( $MATCH{classname}, \%hash, \@list, \%extra );
            }


        }
    })

      [A-Z][A-Za-z0-9]*

     \(\)

    (?{
        if( not $MATCH{parameters} ) {
            $MATCH = Paludis::ResumeState::Serialization::Grammar::_classize( $MATCH{classname}, {}, [], {} );
        } elsif( ref $MATCH{parameters} ){
            my @parameters = @{$MATCH{parameters} || []};
            my %hash;
            my @list;
            my $i;
            for( @parameters ){
                $hash{$_->{label}} = $_->{value};
                push @list, [ $_->{label} , $_->{value} ];
                $i++;
            }
            if( scalar keys %hash  == $i ){
                $MATCH = Paludis::ResumeState::Serialization::Grammar::_classize( $MATCH{classname}, \%hash, \@list, {}  );
            }


        }
    })

         \(\)
    (?{
        if( not $MATCH{parameters} ){
            $MATCH = Paludis::ResumeState::Serialization::Grammar::_listize( [] );
        } elsif ( ref $MATCH{parameters} and $MATCH{parameters}->[-1]->{label} eq 'count' ){
            my $count = pop @{ $MATCH{parameters} };
            $MATCH{count} = int($count->{value});
            my @items = map { $_->{value} } @{ $MATCH{parameters} };
            $MATCH = Paludis::ResumeState::Serialization::Grammar::_listize( \@items );
        }
    })

          ||
          [a-z0-9_]+

      (|(<[MATCH=parameter]> ** (;))(;)?)

      =

    }x;

  return 1;
}

1;

__END__