Dallgoot\Yaml\Builder

Complexity

Total Complexity

65

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	4	2
A	buildComment()	0	3	1
B	buildDocument()	0	27	8
A	buildItem()	0	10	6
A	buildTag()	0	13	5
B	buildNodeList()	0	24	9
B	buildLitteral()	0	19	9
A	buildDirective()	0	2	1
B	buildContent()	0	20	7
A	buildSetValue()	0	11	3
A	buildNode()	0	24	6
A	buildSetKey()	0	6	2
A	buildKey()	0	13	6

<?php

Missing file doc comment

namespace Dallgoot\Yaml;

use Dallgoot\Yaml\Yaml as Y;

/**
 * Constructs the result (YamlObject or array) according to every Node and respecting value
 * @category tag in class comment

There must be exactly one blank line before the tags in a doc comment

Category name "tag in class comment" is not valid; consider "Tag_In_Class_Comment" instead

 * @package tag in class comment

Package name "tag in class comment" is not valid; consider "Tag_In_Class_Comment" instead

Tag value indented incorrectly; expected 2 spaces but found 1

 * @author tag in class comment

Content of the @author tag must be in the form "Display Name <username@example.com>"

Tag value indented incorrectly; expected 3 spaces but found 1

 * @license tag in class comment

Tag value indented incorrectly; expected 2 spaces but found 1

 */

Missing @link tag in class comment

final class Builder
{
    private static $_root;
    private static $_debug;

    const ERROR_NO_KEYNAME = self::class.": key has NO IDENTIFIER on line %d";
    const INVALID_DOCUMENT = self::class.": DOCUMENT %d can NOT be a mapping AND a sequence";


    private static function build(object $node, &$parent = null)

Missing function doc comment

    {
        if ($node instanceof NodeList) return self::buildNodeList($node, $parent);
        return self::buildNode($node, $parent);
    }

    private static function buildNodeList(NodeList $node, &$parent)

Private method name "Builder::buildNodeList" must be prefixed with an underscore

Missing function doc comment

    {
        if ($node->type & (Y::RAW | Y::LITTERALS)) {
            return self::buildLitteral($node, $node->type);

It seems like $node->type can also be of type null; however, parameter $type of Dallgoot\Yaml\Builder::buildLitteral() does only seem to accept integer, maybe add an additional type check?

        }
        $p = $parent;
        switch ($node->type) {
            case Y::MAPPING: //fall through
            case Y::SET:      $p = new \StdClass; break;

Closing brace must be on a line by itself

            case Y::SEQUENCE: $p = []; break;

Closing brace must be on a line by itself

            // case Y::KEY: $p = $parent;break;
        }
        $out = null;
        foreach ($node as $child) {
            $result = self::build($child, $p);
            if (!is_null($result)) {
                if (is_string($result)) {
                    $out .= $result.' ';
                } else {
                    return $result;
                }
            }
        }
        return is_null($out) ? $p : rtrim($out);
    }

    private static function buildNode(Node $node, &$parent)

Private method name "Builder::buildNode" must be prefixed with an underscore

Missing function doc comment

    {
        extract((array) $node, EXTR_REFS);
        if ($type & (Y::REF_DEF | Y::REF_CALL)) {
            if (is_object($value)) {
                $tmp = self::build($value, $parent) ?? $parent;
            } else {
                $tmp = $node->getPhpValue();
            }
            if ($type === Y::REF_DEF) self::$_root->addReference($identifier, $tmp);
            return self::$_root->getReference($identifier);
        }
        $typesActions = [Y::COMMENT   => 'buildComment',
                         Y::DIRECTIVE => 'buildDirective',
                         Y::ITEM      => 'buildItem',
                         Y::KEY       => 'buildKey',
                         Y::SET_KEY   => 'buildSetKey',
                         Y::SET_VALUE => 'buildSetValue',
                         Y::TAG       => 'buildTag',
        ];
        if (isset($typesActions[$type])) {
            return self::{$typesActions[$type]}($node, $parent);
        }
        return is_object($value) ? self::build($value, $parent) : $node->getPhpValue();
    }

