File Coverage

blib/lib/JSON/Parser/Regexp.pm

Criterion	Covered	Total	%
statement	55	70	78.5
branch	2	10	20.0
condition	0	3	0.0
subroutine	19	23	82.6
pod	0	2	0.0
total	76	108	70.3

package JSON::Parser::Regexp;

use utf8;
use Regexp::Grammars;

our $VERSION = '0.19';

sub new {
    my $class = shift;
    return bless {}, $class;
}

sub T::JSON::X {
    my ($self) = @_;
    return $self->{Hash}->X();
}

sub T::Hash::X {
    my ($self) = @_;
    my %hash = $self->{Key_Values}->X();
    return \%hash;
}

sub T::Key_Values::X {
    my ($self) = @_;
    my @kvs = ();
    for my $element ( @{ $self->{Key_Value} } ) {
        push @kvs, $element->X();
    }
    return @kvs;
}

sub T::Key_Value::X {
    my ($self) = @_;
    my $key    = $self->{Key}->X();
    my $sep    = $self->{Sep}->X();
    my $value  = $self->{Value}->X();

    if ( $sep eq ':' ) {
        my @kv = ( $key, $value );
        return @kv;
    }
}

sub T::Key::X {
    my ($self) = @_;
    return $self->{String_Value}->X();
}

sub T::Value::X {
    my ($self) = @_;
    return $self->{Any_Value}->X();
}

sub T::Any_Value::X {
    my ($self) = @_;
    (      $self->{String_Value}
        || $self->{Numeric_Value}
        || $self->{Null_Value}
        || $self->{Hash}
        || $self->{Array}
        || $self->{True}
        || $self->{False} )->X();
}

sub T::String_Value::X {
    my ($self) = @_;
    return $self->{Words}->X();
}

sub T::Words::X {
    my ($self) = @_;
    return $self->{''};
}

sub T::Numeric_Value::X {
    my ($self) = @_;
    return $self->{Number}->X();
}

sub T::Number::X {
    my ($self) = @_;
    return $self->{''};
}

sub T::Null_Value::X {
    my ($self) = @_;
    if ( $self->{''} eq 'null' ) {
        return undef;
    }
}

sub T::True::X {
    my ($self) = @_;
    if ( $self->{''} eq 'true' ) {
        my $TRUE = 1;
        my $class = "JSON::Parser::Regexp::Bool";
        return bless \$TRUE, $class;
    }
}

sub T::False::X {
    my ($self) = @_;
    if ( $self->{''} eq 'false' ) {
        my $FALSE = 0;
        my $class = "JSON::Parser::Regexp::Bool";
        return bless \$FALSE, $class;
    }
}

sub T::Array::X {
    my ($self) = @_;
    return $self->{Array_Elements}->X();
}

sub T::Array_Elements::X {
    my ($self) = @_;
    my @array = ();
    for my $element ( @{ $self->{Array_Element} } ) {
        push @array, $element->X();
    }
    return \@array;
}

sub T::Array_Element::X {
    my ($self) = @_;
    return $self->{Any_Value}->X();
}

sub T::Sep::X {
    my ($self) = @_;
    return $self->{''};
}

sub T::Comma::X {
    my ($self) = @_;
    return $self->{''};
}

my $Parser = qr {





                |  |  |  |  |  |

                    \{  \}

              <[Key_Value]>+ %




                   \[  \]
          <[Array_Element]>+ %


            \s*\"\s*\s*\"\s*
                   (.)*?

           \s*\s*
                  [-]?[\d\.]*

              null
                    true
                   false
                     \:
                   \,

}xms;

sub decode {
    my ( $self, $String ) = @_;
    if ( $String =~ $Parser ) {
        $/{JSON}->X();
    }
}

1;
__END__