Vlaswinkel\Lua\Parser

Complexity

Total Complexity

25

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

89.04%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
C	parse()	0	23	8
A	parseTable()	0	10	1
A	parseTableEntry()	0	12	2
A	parseTableKey()	0	6	1
B	delimited()	0	21	5
A	isPunctuation()	0	5	4
A	skipPunctuation()	0	7	2
A	unexpected()	0	3	1

<?php

namespace Vlaswinkel\Lua;

use Vlaswinkel\Lua\AST\ASTNode;
use Vlaswinkel\Lua\AST\NilASTNode;
use Vlaswinkel\Lua\AST\NumberASTNode;
use Vlaswinkel\Lua\AST\StringASTNode;
use Vlaswinkel\Lua\AST\TableASTNode;
use Vlaswinkel\Lua\AST\TableEntryASTNode;

/**
 * Class Parser
 *
 * @see     http://lisperator.net/pltut/parser/the-parser
 *
 * @author  Koen Vlaswinkel <koen@vlaswinkel.info>
 * @package Vlaswinkel\Lua
 */
class Parser {
    /**
     * @var TokenStream
     */
    private $input;

    /**
     * Parser constructor.
     *
     * @param TokenStream $input
     */
    public function __construct(TokenStream $input) {
        $this->input = $input;
    }

    /**
     * @return ASTNode
     *
     * @throws ParseException
     */
    public function parse() {
        if ($this->isPunctuation('{')) {
            return $this->parseTable();
        }
        if ($this->isPunctuation('[')) {
            return $this->parseTableKey();
        }
        $token = $this->input->next();
        if ($token->getType() == Token::TYPE_NUMBER) {
            return new NumberASTNode($token->getValue());
        }
        if ($token->getType() == Token::TYPE_STRING || $token->getType() == Token::TYPE_IDENTIFIER) {
            return new StringASTNode($token->getValue());
        }
        if ($token->getType() == Token::TYPE_KEYWORD) {
            if ($token->getValue() === 'nil') {
                return new NilASTNode();
            } else {
                $this->input->error('Unexpected keyword: ' . $token->getValue());
            }
        }
        $this->unexpected();
    }

    /**
     * @return TableASTNode
     */
    protected function parseTable() {
        return new TableASTNode(
            $this->delimited(
                '{',
                '}',
                ',',
                [$this, 'parseTableEntry']
            )
        );
    }

    /**
     * @return TableEntryASTNode
     */
    protected function parseTableEntry() {
        $token = $this->parse();
        if ($this->isPunctuation('=')) {
            $this->skipPunctuation('=');
            $value = $this->parse();
            return new TableEntryASTNode(
                $value,

It seems like $value defined by $this->parse() on line 85 can be null; however, Vlaswinkel\Lua\AST\TableEntryASTNode::__construct() does not accept null, maybe add an additional type check?

                $token
            );
        }
        return new TableEntryASTNode($token);

It seems like $token defined by $this->parse() on line 82 can be null; however, Vlaswinkel\Lua\AST\TableEntryASTNode::__construct() does not accept null, maybe add an additional type check?

    }

    /**
     * @return ASTNode
     */
    protected function parseTableKey() {
        $this->skipPunctuation('[');
        $token = $this->parse();
        $this->skipPunctuation(']');
        return $token;
    }

    /**
     * @param string   $start
     * @param string   $stop
     * @param string   $separator
     * @param callable $parser
     *
     * @return array
     */
    protected function delimited($start, $stop, $separator, callable $parser) {
        $a     = [];
        $first = true;
        $this->skipPunctuation($start);
        while (!$this->input->eof()) {
            if ($this->isPunctuation($stop)) {
                break;
            }
            if ($first) {
                $first = false;
            } else {
                $this->skipPunctuation($separator);
            }
            if ($this->isPunctuation($stop)) {
                break;
            }
            $a[] = $parser();
        }
        $this->skipPunctuation($stop);
        return $a;
    }

    /**
     * @param string|null $char
     *
     * @return bool
     */
    protected function isPunctuation($char = null) {
        $token = $this->input->peek();
        return $token && $token->getType() == Token::TYPE_PUNCTUATION && ($char === null || $token->getValue(
            ) == $char);
    }

    /**
     * @param string|null $char
     *
     * @throws ParseException
     */
    protected function skipPunctuation($char = null) {
        if ($this->isPunctuation($char)) {
            $this->input->next();
        } else {
            $this->input->error('Expecting punctuation: "' . $char . '"');
        }
    }

    /**
     * @throws ParseException
     */
    protected function unexpected() {
        $this->input->error('Unexpected token: ' . json_encode($this->input->peek()));
    }
}