    /**
     * Builds a key and set the property + value to the given parent
     *
     * @param Node $node       The node

Expected 9 spaces after parameter type; 1 found

Expected 3 spaces after parameter name; 7 found

     * @param object|array $parent       The parent

Expected 1 spaces after parameter name; 7 found

     *
     * @throws \ParseError if Key has no name(identifier)
     * @return null
     */
    private static function buildKey(Node $node, &$parent):void

Private method name "Builder::buildKey" must be prefixed with an underscore

    {
        extract((array) $node, EXTR_REFS);
        if (is_null($identifier)) {
            throw new \ParseError(sprintf(self::ERROR_NO_KEYNAME, $line));
        } else {
            if ($value instanceof Node && ($value->type & (Y::KEY|Y::ITEM))) {
                $parent->{$identifier} = $value->type & Y::KEY ? new \StdClass : [];
                self::build($value, $parent->{$identifier});
            } elseif (is_object($value)) {
                $parent->{$identifier} = self::build($value, $parent->{$identifier});
            } else {
                $parent->{$identifier} = $node->getPhpValue();
            }
        }
    }

    private static function buildItem(Node $node, &$parent):void

Private method name "Builder::buildItem" must be prefixed with an underscore

Missing function doc comment

    {
        if (!is_array($parent) && !($parent instanceof \ArrayIterator)) {
            throw new \Exception("parent must be an Iterable not ".(is_object($parent) ? get_class($parent) : gettype($parent)), 1);
        }
        if ($value instanceof Node && $value->type === Y::KEY) {

The variable $value seems to be never defined.

            $parent[$node->value->identifier] = self::build($node->value->value, $parent[$node->value->identifier]);

The property value does not seem to exist on Dallgoot\Yaml\NodeList.

It seems like $node->value->value can also be of type null and string; however, parameter $node of Dallgoot\Yaml\Builder::build() does only seem to accept object, maybe add an additional type check?

The property identifier does not seem to exist on Dallgoot\Yaml\NodeList.

        } else {
            $index = count($parent);
            $parent[$index] = self::build($node->value, $parent[$index]);
        }
    }

    /**
     * Builds a file.  check multiple documents & split if more than one documents
     *
     * @param   Node   $_root      The root node

Expected 1 spaces after parameter type; 3 found

Expected 2 spaces after parameter name; 6 found

Tag value indented incorrectly; expected 1 spaces but found 3

     * @param   int   $_debug      the level of debugging requested

Expected 2 spaces after parameter type; 3 found

Expected 1 spaces after parameter name; 6 found

Tag value indented incorrectly; expected 1 spaces but found 3

     *
     * @return array|YamlObject      list of documents or juste one.
     */
    public static function buildContent(Node $_root, int $_debug)
    {
        self::$_debug = $_debug;
        $totalDocStart = 0;
        $documents = [];
        if ($_root->value instanceof Node) {
            $q = new NodeList;
            $q->push($_root->value);
            return self::buildDocument($q, 0);
        }
        $_root->value->setIteratorMode(NodeList::IT_MODE_DELETE);

The method setIteratorMode() does not exist on null.

        foreach ($_root->value as $child) {
            if ($child->type & Y::DOC_START) $totalDocStart++;
            //if 0 or 1 DOC_START = we are still in first document
            $currentDoc = $totalDocStart > 1 ? $totalDocStart - 1 : 0;
            if (!isset($documents[$currentDoc])) $documents[$currentDoc] = new NodeList();
            $documents[$currentDoc]->push($child);
        }
        $content = array_map([self::class, 'buildDocument'], $documents, array_keys($documents));
        return count($content) === 1 ? $content[0] : $content;
    }

    private static function buildDocument(NodeList $list, int $key):YamlObject

Private method name "Builder::buildDocument" must be prefixed with an underscore

Missing function doc comment

