Document::createVectorNodeFromUnsafeArray() - Code Metrics - Inspection of "Extract node factory logic to separate classes" - DaveRandom/JOM - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 37810d...c6a7a1 )

by Chris

created 2018-05-29 15:36 UTC

Document::createVectorNodeFromUnsafeArray() A

↳ Parent: Document

Complexity

Conditions	4
Paths	6

Size

Total Lines	15
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
dl	0
loc	15
ccs	0
cts	13
cp	0
rs	9.2
c	0
b	0
f	0
cc	4
eloc	9
nc	6
nop	2
crap	20

<?php declare(strict_types=1);

namespace DaveRandom\Jom;

use DaveRandom\Jom\Exceptions\DocumentTreeCreationFailedException;
use DaveRandom\Jom\Exceptions\InvalidNodeValueException;
use DaveRandom\Jom\Exceptions\InvalidPointerException;
use DaveRandom\Jom\Exceptions\InvalidSubjectNodeException;
use DaveRandom\Jom\Exceptions\ParseFailureException;
use DaveRandom\Jom\Exceptions\PointerReferenceNotFoundException;
use DaveRandom\Jom\Exceptions\WriteOperationForbiddenException;
use ExceptionalJSON\DecodeErrorException;

final class Document implements \JsonSerializable
{
    /** @var Node */
    private $rootNode;

    private static function getSafeNodeFactory(): SafeNodeFactory
    {
        static $factory;
        return $factory ?? $factory = new SafeNodeFactory();
    }

    private static function getUnsafeNodeFactory(): UnsafeNodeFactory
    {
        static $factory;
        return $factory ?? $factory = new UnsafeNodeFactory();
    }

    /**
     * @throws PointerReferenceNotFoundException
     */
    private function evaluatePointerPath(Pointer $pointer, Node $current): Node
    {
        foreach ($pointer->getPath() as $component) {
            if (!($current instanceof VectorNode)) {
                throw new PointerReferenceNotFoundException(
                    "Pointer '{$pointer}' does not indicate a valid path in the document"
                );
            }

            if (!$current->offsetExists($component)) {
                throw new PointerReferenceNotFoundException("The referenced property or index '{$component}' does not exist");
            }

            $current = $current->offsetGet($component);
        }

        return $current;
    }

    /**
     * @throws PointerReferenceNotFoundException
     * @throws InvalidSubjectNodeException
     */
    private function evaluateRelativePointer(Pointer $pointer, Node $current): Node
    {
        if ($current->getOwnerDocument() !== $this) {
            throw new InvalidSubjectNodeException('Base node belongs to a different document');
        }

        for ($i = $pointer->getRelativeLevels(); $i > 0; $i--) {
            $current = $current->getParent();

            if ($current === null) {
                throw new PointerReferenceNotFoundException(
                    "Pointer '{$pointer}' does not indicate a valid path in the document relative to the supplied node"
                );
            }
        }

        return $this->evaluatePointerPath($pointer, $current);
    }

    /**
     * @throws InvalidNodeValueException
     * @throws InvalidSubjectNodeException
     * @throws WriteOperationForbiddenException
     */
    private function importVectorNode(VectorNode $node): VectorNode
    {
        if (!($node instanceof ArrayNode || $node instanceof ObjectNode)) {
            throw new InvalidSubjectNodeException('Source node is of unknown type ' . \get_class($node));
        }

        $newNode = new $node($this);

        foreach ($node as $key => $value) {
            $newNode[$key] = $this->import($value);
        }

        return $newNode;
    }

    /**
     * @throws InvalidSubjectNodeException
     */
    private function importScalarNode(Node $node): Node
    {
        if (!($node instanceof BooleanNode || $node instanceof NumberNode || $node instanceof StringNode)) {
            throw new InvalidSubjectNodeException('Source node is of unknown type ' . \get_class($node));
        }

        return new $node($this, $node->getValue());
    }

    /**
     * @throws DocumentTreeCreationFailedException
     * @throws ParseFailureException
     */
    public static function parse(string $json, int $depthLimit = 512, int $options = 0): Document
    {
        try {
            $data = \ExceptionalJSON\decode($json, false, $depthLimit, $options & ~\JSON_OBJECT_AS_ARRAY);

            $doc = new self();
            $doc->rootNode = self::getSafeNodeFactory()->createNodeFromValue($doc, $data);

            return $doc;
        } catch (DecodeErrorException $e) {
            throw new ParseFailureException("Decoding JSON string failed: {$e->getMessage()}", $e);
        } catch (InvalidNodeValueException $e) {
            throw new DocumentTreeCreationFailedException("Creating document tree failed: {$e->getMessage()}", $e);
        } catch (\Throwable $e) {
            throw new DocumentTreeCreationFailedException("Unexpected error: {$e->getMessage()}", $e);
        }
    }

