Node::define() - Code Metrics - Inspection of "f496ba49d9fce785611f72592a0c5c0695b49cd3" - dallgoot/yaml - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — master (f496ba)

by stéphane
created 2018-07-24 18:07 UTC
Node::define() C

↳ Parent: Node
Complexity

Conditions	14
Paths	14
Size

Total Lines	19
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	14
eloc	16
nc	14
nop	1
dl	0
loc	19
rs	6.2666
c	0
b	0
f	0
How to fix Complexity

<?php
namespace Dallgoot\Yaml;


use Dallgoot\Yaml\{Types as T, Regex as R};
use \SplDoublyLinkedList as DLL;

class Node

{
    /** @var int */

    public $indent = -1;
    /** @var int */

    public $line;
    /** @var int */

    public $type;
    /** @var null|string|boolean */

    public $identifier;
    /** @var Node|DLL|null|string */

    public $value;

    /** @var null|Node */

    private $parent;


    public function __construct($nodeString = null, $line = null)

    {
        $this->line = $line;
        if (is_null($nodeString)) {
            $this->type = T::ROOT;
        } else {
            $this->parse($nodeString);
        }
    }

    public function setParent(Node $node):Node

    {
        $this->parent = $node;
        return $this;
    }

    public function getParent($indent = null):Node

    {
        if (is_null($indent)) return $this->parent ?? $this;

        $cursor = $this;
        while ($cursor->indent >= $indent) {
            $cursor = $cursor->parent;
        }
        return $cursor;

    }

    public function add(Node $child):void

    {
        $child->setParent($this);
        $current = $this->value;
        if (in_array($this->type, T::$LITTERALS)) $child->type = T::SCALAR;

        if (is_null($current)) {
            $this->value = $child;
            return;
        } elseif ($current instanceof Node) {
            $this->value = new DLL();
            $this->value->setIteratorMode(DLL::IT_MODE_KEEP);
            $this->value->push($current);
        }
        $this->value->push($child);
                      push($child);
        //modify type according to child
        if ($this->value instanceof DLL && !property_exists($this->value, "type")) {
            switch ($child->type) {
                case T::KEY:    $this->value->type = T::MAPPING;break;

                case T::ITEM:   $this->value->type = T::SEQUENCE;break;

                case T::SCALAR: $this->value->type = $this->type;break;

            }
        }
    }

    public function getDeepestNode():Node

    {
        $cursor = $this;
        while ($cursor->value instanceof Node) {
            $cursor = $cursor->value;
        }
        return $cursor;
    }

    /**

    *  CAUTION : the types assumed here are NOT FINAL : they CAN be adjusted according to parent
    */

    public function parse(String $nodeString):Node
    {
        $nodeValue = preg_replace("/^\t+/m", " ", $nodeString);//permissive to tabs but replacement
        $this->indent = strspn($nodeValue, ' ');
        $nodeValue = ltrim($nodeValue);
        if ($nodeValue === '') {
            $this->type = T::EMPTY;
            // $this->indent = 0; // remove if no bugs
        } elseif (substr($nodeValue, 0, 3) === '...') {//TODO: can have something on same line ?
            $this->type = T::DOC_END;
        } elseif (preg_match(R::KEY, $nodeValue, $matches)) {
            $this->onKey($matches);
        } else {//NOTE: can be of another type according to parent
            list($this->type, $value) = $this->define($nodeValue);
            is_object($value) ? $this->add($value) : $this->value = $value;
        }
        return $this;
    }

    /**
     *  Set the type and value according to first character
     *
     * @param      string  $nodeValue  The node value

     * @return     array   contains [node->type, node->value]

     */
    private function define($nodeValue):array

    {
        $v = substr($nodeValue, 1);
        if (in_array($nodeValue[0], ['"', "'"])) {
            $type = R::isProperlyQuoted($nodeValue) ? T::QUOTED : T::PARTIAL;
            return [$type, $nodeValue];
        }
        if (in_array($nodeValue[0], ['{', '[']))      return $this->onObject($nodeValue);

        if (in_array($nodeValue[0], ['!', '&', '*'])) return $this->onNodeAction($nodeValue);

        switch ($nodeValue[0]) {
            case '#': return [T::COMMENT, ltrim($v)];

            case "-": return $this->onHyphen($nodeValue);

            case '%': return [T::DIRECTIVE, ltrim($v)];

            case '?': return [T::SET_KEY,   empty($v) ? null : new Node(ltrim($v), $this->line)];

            case ':': return [T::SET_VALUE, empty($v) ? null : new Node(ltrim($v), $this->line)];

            case '>': return [T::LITTERAL_FOLDED, null];

            case '|': return [T::LITTERAL, null];

            default:

                return [T::SCALAR, $nodeValue];
        }
    }

    private function onKey($matches):void

