Dallgoot\Yaml\Builder

Complexity

Total Complexity

69

Size/Duplication

Total Lines	215
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	4	2
A	buildItem()	0	10	6
A	litteral()	0	18	6
B	buildDocument()	0	29	9
B	buildContent()	0	21	7
B	buildNodeList()	0	25	10
D	buildNode()	0	43	21
A	getChildrenTypes()	0	7	2
A	buildKey()	0	13	6

<?php

Missing file doc comment

namespace Dallgoot\Yaml;

use Dallgoot\Yaml as Y;

/**

Doc comment is empty

 *
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

Missing @license tag in class comment

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)

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

Missing function doc comment

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

Inline control structures are discouraged

        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

    {
        $type = property_exists($node, "type") ? $node->type : null;
        if ($type & (Y\RAW | Y\LITTERALS)) {

The constant Dallgoot\Yaml\Y\RAW was not found. Maybe you did not declare it correctly or list all dependencies?

            return self::litteral($node, $type);
        }
        $p = $parent;
        switch ($type) {
            case Y\MAPPING: //fall through

The constant Dallgoot\Yaml\Y\MAPPING was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

            case Y\SET:      $p = new \StdClass;break;

The constant Dallgoot\Yaml\Y\SET was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

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

The constant Dallgoot\Yaml\Y\SEQUENCE was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

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

    {
        list($line, $type, $value, $identifier) = [$node->line, $node->type, $node->value, $node->identifier];
        switch ($type) {
            case Y\COMMENT: self::$_root->addComment($line, $value);return;

The constant Dallgoot\Yaml\Y\COMMENT was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case Y\DIRECTIVE: return;//TODO

The constant Dallgoot\Yaml\Y\DIRECTIVE was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case Y\ITEM: self::buildItem($value, $parent);return;

The constant Dallgoot\Yaml\Y\ITEM was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case Y\KEY:  self::buildKey($node, $parent);return;

The constant Dallgoot\Yaml\Y\KEY was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

Closing brace must be on a line by itself

            case Y\REF_DEF: //fall through

The constant Dallgoot\Yaml\Y\REF_DEF was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

            case Y\REF_CALL://TODO: self::build returns what ?

The constant Dallgoot\Yaml\Y\REF_CALL was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

                $tmp = is_object($value) ? self::build($value, $parent) : $node->getPhpValue();
                if ($type === Y\REF_DEF) self::$_root->addReference($identifier, $tmp);

Inline control structures are discouraged

                return self::$_root->getReference($identifier);
            case Y\SET_KEY:

The constant Dallgoot\Yaml\Y\SET_KEY was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

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

It seems like $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))

Inline control structures are discouraged

                    throw new \Exception("Cant serialize complex key: ".var_export($value, true), 1);
                $parent->{$key} = null;
                return;
            case Y\SET_VALUE:

The constant Dallgoot\Yaml\Y\SET_VALUE was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

                $prop = array_keys(get_object_vars($parent));
                $key = end($prop);
                if (property_exists($value, "type") && ($value->type & (Y\ITEM | Y\MAPPING))) {

The constant Dallgoot\Yaml\Y\MAPPING was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 12 spaces, found 16

                    $p = $value->type === Y\ITEM  ? [] : new \StdClass;
                    self::build($value, $p);
                } else {

Line indented incorrectly; expected 12 spaces, found 16

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

Line indented incorrectly; expected 12 spaces, found 16

                $parent->{$key} = $p;
                return;
            case Y\TAG:

The constant Dallgoot\Yaml\Y\TAG was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 8 spaces, found 12

                if ($parent === self::$_root) {

Line indented incorrectly; expected 12 spaces, found 16

                    $parent->addTag($identifier);return;
                } else {//TODO: have somewhere a list of common tags and their treatment

Line indented incorrectly; expected 12 spaces, found 16

                    if (in_array($identifier, ['!binary', '!str'])) {

Line indented incorrectly; expected 16 spaces, found 20

                        if ($value->value instanceof NodeList) $value->value->type = Y\RAW;

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

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

The constant Dallgoot\Yaml\Y\RAW was not found. Maybe you did not declare it correctly or list all dependencies?

Inline control structures are discouraged

                        else $value->type = Y\RAW;

Inline control structures are discouraged

Line indented incorrectly; expected 20 spaces, found 24

                    }

Line indented incorrectly; expected 16 spaces, found 20

                    $val = is_null($value) ? null : self::build($value, $node);

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

                    return new Tag($identifier, $val);
                }

Line indented incorrectly; expected 12 spaces, found 16

            default:

Line indented incorrectly; expected 8 spaces, found 12

                return is_object($value) ? self::build($value, $parent) : $node->getPhpValue();
        }
    }

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

Expected 9 spaces after parameter type; 1 found

     * @param object|array $parent   The parent

Expected 1 spaces after parameter name; 3 found

     *
     * @throws \ParseError if Key has no name(identifier)
     */