    /**
     * @throws DocumentTreeCreationFailedException
     */
    public static function createFromData($data): Document
    {
        try {
            $doc = new self();
            $doc->rootNode = self::getUnsafeNodeFactory()->createNodeFromValue($doc, $data);

            return $doc;
        } catch (InvalidNodeValueException $e) {
            throw new DocumentTreeCreationFailedException("Creating document tree failed: {$e->getMessage()}", $e);
        } catch (\Throwable $e) {
            throw new DocumentTreeCreationFailedException("Unexpected error: {$e->getMessage()}", $e);
        }
    }

    public function getRootNode(): ?Node
    {
        return $this->rootNode;
    }

    /**
     * @throws InvalidSubjectNodeException
     * @throws WriteOperationForbiddenException
     * @throws InvalidNodeValueException
     * @throws InvalidSubjectNodeException
     */
    public function import(Node $node): Node
    {
        if ($node->getOwnerDocument() === $this) {
            throw new InvalidSubjectNodeException('Cannot import tne supplied node, already owned by this document');
        }

        if ($node instanceof NullNode) {
            return new NullNode($this);
        }

        return $node instanceof VectorNode
            ? $this->importVectorNode($node)
            : $this->importScalarNode($node);
    }

    /**
     * @param Pointer|string $pointer
     * @return Node|int|string
     * @throws InvalidPointerException
     * @throws PointerReferenceNotFoundException
     * @throws InvalidSubjectNodeException
     */
    public function evaluatePointer($pointer, Node $base = null)
    {
        if (!($pointer instanceof Pointer)) {
            $pointer = Pointer::createFromString((string)$pointer);
        }

        if (!$pointer->isRelative()) {
            return $this->evaluatePointerPath($pointer, $this->rootNode);
        }

        $target = $this->evaluateRelativePointer($pointer, $base ?? $this->rootNode);

        return $pointer->isKeyLookup()
            ? $target->getKey()
            : $target;
    }

    public function jsonSerialize()
    {
        return $this->rootNode !== null
            ? $this->rootNode->jsonSerialize()
            : null;
    }
}