    {
        $this->type = T::KEY;
        $this->identifier = trim($matches[1]);
        $keyValue = isset($matches[2]) ? trim($matches[2]) : null;
        if (!empty($keyValue)) {
            $n = new Node($keyValue, $this->line);
            $hasComment = strpos($keyValue, ' #');
            if (!is_bool($hasComment)) {

                $tmpNode = new Node(trim(substr($keyValue, 0, $hasComment)), $this->line);
                if ($tmpNode->type !== T::PARTIAL) {
                    $comment = new Node(trim(substr($keyValue, $hasComment+1)), $this->line);
                    //TODO: modify "identifier" to specify if fullline comment or not
                    $this->add($comment);
                    $n = $tmpNode;
                }
            }
            $n->indent = $this->indent + strlen($this->identifier);
            $this->add($n);
        }
    }

    private function onObject($value):array

    {
        json_decode($value, false, 512, JSON_PARTIAL_OUTPUT_ON_ERROR|JSON_UNESCAPED_SLASHES);
        if (json_last_error() === JSON_ERROR_NONE)  return [T::JSON, $value];

        if (preg_match(R::MAPPING, $value))         return [T::MAPPING_SHORT, $value];

        if (preg_match(R::SEQUENCE, $value))        return [T::SEQUENCE_SHORT, $value];

        return [T::PARTIAL, $value];
    }

    private function onHyphen($nodeValue):array

    {
        if (substr($nodeValue, 0, 3) === '---') {
            $rest = trim(substr($nodeValue, 3));
            if (empty($rest)) return [T::DOC_START, null];

            $n = new Node($rest, $this->line);
            $n->indent = $this->indent + 4;
            return [T::DOC_START, $n->setParent($this)];
        }
        if (preg_match(R::ITEM, $nodeValue, $matches)) {
            if (isset($matches[1]) && !empty(trim($matches[1]))) {
                $n = new Node(trim($matches[1]), $this->line);
                return [T::ITEM, $n->setParent($this)];
            }
            return [T::ITEM, null];
        }
        return [T::SCALAR, $nodeValue];
    }

    private function onNodeAction($nodeValue):array

    {
        // TODO: handle tags like  <tag:clarkevans.com,2002:invoice>
        $v = substr($nodeValue, 1);
        $type = ['!' => T::TAG, '&' => T::REF_DEF, '*' => T::REF_CALL][$nodeValue[0]];
        $pos = strpos($v, ' ');
        $this->identifier = is_bool($pos) ? $v : strstr($v, ' ', true);

        $n = is_bool($pos) ? null : (new Node(trim(substr($nodeValue, $pos+1)), $this->line))->setParent($this);

        return [$type, $n];
    }

    public function getPhpValue()

    {
        $v = $this->value;
        if (is_null($v)) return null;

        switch ($this->type) {
            case T::JSON:   return json_decode($v, false, 512, JSON_PARTIAL_OUTPUT_ON_ERROR);
            case T::JSON:   return json_decode(/** @scrutinizer ignore-type */ $v, false, 512, JSON_PARTIAL_OUTPUT_ON_ERROR);
            case T::QUOTED: return substr($v, 1, -1);
            case T::QUOTED: return substr(/** @scrutinizer ignore-type */ $v, 1, -1);
            case T::RAW:    return strval($v);

            case T::REF_CALL://fall through

            case T::SCALAR: return self::getScalar($v);

            case T::MAPPING_SHORT:  return self::getShortMapping(substr($v, 1, -1));

            //TODO : that's not robust enough, improve it
            case T::SEQUENCE_SHORT:

                $f = function ($e) { return self::getScalar(trim($e));};

                return array_map($f, explode(",", substr($v, 1, -1)));
            default:

                trigger_error("Error can not get PHP type for ".T::getName($this->type), E_USER_WARNING);
                return null;
        }
    }

    private static function getScalar($v)

    {
        $types = ['yes'   => true,
                  'no'    => false,
                  'true'  => true,
                  'false' => false,
                  'null'  => null,
                  '.inf'  => INF,
                  '-.inf' => -INF,
                  '.nan'  => NAN
        ];
        if (in_array(strtolower($v), array_keys($types))) return $types[strtolower($v)];

        if (R::isDate($v))   return date_create($v);

        if (R::isNumber($v)) return self::getNumber($v);

        return strval($v);
    }

    private static function getNumber($v)

    {
        if (preg_match("/^(0o\d+)$/i", $v))      return intval(base_convert($v, 8, 10));

        if (preg_match("/^(0x[\da-f]+)$/i", $v)) return intval(base_convert($v, 16, 10));

        // if preg_match("/^([\d.]+e[-+]\d{1,2})$/", $v)://fall through
        // if preg_match("/^([-+]?(?:\d+|\d*.\d+))$/", $v):
            return is_bool(strpos($v, '.')) ? intval($v) : floatval($v);

    }

    //TODO : that's not robust enough, improve it
    private static function getShortMapping($mappingString):object

    {
        $out = new \StdClass();
        foreach (explode(',', $mappingString) as $value) {
            list($keyName, $keyValue) = explode(':', $value);
            $out->{trim($keyName)} = self::getScalar(trim($keyValue));
        }
        return $out;
    }

    public function __debugInfo():array

    {
        $out = ['line'  => $this->line,
                'indent'=> $this->indent,
                'type'  => T::getName($this->type),
                'value' => $this->value];
        if (!is_null($this->identifier)) $out['type'] .= "($this->identifier)";

        return $out;
    }
}

dallgoot / yaml

Branch — master (f496ba)

Node::define() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like
