PeacefulBit\Slate\Core\Frame

Complexity

Total Complexity

18

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	evaluate()	0	16	1
A	valueOf()	0	12	1
A	__invoke()	0	4	1
A	isRoot()	0	4	1
A	has()	0	14	3
A	get()	0	14	3
A	set()	0	4	1
A	extend()	0	4	1
A	replace()	0	5	1
A	__toString()	0	4	1
A	getEvaluator()	0	4	1
A	useModule()	0	5	1
A	importModule()	0	10	1

<?php

namespace PeacefulBit\Slate\Core;

use function Nerd\Common\Arrays\toString;
use function Nerd\Common\Functional\tail;

use PeacefulBit\Slate\Exceptions\EvaluatorException;

class Frame
{
    /**
     * @var Evaluator
     */
    private $evaluator;

    /**
     * @var self
     */
    private $parent = null;

    /**
     * @var array
     */
    private $table = [];

    /**
     * @var array
     */
    private $modules = [];

    /**
     * @param Evaluator $evaluator
     * @param array $table
     * @param Frame|null $parent
     */
    public function __construct(Evaluator $evaluator, array $table = [], Frame $parent = null)
    {
        $this->evaluator = $evaluator;
        $this->table = $table;
        $this->parent = $parent;
    }

    /**
     * @param mixed $node
     * @return mixed
     */
    public function evaluate($node)
    {
//        if (!$node instanceof Nodes\NodeInterface) {

50% of this comment could be valid code. Did you maybe forget this after debugging?

//            return $node;
//        }

//        $iter = tail(function ($node) use (&$iter) {

59% of this comment could be valid code. Did you maybe forget this after debugging?

//            if ($node instanceof Nodes\CallExpression) {
//                return $iter($node->evaluate($this));
//            }
//            return $node;
//        });
//
//        return $iter($node->evaluate($this));
        return $node->evaluate($this);
    }

    /**
     * @param mixed $node
     * @return mixed
     */
    public function valueOf($node)
    {
//        $iter = tail(function ($node) use (&$iter) {

57% of this comment could be valid code. Did you maybe forget this after debugging?

//            if ($node instanceof Nodes\Node) {
//                return $iter($this->evaluate($node));
//            }
//            return $node;
//        });
//
//        return $iter($node);
        return $this->evaluate($node);
    }

    /**
     * @param mixed $node
     * @return mixed
     */
    public function __invoke($node)
    {
        return $this->evaluate($node);
    }

    /**
     * @return bool
     */
    public function isRoot(): bool
    {
        return is_null($this->parent);
    }

    /**
     * @param string $key
     * @return bool
     */
    public function has(string $key): bool
    {
        $iter = tail(function ($key, Frame $frame) use (&$iter) {
            if (array_key_exists($key, $frame->table)) {
                return true;
            }
            if ($frame->isRoot()) {
                return false;
            }
            return $iter($key, $frame->parent);
        });

        return $iter($key, $this);
    }

    /**
     * @param string $key
     * @return mixed|null
     * @throws EvaluatorException
     */
    public function get(string $key)
    {
        $iter = tail(function ($key, Frame $frame) use (&$iter) {
            if (array_key_exists($key, $frame->table)) {
                return $frame->table[$key];
            }
            if ($frame->isRoot()) {
                throw new EvaluatorException("Symbol \"$key\" not defined");
            }
            return $iter($key, $frame->parent);
        });

        return $iter($key, $this);
    }

    /**
     * @param string $key
     * @param mixed $value
     * @return void
     */
    public function set(string $key, $value)
    {
        $this->table[$key] = $value;
    }

    /**
     * @param array $table
     * @return Frame
     */
    public function extend(array $table = []): Frame
    {
        return new self($this->evaluator, $table, $this);
    }

    /**
     * @param array $table
     * @return Frame
     */
    public function replace(array $table = []): Frame
    {
        $this->table = array_merge($this->table, $table);
        return $this;
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return toString(array_keys($this->table));
    }

    /**
     * @return Evaluator
     */
    public function getEvaluator(): Evaluator
    {
        return $this->evaluator;
    }

    /**
     * @param $name
     * @param null|string $alias
     */
    public function useModule(string $name, string $alias = null)
    {
        $module = $this->getEvaluator()->getModule($name);
        $this->modules[$alias ?? $name] = $module;
    }

    /**
     * @param string $name
     * @param array|null $functions
     */
    public function importModule(string $name, array $functions = null)
    {
        $module = $this->getEvaluator()->getModule($name);

        $importFunctions = $functions ?? array_keys($module);

        array_walk($importFunctions, function ($fn) use (&$module) {
            $this->set($fn, $module[$fn]);
        });
    }
}