1			<?php declare(strict_types=1);
2
3			namespace DaveRandom\Jom;
4
5			use DaveRandom\Jom\Exceptions\DocumentTreeCreationFailedException;
6			use DaveRandom\Jom\Exceptions\InvalidNodeValueException;
7			use DaveRandom\Jom\Exceptions\InvalidPointerException;
8			use DaveRandom\Jom\Exceptions\InvalidSubjectNodeException;
9			use DaveRandom\Jom\Exceptions\ParseFailureException;
10			use DaveRandom\Jom\Exceptions\PointerReferenceNotFoundException;
11			use DaveRandom\Jom\Exceptions\WriteOperationForbiddenException;
12			use ExceptionalJSON\DecodeErrorException;
13
14			final class Document implements \JsonSerializable
15			{
16			/** @var Node */
17			private $rootNode;
18
19			private static function getSafeNodeFactory(): SafeNodeFactory
20			{
21			static $factory;
22			return $factory ?? $factory = new SafeNodeFactory();
23			}
24
25			private static function getUnsafeNodeFactory(): UnsafeNodeFactory
26			{
27			static $factory;
28			return $factory ?? $factory = new UnsafeNodeFactory();
29			}
30
31			/**
32			* @throws PointerReferenceNotFoundException
33			*/
34			private function evaluatePointerPath(Pointer $pointer, Node $current): Node
35			{
36			foreach ($pointer->getPath() as $component) {
37			if (!($current instanceof VectorNode)) {
38			throw new PointerReferenceNotFoundException(
39			"Pointer '{$pointer}' does not indicate a valid path in the document"
40			);
41			}
42
43			if (!$current->offsetExists($component)) {
44			throw new PointerReferenceNotFoundException("The referenced property or index '{$component}' does not exist");
45			}
46
47			$current = $current->offsetGet($component);
48			}
49
50			return $current;
51			}
52
53			/**
54			* @throws PointerReferenceNotFoundException
55			* @throws InvalidSubjectNodeException
56			*/
57			private function evaluateRelativePointer(Pointer $pointer, Node $current): Node
58			{
59			if ($current->getOwnerDocument() !== $this) {
60			throw new InvalidSubjectNodeException('Base node belongs to a different document');
61			}
62
63			for ($i = $pointer->getRelativeLevels(); $i > 0; $i--) {
64			$current = $current->getParent();
65
66			if ($current === null) {
67			throw new PointerReferenceNotFoundException(
68			"Pointer '{$pointer}' does not indicate a valid path in the document relative to the supplied node"
69			);
70			}
71			}
72
73			return $this->evaluatePointerPath($pointer, $current);
74			}
75
76			/**
77			* @throws InvalidNodeValueException
78			* @throws InvalidSubjectNodeException
79			* @throws WriteOperationForbiddenException
80			*/
81			private function importVectorNode(VectorNode $node): VectorNode
82			{
83			if (!($node instanceof ArrayNode \|\| $node instanceof ObjectNode)) {
84			throw new InvalidSubjectNodeException('Source node is of unknown type ' . \get_class($node));
85			}
86
87			$newNode = new $node($this);
88
89			foreach ($node as $key => $value) {
90			$newNode[$key] = $this->import($value);
91			}
92
93			return $newNode;
94			}
95
96			/**
97			* @throws InvalidSubjectNodeException
98			*/
99			private function importScalarNode(Node $node): Node
100			{
101			if (!($node instanceof BooleanNode \|\| $node instanceof NumberNode \|\| $node instanceof StringNode)) {
102			throw new InvalidSubjectNodeException('Source node is of unknown type ' . \get_class($node));
103			}
104
105			return new $node($this, $node->getValue());
106			}
107
108			/**
109			* @throws DocumentTreeCreationFailedException
110			* @throws ParseFailureException
111			*/
112			public static function parse(string $json, int $depthLimit = 512, int $options = 0): Document
113			{
114			try {
115			$data = \ExceptionalJSON\decode($json, false, $depthLimit, $options & ~\JSON_OBJECT_AS_ARRAY);
116
117			$doc = new self();
118			$doc->rootNode = self::getSafeNodeFactory()->createNodeFromValue($doc, $data);
119
120			return $doc;
121			} catch (DecodeErrorException $e) {
122			throw new ParseFailureException("Decoding JSON string failed: {$e->getMessage()}", $e);
123			} catch (InvalidNodeValueException $e) {
124			throw new DocumentTreeCreationFailedException("Creating document tree failed: {$e->getMessage()}", $e);
125			} catch (\Throwable $e) {
126			throw new DocumentTreeCreationFailedException("Unexpected error: {$e->getMessage()}", $e);
127			}
128			}
129
130			/**
131			* @throws DocumentTreeCreationFailedException
132			*/
133			public static function createFromData($data): Document
134			{
135			try {
136			$doc = new self();
137			$doc->rootNode = self::getUnsafeNodeFactory()->createNodeFromValue($doc, $data);
138
139			return $doc;
140			} catch (InvalidNodeValueException $e) {
141			throw new DocumentTreeCreationFailedException("Creating document tree failed: {$e->getMessage()}", $e);
142			} catch (\Throwable $e) {
143			throw new DocumentTreeCreationFailedException("Unexpected error: {$e->getMessage()}", $e);
144			}
145			}
146
147			public function getRootNode(): ?Node
148			{
149			return $this->rootNode;
150			}
151
152			/**
153			* @throws InvalidSubjectNodeException
154			* @throws WriteOperationForbiddenException
155			* @throws InvalidNodeValueException
156			* @throws InvalidSubjectNodeException
157			*/
158			public function import(Node $node): Node
159			{
160			if ($node->getOwnerDocument() === $this) {
161			throw new InvalidSubjectNodeException('Cannot import tne supplied node, already owned by this document');
162			}
163
164			if ($node instanceof NullNode) {
165			return new NullNode($this);
166			}
167
168			return $node instanceof VectorNode
169			? $this->importVectorNode($node)
170			: $this->importScalarNode($node);
171			}
172
173			/**
174			* @param Pointer\|string $pointer
175			* @return Node\|int\|string
176			* @throws InvalidPointerException
177			* @throws PointerReferenceNotFoundException
178			* @throws InvalidSubjectNodeException
179			*/
180			public function evaluatePointer($pointer, Node $base = null)
181			{
182			if (!($pointer instanceof Pointer)) {
183			$pointer = Pointer::createFromString((string)$pointer);
184			}
185
186			if (!$pointer->isRelative()) {
187			return $this->evaluatePointerPath($pointer, $this->rootNode);
188			}
189
190			$target = $this->evaluateRelativePointer($pointer, $base ?? $this->rootNode);
191
192			return $pointer->isKeyLookup()
193			? $target->getKey()
194			: $target;
195			}
196
197			public function jsonSerialize()
198			{
199			return $this->rootNode !== null
200			? $this->rootNode->jsonSerialize()
201			: null;
202			}
203			}
204

DaveRandom / JOM

Push — master ( 37810d...c6a7a1 )

Document::createVectorNodeFromUnsafeArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like