Dallgoot\Yaml\NodeFactory

Complexity

Total Complexity

28

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Test Coverage

Coverage

93.88%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	onHyphen()	0	6	3
A	onSpecial()	0	10	4
B	get()	0	22	7
A	onCompact()	0	8	4
A	onSetElement()	0	4	2
A	onQuoted()	0	4	2
A	onNodeAction()	0	10	3
A	onLiteral()	0	7	3

<?php

namespace Dallgoot\Yaml;

use Dallgoot\Yaml\Nodes;
use Dallgoot\Yaml\Regex;
use Dallgoot\Yaml\Nodes\NodeGeneric;

/**
 * Analyzes $nodeString
 * determines the appropriate NodeType
 * constructs it
 * and returns it
 *
 * @author  Stéphane Rebai <stephane.rebai@gmail.com>
 * @license Apache 2.0
 * @link    https://github.com/dallgoot/yaml
 */
final class NodeFactory
{
    private const JSON_OPTIONS = \JSON_PARTIAL_OUTPUT_ON_ERROR|\JSON_UNESCAPED_SLASHES;

    final public static function get($nodeString = null, $line = 0):NodeGeneric
    {
        $trimmed = ltrim($nodeString);
        if ($trimmed === '')                                return new Nodes\Blank($nodeString, $line);
        elseif (substr($trimmed, 0, 3) === '...')           return new Nodes\DocEnd($nodeString, $line);
        elseif ((bool) preg_match(Regex::KEY, $trimmed, $matches)) return new Nodes\Key($nodeString, $line, $matches);
        else {
            $first = $trimmed[0];
            $stringGroups = ['-',         '>|' ,   '"\'',    "#%" ,    "{[" ,       ":?" ,       '*&!'];
            $methodGroups = ['Hyphen','Literal','Quoted','Special','Compact','SetElement','NodeAction'];
            foreach ($stringGroups as $groupIndex => $stringRef) {
                if (is_int(strpos($stringRef, $first))) {
                    $methodName = 'on'.$methodGroups[$groupIndex];
                    try {
                        return self::$methodName($first, $nodeString, $line);
                    } catch (\Throwable $e) {
                        throw new \Exception(" could not create a Node ($methodName) for '$nodeString'", 1, $e);
                    }
                }
            }
        }
        return new Nodes\Scalar($nodeString, $line);
    }

    /**
     * Return the correct Node Object between NodeComment OR NodeDirective
     *
     * @param      string   $nodeString  The node string
     * @param      integer  $line         The line
     *
     * @return     NodeGeneric
     */
    final private static function onSpecial(string $first, string $nodeString, int $line):NodeGeneric
    {
        if ($first === "#") {
            return new Nodes\Comment(ltrim($nodeString), $line);
        } else {
            if (preg_match(Regex::DIRECTIVE_TAG, $nodeString)
                || preg_match(Regex::DIRECTIVE_VERSION, $nodeString)) {
                return new Nodes\Directive(ltrim($nodeString), $line);
            } else {
                throw new \ParseError("Invalid/Unknown Directive", 1);
            }
        }
    }

    /**
     * Set $node type and value when $nodevalue starts with a quote (simple or double)
     *
     * @param string $nodeString The node value
     * @param int    $line       The line
     *
     * @return     NodeGeneric
     */
    final private static function onQuoted(string $first, string $nodeString, int $line):NodeGeneric
    {
        return Regex::isProperlyQuoted(trim($nodeString)) ? new Nodes\Quoted($nodeString, $line)
                                                          : new Nodes\Partial($nodeString, $line);
    }

    /**
     * Set $node type and value when NodeValue starts with a Set characters "?:"
     *
     * @param string $nodeString The node value
     * @param int    $line       The line
     *
     * @return     NodeGeneric
     */
    final private static function onSetElement(string $first, string $nodeString, int $line):NodeGeneric
    {
        return $first === '?' ? new Nodes\SetKey($nodeString, $line)
                              : new Nodes\SetValue($nodeString, $line);
    }

    /**
     * Determines the Node type and value when a compact object/array syntax is found
     *
     * @param string $nodeString The value assumed to start with { or [ or characters
     * @param int    $line       The line
     *
     * @return     NodeGeneric
     */
    final private static function onCompact(string $first, string $nodeString, int $line):NodeGeneric
    {
        json_decode($nodeString, false, 512, self::JSON_OPTIONS);
        if (json_last_error() === \JSON_ERROR_NONE)             return new Nodes\JSON($nodeString, $line);
        elseif ((bool) preg_match(Regex::MAPPING, trim($nodeString)))  return new Nodes\CompactMapping($nodeString, $line);
        elseif ((bool) preg_match(Regex::SEQUENCE, trim($nodeString))) return new Nodes\CompactSequence($nodeString, $line);
        else {
            return new Nodes\Partial($nodeString, $line);
        }
    }

    /**
     * Determines Node type and value when an hyphen "-" is found
     *
     * @param string $nodeString The node string value
     * @param int    $line       The line
     *
     * @return     NodeGeneric
     */
    final private static function onHyphen(string $first, string $nodeString, int $line):NodeGeneric
    {
        if (substr($nodeString, 0, 3) === '---')              return new Nodes\DocStart($nodeString, $line);
        elseif ((bool) preg_match(Regex::ITEM, ltrim($nodeString)))  return new Nodes\Item($nodeString, $line);
        else {
            return new Nodes\Scalar($nodeString, $line);
        }
    }

    /**
     * Sets Node type and value according to $nodeString when one of these characters is found : !,&,*
     *
     * @param string $nodeString The node value
     * @param int    $line       The line
     *
     *@todo replace $action[0] with $first if applicable
     */
    final private static function onNodeAction(string $first, string $nodeString, int $line):NodeGeneric
    {
        if (!((bool) preg_match(Regex::NODE_ACTIONS, trim($nodeString), $matches))) {
            return new Nodes\Scalar($nodeString, $line);
        }
        // $action = trim($matches['action']);//var_dump($matches);
        switch ($first) {
            case '!': return new Nodes\Tag   ($nodeString, $line);
            default :
                return new Nodes\Anchor($nodeString, $line);
            // case '&': return new NodeAnchor($nodeString, $line);
            // case '*': return new NodeAnchor($nodeString, $line);
            // default:
            //     throw new \ParseError("Not a action node !! '$action[0]' on line:$line".gettype($first));
        }
    }

    final private static function onLiteral(string $first, string $nodeString, int $line):NodeGeneric
    {
        switch ($first) {
            case '>': return new Nodes\LiteralFolded($nodeString, $line);
            case '|': return new Nodes\Literal($nodeString, $line);
            default:
                throw new \ParseError("Not a literal node !! '$first' on line:$line");
        }
    }

}