Zicht\Tool\Script\Parser

Complexity

Total Complexity

16

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	12

Test Coverage

Coverage

31.03%

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
C	parse()	0	65	16

<?php
/**
 * For licensing information, please see the LICENSE file accompanied with this file.
 *
 * @author Gerard van Helden <drm@melp.nl>
 * @copyright 2012 Gerard van Helden <http://melp.nl>
 */

namespace Zicht\Tool\Script;

use Symfony\Component\Process\Exception\InvalidArgumentException;

/**
 * Parser for root nodes of the script
 */
class Parser extends AbstractParser
{
    /**
     * Parses the input tokenstream and returns a Script node
     *
     * @param TokenStream $input
     * @return Node\Script
     *
     * @throws \Symfony\Component\Process\Exception\InvalidArgumentException
     * @throws \UnexpectedValueException
     */
    public function parse(TokenStream $input)
    {
        $exprParser = new Parser\Expression($this);
        $ret = new Node\Script();
        if ($input->valid()) {
            do {
                $hasMatch = false;
                if ($input->match(Token::EXPR_START, '@(')) {
                    $input->next();
                    $type = $input->expect(Token::IDENTIFIER)->value;

                    switch ($type) {
                        case 'sh':
                            $ret->append(new Node\Script\Shell($exprParser->parse($input)));

It seems like $exprParser->parse($input) targeting Zicht\Tool\Script\Parser\Expression::parse() can also be of type null; however, Zicht\Tool\Script\Node\Script\Shell::__construct() does only seem to accept object<Zicht\Tool\Script\Node\Node>, maybe add an additional type check?

                            break;
                        case 'for':
                            $key = null;
                            $name = $input->expect(Token::IDENTIFIER)->value;
                            if ($input->match(',')) {
                                $input->next();
                                $key = $name;
                                $name = $input->expect(Token::IDENTIFIER)->value;
                            }
                            $input->expect(Token::KEYWORD, 'in');
                            $ret->append(new Node\Script\ForIn($exprParser->parse($input), $key, $name));

It seems like $exprParser->parse($input) targeting Zicht\Tool\Script\Parser\Expression::parse() can also be of type null; however, Zicht\Tool\Script\Node\Script\ForIn::__construct() does only seem to accept object<Zicht\Tool\Script\Node\Node>, maybe add an additional type check?

                            break;
                        case 'each':
                            $ret->append(new Node\Script\ForIn($exprParser->parse($input), null, null));

It seems like $exprParser->parse($input) targeting Zicht\Tool\Script\Parser\Expression::parse() can also be of type null; however, Zicht\Tool\Script\Node\Script\ForIn::__construct() does only seem to accept object<Zicht\Tool\Script\Node\Node>, maybe add an additional type check?

                            break;
                        case 'with':
                            $expr = $exprParser->parse($input);
                            $input->expect(Token::KEYWORD, 'as');
                            $name = $input->expect(Token::IDENTIFIER)->value;
                            $ret->append(new Node\Script\With($expr, $name));

It seems like $expr defined by $exprParser->parse($input) on line 57 can also be of type null; however, Zicht\Tool\Script\Node\Script\With::__construct() does only seem to accept object<Zicht\Tool\Script\Node\Node>, maybe add an additional type check?

                            break;
                        case 'if':
                            $ret->append(new Node\Script\Conditional($exprParser->parse($input)));

It seems like $exprParser->parse($input) targeting Zicht\Tool\Script\Parser\Expression::parse() can also be of type null; however, Zicht\Tool\Script\Node\Script\Conditional::__construct() does only seem to accept object<Zicht\Tool\Script\Node\Node>, maybe add an additional type check?

                            break;
                        default:
                            throw new \UnexpectedValueException("Unknown EXPR_START token at this point: {$type}");
                    }
                    $input->expect(Token::EXPR_END);
                    $hasMatch = true;
                }
                while ($input->match(Token::DATA) && preg_match('/^\s+$/', $input->current()->value)) {
                    $input->next();
                }
            } while ($hasMatch && $input->valid());
        }
        while ($input->valid()) {
            $cur = $input->current();
            if ($cur->match(Token::EXPR_START, '$(')) {
                $input->next();
                $ret->append(new Node\Expr\Expr($exprParser->parse($input)));

It seems like $exprParser->parse($input) targeting Zicht\Tool\Script\Parser\Expression::parse() can also be of type null; however, Zicht\Tool\Script\Node\Expr\Expr::__construct() does only seem to accept object<Zicht\Tool\Script\Node\Node>, maybe add an additional type check?

                $input->expect(Token::EXPR_END);
            } elseif ($cur->match(Token::DATA)) {
                $ret->append(new Node\Expr\Data($cur->value));
                $input->next();
            } else {
                throw new InvalidArgumentException("Unxpected token: " . $input->current()->type);
            }
        }

        return $ret;
    }
}