Builder::buildLitteral() - Code Metrics - Inspection of "decomplexification" - dallgoot/yaml - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( f07b2d...569899 )

by stéphane

created 2018-12-18 15:58 UTC

Builder::buildLitteral() B

↳ Parent: Builder

Complexity

Conditions	10
Paths	24

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	25
rs	7.6666
c	0
b	0
f	0
cc	10
nc	24
nop	2

How to fix Complexity

<?php

namespace Dallgoot\Yaml;

use Dallgoot\Yaml\{Yaml as Y, Regex as R};

/**
 * Constructs the result (YamlObject or array) according to every Node and respecting value
 *
 * @author  Stéphane Rebai <[email protected]>
 * @license Apache 2.0
 * @link    TODO : url to specific online doc
 */
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";

    /**
     * Builds a file.  check multiple documents & split if more than one documents
     *
     * @param   Node   $_root      The root node : Node with Node->type === YAML::ROOT
     * @param   int   $_debug      the level of debugging requested
     *
     * @return array|YamlObject      list of documents or just one.
     * @todo  implement splitting on YAML::DOC_END also
     */
    public static function buildContent(Node $_root, int $_debug)

    {
        self::$_debug = $_debug;

        $totalDocStart = 0;
        $documents = [];
        $_root->value instanceof NodeList && $_root->value->setIteratorMode(NodeList::IT_MODE_DELETE);

        foreach ($_root->value as $child) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            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 = [];
        foreach ($documents as $docNum => $list) {
            self::$_root = new YamlObject;
            try {
                $content[] = self::buildNodeList($list, self::$_root);
            } catch (\Exception $e) {
                throw new \ParseError(sprintf(self::INVALID_DOCUMENT, $docNum));

            }
        }
        return count($content) === 1 ? $content[0] : $content;
    }

    /**
     * Generic function to distinguish between Node and NodeList
     *
     * @param Node|NodeList $node   The node.

     * @param mixed         $parent The parent
     *
     * @return mixed  ( description_of_the_return_value )
     */
    private static function build(object $node, &$parent = null)
    {
        if ($node instanceof NodeList) return self::buildNodeList($node, $parent);
        return self::buildNode($node, $parent);
    }

    /**
     * Builds a node list.
     *
     * @param NodeList $node   The node
     * @param mixed    $parent The parent
     *
     * @return mixed    The parent (object|array) or a string representing the NodeList.
     */
    private static function buildNodeList(NodeList $node, &$parent=null)
    {
        $node->forceType();
        if ($node->type & (Y::RAW | Y::LITTERALS)) {
            return self::buildLitteral($node, (int) $node->type);
        }
        $action = function ($child, &$parent, &$out) {
            self::build($child, $out);
        };
        if ($node->type & (Y::COMPACT_MAPPING|Y::MAPPING|Y::SET)) {
            $out = $parent ?? new \StdClass;
        } elseif ($node->type & (Y::COMPACT_SEQUENCE|Y::SEQUENCE)) {
            $out = $parent ?? [];
        } else {
            $out = '';
            $action = function ($child, &$parent, &$out) {
                if ($child->type & (Y::SCALAR|Y::QUOTED)) {
                    if ($parent) {
                        $parent->setText(self::build($child));
                    } else {
                        $out .= self::build($child);
                    }
                }
            };
        }
        foreach ($node as $child) {
            $action($child, $parent, $out);
        }
        if ($node->type & (Y::COMPACT_SEQUENCE|Y::COMPACT_MAPPING)) {
            $out = new Compact($out);
        }
        return is_null($out) ? $parent : $out;
    }

    /**
     * Builds a node.
     *
     * @param Node    $node    The node of any Node->type
     * @param mixed  $parent  The parent
     *
     * @return mixed  The node value as scalar, array or object or null to otherwise.
     */
    private static function buildNode(Node $node, &$parent)
    {
        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 = Node2PHP::get($node);
            }
            if ($type === Y::REF_DEF) self::$_root->addReference($identifier, $tmp);
            return self::$_root->getReference($identifier);
        }
        if ($type & (Y::COMPACT_MAPPING|Y::COMPACT_SEQUENCE)) {
            return self::buildNodeList($node->value, $parent);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }
        if ($type & Y::COMMENT) self::$_root->addComment($node->line, $node->value);
        $typesActions = [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) : Node2PHP::get($node);
    }

    /**
     * Builds a key and set the property + value to the given parent
     *
     * @param Node $node       The node with type YAML::KEY
     * @param object|array $parent       The parent

     *
     * @throws \ParseError if Key has no name(identifier) Note: empty string is allowed
     * @return null
     */
    private static function buildKey(Node $node, &$parent=null)
    {
        extract((array) $node, EXTR_REFS);

        if (is_null($identifier)) {
            throw new \ParseError(sprintf(self::ERROR_NO_KEYNAME, $line));

        } else {
            if ($value instanceof Node) {
                if ($value->type & (Y::ITEM|Y::KEY)) {
                    $value = new NodeList($value);
                } else {
                    $result = self::build($value);
                }
            }
            if ($value instanceof NodeList) {
                $result = self::buildNodeList($value);
            }
            if (is_null($parent)) {
                return $result;
            } else {
                if (is_array($parent)) {
                    $parent[$identifier] = $result;
                } else {
                    $parent->{$identifier} = $result;
                }
            }
        }
    }

    /**
     * Builds an item. Adds the item value to the parent array|Iterator
     *
     * @param      Node        $node    The node with type YAML::ITEM
     * @param      array|\Iterator      $parent  The parent
     *
     * @throws     \Exception  if parent is another type than array or object Iterator
     * @return null
     */
    private static function buildItem(Node $node, &$parent)
    {
        extract((array) $node, EXTR_REFS);

        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);
        }
        $ref = $parent instanceof \ArrayIterator ? $parent->getArrayCopy() : $parent;
        $numKeys = array_filter(array_keys($ref), 'is_int');
        $key = count($numKeys) > 0 ? max($numKeys) + 1 : 0;
        if ($value instanceof Node) {
            if($value->type & Y::KEY) {
                self::buildKey($node->value, $parent);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                return;
            } elseif ($value->type & Y::ITEM) {
                $a = [];
                $result = self::buildItem($value, $a);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            }
        }
        $result = self::build($value);
        $parent[$key] = $result;
    }


    /**
     * Builds a litteral (folded or not) or any NodeList that has YAML::RAW type (like a multiline value)
     *
     * @param      NodeList  $children  The children
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param      integer   $type      The type
     *
     * @return     string    The litteral.
     * @todo : Example 6.1. Indentation Spaces  spaces must be considered as content
     */
    private static function buildLitteral(NodeList $list, int $type):string
    {
        $list->rewind();
        $refIndent = $list->current()->indent;
        //remove trailing blank
        while ($list->top()->type & Y::BLANK) $list->pop();
        $result = '';
        $separator = [ 0 => '', Y::LITT => "\n", Y::LITT_FOLDED => ' '][(int) $type];
        foreach ($list as $child) {
            if ($child->value instanceof NodeList) {
                $result .= self::buildLitteral($child->value, $type).$separator;
            } else {
                $val = $child->type & (Y::SCALAR|Y::BLANK) ? $child->value : substr($child->raw, $refIndent);
                if ($type & Y::LITT_FOLDED && ($child->indent > $refIndent || ($child->type & Y::BLANK))) {
                    if ($result[-1] === $separator)
                        $result[-1] = "\n";
                    if ($result[-1] === "\n")
                        $result .= $val;
                    continue;
                }
                $result .= $val.$separator;
            }
        }
        return rtrim($result);
    }

    /**
     * Builds a set key.
     *
     * @param      Node        $node    The node of type YAML::SET_KEY.
     * @param      object      $parent  The parent
     *
     * @throws     \Exception  if a problem occurs during serialisation (json format) of the key
     */
    private function buildSetKey(Node $node, &$parent)

    {
        $built = is_object($node->value) ? self::build($node->value) : null;
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $stringKey = is_string($built) && Regex::isProperlyQuoted($built) ? trim($built, '\'" '): $built;
        $key = json_encode($stringKey, JSON_PARTIAL_OUTPUT_ON_ERROR|JSON_UNESCAPED_SLASHES);
        if (empty($key)) throw new \Exception("Cant serialize complex key: ".var_export($node->value, true), 1);
        $parent->{trim($key, '\'" ')} = null;
    }

    /**
     * Builds a set value.
     *
     * @param      Node    $node    The node of type YAML::SET_VALUE
     * @param      object  $parent  The parent (the document object or any previous object created through a mapping key)
     */
    private function buildSetValue(Node $node, &$parent)

    {
        $prop = array_keys(get_object_vars($parent));
        $key = end($prop);
        if ($node->value->type & (Y::ITEM|Y::KEY )) {
            $node->value = new NodeList($node->value);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }
        $parent->{$key} = self::build($node->value);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Builds a tag and its value (also built) and encapsulates them in a Tag object.
     *
     * @param      Node    $node    The node of type YAML::TAG
     * @param      mixed  $parent  The parent
     *
     * @return     Tag|null     The tag object of class Dallgoot\Yaml\Tag.
     */
    private static function buildTag(Node $node, &$parent)
    {
        $name = (string) $node->identifier;
        if ($parent === self::$_root && empty($node->value)) {
            $parent->addTag($name);
        } else {
            $target = $node->value;
            if ($node->value instanceof Node) {
                if ($node->value->type & (Y::KEY|Y::ITEM)) {
                    if (is_null($parent)) {
                        $target = new NodeList($node->value);
                    } else {
                        self::build($node->value, $parent);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    }
                }
            }
            //TODO: have somewhere a list of common tags and their treatment
            // if (in_array($node->identifier, ['!binary', '!str'])) {
            //     $target->type = Y::RAW;
            // }
            return new Tag($name, is_object($target) ? self::build($target) : null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
    }

    /**
     * Builds a directive. NOT IMPLEMENTED YET
     *
     * @param      Node  $node    The node
     * @param      mixed  $parent  The parent
     * @todo implement if requested
     */
    private function buildDirective(Node $node, $parent)

    {
        // TODO : implement
    }
}


1			<?php
2
3			namespace Dallgoot\Yaml;
4
5			use Dallgoot\Yaml\{Yaml as Y, Regex as R};
6
7			/**
8			* Constructs the result (YamlObject or array) according to every Node and respecting value
9			*
10			* @author Stéphane Rebai <[email protected]>
11			* @license Apache 2.0
12			* @link TODO : url to specific online doc
13			*/
14			final class Builder
15			{
16			private static $_root;
			0 ignored issues – show Coding Style introduced 2018-12-17 16:40 UTC by Report Bug Copy Issue Report `$_root` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
17			private static $_debug;
			0 ignored issues – show Coding Style introduced 2018-12-17 16:40 UTC by Report Bug Copy Issue Report `$_debug` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
18
19			const ERROR_NO_KEYNAME = self::class.": key has NO IDENTIFIER on line %d";
20			const INVALID_DOCUMENT = self::class.": DOCUMENT %d can NOT be a mapping AND a sequence";
21
22			/**
23			* Builds a file. check multiple documents & split if more than one documents
24			*
25			* @param Node $_root The root node : Node with Node->type === YAML::ROOT
26			* @param int $_debug the level of debugging requested
27			*
28			* @return array\|YamlObject list of documents or just one.
29			* @todo implement splitting on YAML::DOC_END also
30			*/
31			public static function buildContent(Node $_root, int $_debug)
			0 ignored issues – show Coding Style introduced 2018-12-17 16:40 UTC by Report Bug Copy Issue Report `$_root` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
32			{
33			self::$_debug = $_debug;
			0 ignored issues – show Coding Style introduced 2018-12-17 16:40 UTC by Report Bug Copy Issue Report `$_debug` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
34			$totalDocStart = 0;
35			$documents = [];
36			$_root->value instanceof NodeList && $_root->value->setIteratorMode(NodeList::IT_MODE_DELETE);

dallgoot / yaml

Push — master ( f07b2d...569899 )

Builder::buildLitteral() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like