File Coverage

blib/lib/Games/Solitaire/Verify/Solution.pm

Criterion	Covered	Total	%
statement	71	79	89.8
branch	14	24	58.3
condition	4	6	66.6
subroutine	14	14	100.0
pod	1	1	100.0
total	104	124	83.8

package Games::Solitaire::Verify::Solution;
$Games::Solitaire::Verify::Solution::VERSION = '0.2601';
use warnings;
use strict;

use 5.008;


use parent 'Games::Solitaire::Verify::Solution::Base';

use Games::Solitaire::Verify::Exception ();
use Games::Solitaire::Verify::Card      ();
use Games::Solitaire::Verify::Column    ();
use Games::Solitaire::Verify::Move      ();
use Games::Solitaire::Verify::State     ();


sub _init
{
    my ( $self, $args ) = @_;

    $self->SUPER::_init($args);

    $self->_st(undef);
    $self->_reached_end(0);

    return 0;
}

sub _read_state
{
    my $self = shift;

    my $line = $self->_l();

    if ( $line ne "\n" )
    {
        die "Non empty line before state";
    }

    my $str = "";

    while ( ( $line = $self->_l() ) && ( $line ne "\n" ) )
    {
        $str .= $line;
    }

    if ( !defined( $self->_st() ) )
    {
        $self->_st(
            Games::Solitaire::Verify::State->new(
                {
                    string => $str,
                    @{ $self->_V },
                }
            )
        );
    }
    else
    {
        if ( $self->_st()->to_string() ne $str )
        {
            die "States don't match";
        }
    }

    while ( defined( $line = $self->_l() ) && ( $line eq "\n" ) )
    {
    }

    if ( $line !~ m{\A={3,}\n\z} )
    {
        die "No ======== separator";
    }

    return ();
}

sub _read_move
{
    my $self = shift;

    my $line = $self->_l();

    if ( $line ne "\n" )
    {
        die "No empty line before move";
    }

    $line = $self->_l();

    if ( $line eq "This game is solveable.\n" )
    {
        $self->_reached_end(1);

        return "END";
    }

    chomp($line);

    $self->_move(
        Games::Solitaire::Verify::Move->new(
            {
                fcs_string => $line,
                game       => $self->_variant(),
            }
        )
    );

    return ();
}

sub _apply_move
{
    my $self = shift;

    if ( my $verdict = $self->_st()->verify_and_perform_move( $self->_move() ) )
    {
        Games::Solitaire::Verify::Exception::VerifyMove->throw(
            error   => "Wrong Move",
            problem => $verdict,
        );
    }

    return ();
}


sub verify
{
    my $self = shift;

    eval {

        my $line = $self->_l();

        if ( $line !~ m{\A(-=)+-\n\z} )
        {
            die "Incorrect start";
        }

        $self->_read_state();
        $self->_st->verify_contents( { max_rank => $self->_max_rank } );

        while ( !defined( scalar( $self->_read_move() ) ) )
        {
            $self->_apply_move();
            $self->_read_state();
        }
    };

    my $err;
    if ( !$@ )
    {
        # Do nothing - no exception was thrown.
    }
    elsif (
        $err = Exception::Class->caught(
            'Games::Solitaire::Verify::Exception::VerifyMove')
        )
    {
        return { error => $err, line_num => $self->_ln(), };
    }
    elsif (
        $err = Exception::Class->caught(
            'Games::Solitaire::Verify::Exception::State::MissingCards')
        )
    {
        return { error => $err, line_num => $self->_ln(), };
    }
    elsif (1)
    {
        $err = Exception::Class->caught();
        ref $err ? $err->rethrow : die $err;
    }

    return ();
}

1;    # End of Games::Solitaire::Verify::Solution

__END__