    {
        self::$_root = new YamlObject();
        $childTypes = $list->getTypes();
        $isaMapping  = (bool) (Y::KEY | Y::MAPPING) & $childTypes;
        $isaSequence = (bool) Y::ITEM & $childTypes;
        $isaSet      = (bool) Y::SET_VALUE & $childTypes;
        if ($isaMapping && $isaSequence) {
            throw new \ParseError(sprintf(self::INVALID_DOCUMENT, $key));
        } else {
            switch (true) {

It seems like you are loosely comparing $isaSet of type integer to the boolean true. If you are specifically checking for non-zero, consider using something more explicit like > 0 or !== 0 instead.

It seems like you are loosely comparing $isaSequence of type integer to the boolean true. If you are specifically checking for non-zero, consider using something more explicit like > 0 or !== 0 instead.

                case $isaSequence: $list->type = Y::SEQUENCE;break;

Closing brace must be on a line by itself

                case $isaSet:      $list->type = Y::SET;break;

Closing brace must be on a line by itself

                default:           $list->type = Y::MAPPING;
            }
        }
        $string = '';
        foreach ($list as $child) {
            $result = self::build($child, self::$_root);
            if (is_string($result)) {
                $string .= $result.' ';
            }
        }
        if (!empty($string)) {
            self::$_root->setText(rtrim($string));
        }
        return self::$_root;
    }

    private static function buildLitteral(NodeList $children, int $type):string

Private method name "Builder::buildLitteral" must be prefixed with an underscore

Missing function doc comment

    {
        $lines = [];
        $children->rewind();
        $refIndent = $children->current()->indent;
        foreach ($children as $child) {
            if ($child->value instanceof NodeList) {
                $lines[] = self::buildLitteral($child->value, $type);
            } else {
                $prefix = '';
                if ($type & Y::LITT_FOLDED && ($child->indent > $refIndent || ($child->type & Y::BLANK))) {
                    $prefix = "\n";
                }
                $lines[] = $prefix.$child->value;
            }
        }
        if ($type & Y::RAW)         return implode('',   $lines);
        if ($type & Y::LITT)        return implode("\n", $lines);
        if ($type & Y::LITT_FOLDED) return implode(' ',  $lines);

The function implicitly returns null when the if condition on line 197 is false. This is incompatible with the type-hinted return string. Consider adding a return statement or allowing null as return value.

    }

    private function buildSetKey(Node $node, $parent):void

Private method name "Builder::buildSetKey" must be prefixed with an underscore

Missing function doc comment

    {
        $key = json_encode(self::build($node->value, $parent), JSON_PARTIAL_OUTPUT_ON_ERROR|JSON_UNESCAPED_SLASHES);

It seems like $node->value can also be of type null and string; however, parameter $node of Dallgoot\Yaml\Builder::build() does only seem to accept object, maybe add an additional type check?

        if (empty($key))
        throw new \Exception("Cant serialize complex key: ".var_export($node->value, true), 1);
        $parent->{$key} = null;
    }

    private function buildSetValue(Node $node, $parent):void

Private method name "Builder::buildSetValue" must be prefixed with an underscore

Missing function doc comment

    {
        $prop = array_keys(get_object_vars($parent));
        $key = end($prop);
        if ($node->value->type & (Y::ITEM|Y::MAPPING)) {
            $p = $node->value->type === Y::ITEM ? [] : new \StdClass;
            self::build($node->value, $p);

It seems like $node->value can also be of type null and string; however, parameter $node of Dallgoot\Yaml\Builder::build() does only seem to accept object, maybe add an additional type check?

        } else {
            $p = self::build($node->value, $parent->{$key});
        }
        $parent->{$key} = $p;
    }

    private function buildTag(Node $node, $parent)

Private method name "Builder::buildTag" must be prefixed with an underscore

Missing function doc comment

    {
        if ($parent === self::$_root) {
            $parent->addTag($node->identifier);
            return;
        }
        //TODO: have somewhere a list of common tags and their treatment
        if (in_array($node->identifier, ['!binary', '!str'])) {
            if ($node->value->value instanceof NodeList) $node->value->value->type = Y::RAW;

The property value does not seem to exist on Dallgoot\Yaml\NodeList.

            else $node->value->type = Y::RAW;
        }
        $val = is_null($node->value) ? null : self::build(/** @scrutinizer ignore-type */ $node->value, $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

        return new Tag($node->identifier, $val);
    }

    private function buildComment(Node $node, $parent):void

Private method name "Builder::buildComment" must be prefixed with an underscore

Missing function doc comment

    {
        self::$_root->addComment($node->line, $node->value);
    }

    private function buildDirective($node, $parent)

Private method name "Builder::buildDirective" must be prefixed with an underscore

Missing function doc comment

    {
        # TODO : implement

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

    }
}