Zicht\Tool\Script\Parser::parse()

Complexity

Conditions	16
Paths	40

Size

Total Lines	65
Code Lines	54

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	99.9886

Importance

Changes

0

<?php
    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;
    }
}