dallgoot / yaml

Node.php

<?php
namespace Dallgoot\Yaml;

Missing file doc comment

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

class Node

Missing class doc comment

{
    /** @var int */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

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

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

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

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

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

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

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

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

    public $value;

    /** @var null|Node */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

    private $parent;

Private member variable "parent" must be prefixed with an underscore

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

Missing function doc comment

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

    public function setParent(Node $node):Node

Missing function doc comment

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

    public function getParent($indent = null):Node

Missing function doc comment

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

Inline control structures are discouraged

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

The expression return $cursor could return the type null which is incompatible with the type-hinted return Dallgoot\Yaml\Node. Consider adding an additional type-check to rule them out.

    }

    public function add(Node $child):void

Missing function doc comment

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

Inline control structures are discouraged

        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);

The method push() does not exist on Dallgoot\Yaml\Node.

The method push() does not exist on null.

        //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;

The property type does not seem to exist on SplDoublyLinkedList.

Line indented incorrectly; expected 12 spaces, found 16

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 12 spaces, found 16

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 12 spaces, found 16

Closing brace must be on a line by itself

            }
        }
    }

    public function getDeepestNode():Node

Missing function doc comment

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

    /**

Parameter $nodeString should have a doc-comment as per coding-style.

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

Missing @return tag in function comment

    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

Expected 1 spaces after parameter type; 2 found

Expected 1 spaces after parameter name; 2 found

Tag value indented incorrectly; expected 2 spaces but found 6

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

Tag cannot be grouped with parameter tags in a doc comment

Tag value indented incorrectly; expected 1 spaces but found 5

     */
    private function define($nodeValue):array

Private method name "Node::define" must be prefixed with an underscore

    {
        $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);

Inline control structures are discouraged

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

Inline control structures are discouraged

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            default:

Line indented incorrectly; expected 8 spaces, found 12

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

    private function onKey($matches):void

Missing function doc comment

Private method name "Node::onKey" must be prefixed with an underscore

    {
        $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)) {

The condition is_bool($hasComment) is always false.

                $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

Missing function doc comment

Private method name "Node::onObject" must be prefixed with an underscore

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

Inline control structures are discouraged

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

Inline control structures are discouraged

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

Inline control structures are discouraged

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

    private function onHyphen($nodeValue):array

Missing function doc comment

Private method name "Node::onHyphen" must be prefixed with an underscore

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

Inline control structures are discouraged

            $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

Missing function doc comment

Private method name "Node::onNodeAction" must be prefixed with an underscore

    {
        // 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);

The condition is_bool($pos) is always false.

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

The condition is_bool($pos) is always false.

        return [$type, $n];
    }

    public function getPhpValue()

Missing function doc comment

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

Inline control structures are discouraged

        switch ($this->type) {
            case T::JSON:   return json_decode($v, false, 512, JSON_PARTIAL_OUTPUT_ON_ERROR);

It seems like $v can also be of type SplDoublyLinkedList and Dallgoot\Yaml\Node; however, parameter $json of json_decode() does only seem to accept string, maybe add an additional type check?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case T::QUOTED: return substr($v, 1, -1);

It seems like $v can also be of type SplDoublyLinkedList and Dallgoot\Yaml\Node; however, parameter $string of substr() does only seem to accept string, maybe add an additional type check?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case T::RAW:    return strval($v);

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case T::REF_CALL://fall through

Line indented incorrectly; expected 8 spaces, found 12

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

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

Opening brace must be the last content on the line

Closing brace must be on a line by itself

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

Line indented incorrectly; expected 8 spaces, found 12

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

    private static function getScalar($v)

Missing function doc comment

Private method name "Node::getScalar" must be prefixed with an underscore

    {
        $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)];

Inline control structures are discouraged

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

Inline control structures are discouraged

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

Inline control structures are discouraged

        return strval($v);
    }

    private static function getNumber($v)

Missing function doc comment

Private method name "Node::getNumber" must be prefixed with an underscore

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

Inline control structures are discouraged

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

Inline control structures are discouraged

        // 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);

The condition is_bool(strpos($v, '.')) is always false.

    }

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

You must use "/**" style comments for a function comment

Private method name "Node::getShortMapping" must be prefixed with an underscore

    {
        $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

Missing function doc comment

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

Inline control structures are discouraged

        return $out;
    }
}