BaoPham\TreeParser\TreeParser

Complexity

Total Complexity

21

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

87.5%

Importance

Changes	3
Bugs	1	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	parse()	0	22	3
A	setTree()	0	4	1
A	getTree()	0	4	1
A	getOrderedNodes()	0	4	1
A	getStructure()	0	4	1
A	getParentForNode()	0	20	4
A	numberOfSpaces()	0	4	1
A	lineToNode()	0	12	1
B	setStructureAndOrderedNodes()	0	25	3
A	setIndentation()	0	5	1
A	spacesToLevel()	0	14	3

<?php

namespace BaoPham\TreeParser;

class TreeParser
{
    private $indentation = 2;

    /**
     * @var string
     */
    private $tree;

    /**
     * @var int
     */
    private $initialSpaces;

    /**
     * @var array
     */
    private $structure;

    /**
     * @var array
     */
    private $orderedNodes;

    /**
     * TreeParser constructor.
     * @param string $tree
     *
     * <<<TREE
     *  Root
     *    |- Level 1 - Order 1
     *      |- Level 2 - Order 2
     *        |- Level 3 - Order 3
     *        |- Level 3 - Order 4
     *      |- Level 2 - Order 5
     *    |- Level 1 - Order 6
     *      |- Level 2 - Order 7
     *        |- Level 3 - Order 8
     *          |- Level 4 - Order 9
     * TREE;
     */
    public function __construct($tree)
    {
        $this->tree = $tree;
    }

    public function parse()
    {
        $lines = explode(PHP_EOL, $this->tree);

        $this->setStructureAndOrderedNodes($lines);

        $root = $this->structure[TreeNode::ROOT_LEVEL][TreeNode::ROOT_ORDER];

        foreach ($this->orderedNodes as $node) {
            if ($node->isRoot) {
                continue;
            }

            $parent = $this->getParentForNode($node);

            $parent->children[] = $node;

            $node->parent = $parent;
        }

        return $root;
    }

    public function setTree($tree)
    {
        $this->tree = $tree;
    }

    public function getTree()
    {
        return $this->tree;
    }

    /**
     * @return array
     */
    public function getOrderedNodes()
    {
        return $this->orderedNodes;
    }

    /**
     * @return array
     */
    public function getStructure()
    {
        return $this->structure;
    }

    /**
     * @param int $indentation
     * @return TreeParser
     */
    public function setIndentation($indentation)
    {
        $this->indentation = $indentation;
        return $this;
    }

    /**
     * @param TreeNode $node
     * @return TreeNode|null
     */
    public function getParentForNode(TreeNode $node)
    {
        if ($node->level === TreeNode::ROOT_LEVEL) {
            return null;
        }

        $parentLevel = $node->level - 1;

        $candidates = $this->structure[$parentLevel];

        $order = $node->order - 1;

        while ($order >= TreeNode::ROOT_ORDER) {
            if (isset($candidates[$order])) {
                return $candidates[$order];
            }

            --$order;
        }
    }

    /**
     * @param $line
     * @return int
     */
    private function numberOfSpaces($line)
    {
        return strspn($line, ' ');
    }

    /**
     * @param $numberOfSpaces
     * @return int
     * @throws InvalidNumberOfSpaces
     */
    private function spacesToLevel($numberOfSpaces)
    {
        if ($numberOfSpaces === $this->initialSpaces) {
            return 0;
        }

        if (($numberOfSpaces - $this->initialSpaces) % $this->indentation !== 0) {
            throw new InvalidNumberOfSpaces(
                "Make sure children's leading spaces being a multiple of {$this->indentation}"
            );
        }

        return (int) ($numberOfSpaces - $this->initialSpaces) / $this->indentation;
    }

    private function lineToNode($line)
    {
        $line = trim($line);
        $line = ltrim($line, '|-');
        $line = trim($line);

        $node = new TreeNode();

        $node->name = $line;

        return $node;
    }

    private function setStructureAndOrderedNodes(array $lines)
    {
        $this->orderedNodes = [];

        $this->initialSpaces = null;

        $this->structure = [];

        foreach ($lines as $order => $line) {
            $node = $this->lineToNode($line);

            if ($this->initialSpaces === null) {
                $this->initialSpaces = $this->numberOfSpaces($line);
                $node->isRoot = true;
            }

            $node->order = (int) $order;

            $node->level = $this->spacesToLevel($this->numberOfSpaces($line));

            $this->structure[$node->level][$node->order] = $node;

            $this->orderedNodes[] = $node;
        }
    }
}