Dallgoot\Yaml\Builder

Complexity

Total Complexity

67

Size/Duplication

Total Lines	214
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	4	2
A	buildItem()	0	10	6
B	litteral()	0	18	7
B	buildDocument()	0	27	8
B	buildContent()	0	20	7
B	buildNodeList()	0	25	9
D	buildNode()	0	53	22
A	buildKey()	0	13	6

<?php

Missing file doc comment

namespace Dallgoot\Yaml;

use Dallgoot\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

    {
        $type = &$node->type;
        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

    {
        extract((array) $node, EXTR_REFS);
        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;

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

                if (is_object($value)) {

Line indented incorrectly; expected 12 spaces, found 16

                    $result = self::build($value, $parent);
                    if (is_null($result)) {

Line indented incorrectly; expected 16 spaces, found 20

                        $tmp = $parent;
                    } else {

Line indented incorrectly; expected 16 spaces, found 20

                        $tmp = $result;
                    }

Line indented incorrectly; expected 16 spaces, found 20

                } else {

Line indented incorrectly; expected 12 spaces, found 16

                    $tmp = $node->getPhpValue();
                }

Line indented incorrectly; expected 12 spaces, found 16

                // $tmp = is_object($value) ? self::build($value, $parent) : $node->getPhpValue();
                if ($type === Y\REF_DEF) self::$_root->addReference($identifier, $tmp);
                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);
                if (empty($key))
                    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 constant Dallgoot\Yaml\Y\RAW was not found. Maybe you did not declare it correctly or list all dependencies?

                        else $value->type = Y\RAW;

Line indented incorrectly; expected 20 spaces, found 24

                    }

Line indented incorrectly; expected 16 spaces, found 20

                    $val = is_null($value) ? null : self::build(/** @scrutinizer ignore-type */ $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($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 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, &$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))) {

The constant Dallgoot\Yaml\Y\ITEM 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)) {
            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) {
            $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]);
        }
    }

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

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

            //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();
        $isMapping  = (Y\KEY | Y\MAPPING) & $childTypes;

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

        $isSequence = Y\ITEM & $childTypes;

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

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

It seems like you are loosely comparing $isSequence 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 $isSet 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 $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?

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

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

Line indented incorrectly; expected 12 spaces, found 16

            }
        }
        $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;
            };
        }
        $tmp = [];
        $children->rewind();
        foreach ($children as $child) {
            $tmp[] = $child->value instanceof NodeList ? self::litteral($child->value, $type) : $action($child);
        }
        return implode($separator, $tmp);
    }
}