Missing @return tag in function comment

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

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

    {
        list($identifier, $value) = [$node->identifier, $node->value];
        if (is_null($identifier)) {
            throw new \ParseError(sprintf(self::ERROR_NO_KEYNAME, $node->line));
        } else {
            if ($value instanceof Node && ($value->type & (Y\KEY | Y\ITEM))) {

The constant Dallgoot\Yaml\Y\ITEM was not found. Maybe you did not declare it correctly or list all dependencies?

The constant Dallgoot\Yaml\Y\KEY was not found. Maybe you did not declare it correctly or list all dependencies?

                $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($value, &$parent):void

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

Missing function doc comment

    {
        if(!is_array($parent) && !($parent instanceof \ArrayIterator)) {

Expected "if (...) {\n"; found "if(...) {\n"

            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 constant Dallgoot\Yaml\Y\KEY was not found. Maybe you did not declare it correctly or list all dependencies?

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

It seems like $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?

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

    /**

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

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

Expected 1 spaces after parameter name; 3 found

     * @param int $debug   the level of debugging requested

Expected 2 spaces after parameter type; 1 found

Doc comment for parameter $debug does not match actual variable name $_debug

Expected 1 spaces after parameter name; 3 found

     *
     * @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++;

The constant Dallgoot\Yaml\Y\DOC_START was not found. Maybe you did not declare it correctly or list all dependencies?

Inline control structures are discouraged

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

Inline control structures are discouraged

            $documents[$currentDoc]->push($child);
        }
        // $_debug >= 2 && var_dump($documents);//var_dump($documents);die("documents");
        $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 = self::getChildrenTypes($list);
        $isMapping  = count(array_intersect($childTypes, [Y\KEY, Y\MAPPING])) > 0;

The constant Dallgoot\Yaml\Y\KEY was not found. Maybe you did not declare it correctly or list all dependencies?

The constant Dallgoot\Yaml\Y\MAPPING was not found. Maybe you did not declare it correctly or list all dependencies?

        $isSequence = in_array(Y\ITEM, $childTypes);

The constant Dallgoot\Yaml\Y\ITEM was not found. Maybe you did not declare it correctly or list all dependencies?

        $isSet      = in_array(Y\SET_VALUE, $childTypes);

The constant Dallgoot\Yaml\Y\SET_VALUE was not found. Maybe you did not declare it correctly or list all dependencies?

        if ($isMapping && $isSequence) {
            throw new \ParseError(sprintf(self::INVALID_DOCUMENT, $key));
        } else {
            switch (true) {
                case $isSequence: $list->type = Y\SEQUENCE;break;

The constant Dallgoot\Yaml\Y\SEQUENCE was not found. Maybe you did not declare it correctly or list all dependencies?

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

Line indented incorrectly; expected 12 spaces, found 16

Closing brace must be on a line by itself

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

The constant Dallgoot\Yaml\Y\SET was not found. Maybe you did not declare it correctly or list all dependencies?

Line indented incorrectly; expected 12 spaces, found 16

Closing brace must be on a line by itself

                case $isMapping://fall through

Line indented incorrectly; expected 12 spaces, found 16

                default:          $list->type = Y\MAPPING;

Line indented incorrectly; expected 12 spaces, found 16

            }
        }
        // self::$_debug >= 3 && var_dump(self::$_root, $list);
        $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 litteral(NodeList $children, $type):string

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

Missing function doc comment

    {
        $children->rewind();
        $refIndent = $children->current()->indent;
        $separator = $type === Y\RAW ? '' : "\n";

The constant Dallgoot\Yaml\Y\RAW was not found. Maybe you did not declare it correctly or list all dependencies?

        $action = function ($c) { return $c->value; };

Opening brace must be the last content on the line

Closing brace must be on a line by itself

        if ($type & Y\LITT_FOLDED) {

The constant Dallgoot\Yaml\Y\LITT_FOLDED was not found. Maybe you did not declare it correctly or list all dependencies?

            $separator = ' ';
            $action = function ($c) use ($refIndent) {
                return $c->indent > $refIndent || ($c->type & Y\BLANK) ? "\n".$c->value : $c->value;

The constant Dallgoot\Yaml\Y\BLANK was not found. Maybe you did not declare it correctly or list all dependencies?

            };
        }
        $tmp = [];
        $children->rewind();
        foreach ($children as $child) {
            $tmp[] = $action($child);
        }
        return implode($separator, $tmp);
    }

    private static function getChildrenTypes(NodeList $children):array

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

Missing function doc comment

    {
        $types = [];
        foreach ($children as $child) {
            $types[] = $child->type;
        }
        return array_unique($types);
    }
}