JsonDiff::getRearranged() - Code Metrics - Inspection of "performance optimization" - swaggest/json-diff - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b0bc1b...c71b41 )

by Viacheslav

created 2018-01-16 09:56 UTC

JsonDiff::getRearranged() A

↳ Parent: JsonDiff

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

namespace Swaggest\JsonDiff;

class JsonDiff
{
    const SKIP_REARRANGE_ARRAY = 1;
    const STOP_ON_DIFF = 2;

    private $options = 0;
    private $original;
    private $new;

    private $added;
    private $addedCnt = 0;
    private $addedPaths = array();

    private $removed;
    private $removedCnt = 0;
    private $removedPaths = array();

    private $modifiedOriginal;
    private $modifiedNew;
    private $modifiedCnt = 0;
    private $modifiedPaths = array();

    private $path = '#';

    private $rearranged;

    /**
     * Processor constructor.
     * @param $original
     * @param $new
     * @param int $options
     */
    public function __construct($original, $new, $options = 0)
    {
        $this->original = $original;
        $this->new = $new;
        $this->options = $options;

        $this->rearranged = $this->rearrange();
    }

    /**
     * Returns total number of differences
     * @return int
     */
    public function getDiffCnt()
    {
        return $this->addedCnt + $this->modifiedCnt + $this->removedCnt;
    }

    /**
     * Returns removals as partial value of original.
     * @return mixed
     */
    public function getRemoved()
    {
        return $this->removed;
    }

    /**
     * Returns list of `JSON` paths that were removed from original.
     * @return array
     */
    public function getRemovedPaths()
    {
        return $this->removedPaths;
    }

    /**
     * Returns number of removals.
     * @return int
     */
    public function getRemovedCnt()
    {
        return $this->removedCnt;
    }

    /**
     * Returns additions as partial value of new.
     * @return mixed
     */
    public function getAdded()
    {
        return $this->added;
    }

    /**
     * Returns number of additions.
     * @return int
     */
    public function getAddedCnt()
    {
        return $this->addedCnt;
    }

    /**
     * Returns list of `JSON` paths that were added to new.
     * @return array
     */
    public function getAddedPaths()
    {
        return $this->addedPaths;
    }

    /**
     * Returns changes as partial value of original.
     * @return mixed
     */
    public function getModifiedOriginal()
    {
        return $this->modifiedOriginal;
    }

    /**
     * Returns changes as partial value of new.
     * @return mixed
     */
    public function getModifiedNew()
    {
        return $this->modifiedNew;
    }

    /**
     * Returns number of changes.
     * @return int
     */
    public function getModifiedCnt()
    {
        return $this->modifiedCnt;
    }

    /**
     * Returns list of `JSON` paths that were changed from original to new.
     * @return array
     */
    public function getModifiedPaths()
    {
        return $this->modifiedPaths;
    }

    /**
     * Returns new value, rearranged with original order.
     * @return array|object
     */
    public function getRearranged()
    {
        return $this->rearranged;
    }

    private function rearrange()
    {
        return $this->process($this->original, $this->new);
    }

    private function process($original, $new)
    {
        if (
            (!$original instanceof \stdClass && !is_array($original))
            || (!$new instanceof \stdClass && !is_array($new))
        ) {
            if ($original !== $new) {
                $this->modifiedCnt++;
                $this->modifiedPaths [] = $this->path;
                JsonProcessor::pushByPath($this->modifiedOriginal, $this->path, $original);
                JsonProcessor::pushByPath($this->modifiedNew, $this->path, $new);
                if ($this->options & self::STOP_ON_DIFF) {
                    return;
                }
            }
            return $new;
        }

        if (
            !($this->options & self::SKIP_REARRANGE_ARRAY)
            && is_array($original) && is_array($new)
        ) {
            $new = $this->rearrangeArray($original, $new);
        }

        $newArray = $new instanceof \stdClass ? get_object_vars($new) : $new;
        $newOrdered = array();

        $originalKeys = $original instanceof \stdClass ? get_object_vars($original) : $original;

        foreach ($originalKeys as $key => $originalValue) {
            $path = $this->path;
            $this->path .= '/' . urlencode($key);

            if (array_key_exists($key, $newArray)) {
                $newOrdered[$key] = $this->process($originalValue, $newArray[$key]);
                unset($newArray[$key]);
            } else {
                $this->removedCnt++;
                $this->removedPaths [] = $this->path;
                JsonProcessor::pushByPath($this->removed, $this->path, $originalValue);
                if ($this->options & self::STOP_ON_DIFF) {
                    return;
                }
            }
            $this->path = $path;
        }

        // additions
        foreach ($newArray as $key => $value) {
            $newOrdered[$key] = $value;
            $path = $this->path . '/' . urlencode($key);
            JsonProcessor::pushByPath($this->added, $path, $value);
            $this->addedCnt++;
            $this->addedPaths [] = $path;
            if ($this->options & self::STOP_ON_DIFF) {
                return;
            }
        }

        return is_array($new) ? $newOrdered : (object)$newOrdered;
    }

    private function rearrangeArray(array $original, array $new)
    {
        $first = reset($original);
        if (!$first instanceof \stdClass) {
            return $new;
        }

        $uniqueKey = false;
        $uniqueIdx = array();

        // find unique key for all items
        $f = get_object_vars($first);
        foreach ($f as $key => $value) {
            if (is_array($value) || $value instanceof \stdClass) {
                continue;
            }

            $keyIsUnique = true;
            $uniqueIdx = array();
            foreach ($original as $item) {
                if (!$item instanceof \stdClass) {
                    return $new;
                }
                if (!isset($item->$key)) {
                    $keyIsUnique = false;
                    break;
                }
                $value = $item->$key;
                if ($value instanceof \stdClass || is_array($value)) {
                    $keyIsUnique = false;
                    break;
                }

                if (isset($uniqueIdx[$value])) {
                    $keyIsUnique = false;
                    break;
                }
                $uniqueIdx[$value] = true;
            }

            if ($keyIsUnique) {
                $uniqueKey = $key;
                break;
            }
        }

        if ($uniqueKey) {
            $newIdx = array();
            foreach ($new as $item) {
                if (!$item instanceof \stdClass) {
                    return $new;
                }

                if (!property_exists($item, $uniqueKey)) {
                    return $new;
                }

                $value = $item->$uniqueKey;

                if ($value instanceof \stdClass || is_array($value)) {
                    return $new;
                }

                if (isset($newIdx[$value])) {
                    return $new;
                }

                $newIdx[$value] = $item;
            }

            $newRearranged = array();
            foreach ($uniqueIdx as $key => $item) {
                if (isset($newIdx[$key])) {
                    $newRearranged [] = $newIdx[$key];
                    unset($newIdx[$key]);
                }
            }
            foreach ($newIdx as $item) {
                $newRearranged [] = $item;
            }
            return $newRearranged;
        }

        return $new;
    }
}

1			<?php
2
3			namespace Swaggest\JsonDiff;
4
5			class JsonDiff
6			{
7			const SKIP_REARRANGE_ARRAY = 1;
8			const STOP_ON_DIFF = 2;
9
10			private $options = 0;
11			private $original;
12			private $new;
13
14			private $added;
15			private $addedCnt = 0;
16			private $addedPaths = array();
17
18			private $removed;
19			private $removedCnt = 0;
20			private $removedPaths = array();
21
22			private $modifiedOriginal;
23			private $modifiedNew;
24			private $modifiedCnt = 0;
25			private $modifiedPaths = array();
26
27			private $path = '#';
28
29			private $rearranged;
30
31			/**
32			* Processor constructor.
33			* @param $original
34			* @param $new
35			* @param int $options
36			*/
37			public function __construct($original, $new, $options = 0)
38			{
39			$this->original = $original;
40			$this->new = $new;
41			$this->options = $options;
42
43			$this->rearranged = $this->rearrange();
44			}
45
46			/**
47			* Returns total number of differences
48			* @return int
49			*/
50			public function getDiffCnt()
51			{
52			return $this->addedCnt + $this->modifiedCnt + $this->removedCnt;
53			}
54
55			/**
56			* Returns removals as partial value of original.
57			* @return mixed
58			*/
59			public function getRemoved()
60			{
61			return $this->removed;
62			}
63
64			/**
65			* Returns list of `JSON` paths that were removed from original.
66			* @return array
67			*/
68			public function getRemovedPaths()
69			{
70			return $this->removedPaths;
71			}
72
73			/**
74			* Returns number of removals.
75			* @return int
76			*/
77			public function getRemovedCnt()
78			{
79			return $this->removedCnt;
80			}
81
82			/**
83			* Returns additions as partial value of new.
84			* @return mixed
85			*/
86			public function getAdded()
87			{
88			return $this->added;
89			}
90
91			/**
92			* Returns number of additions.
93			* @return int
94			*/
95			public function getAddedCnt()
96			{
97			return $this->addedCnt;
98			}
99
100			/**
101			* Returns list of `JSON` paths that were added to new.
102			* @return array
103			*/
104			public function getAddedPaths()
105			{
106			return $this->addedPaths;
107			}
108
109			/**
110			* Returns changes as partial value of original.
111			* @return mixed
112			*/
113			public function getModifiedOriginal()
114			{
115			return $this->modifiedOriginal;
116			}
117
118			/**
119			* Returns changes as partial value of new.
120			* @return mixed
121			*/
122			public function getModifiedNew()
123			{
124			return $this->modifiedNew;
125			}
126
127			/**
128			* Returns number of changes.
129			* @return int
130			*/
131			public function getModifiedCnt()
132			{
133			return $this->modifiedCnt;
134			}
135
136			/**
137			* Returns list of `JSON` paths that were changed from original to new.
138			* @return array
139			*/
140			public function getModifiedPaths()
141			{
142			return $this->modifiedPaths;
143			}
144
145			/**
146			* Returns new value, rearranged with original order.
147			* @return array\|object
148			*/
149			public function getRearranged()
150			{
151			return $this->rearranged;
152			}
153
154			private function rearrange()
155			{
156			return $this->process($this->original, $this->new);
157			}
158
159			private function process($original, $new)
160			{
161			if (
162			(!$original instanceof \stdClass && !is_array($original))
163			\|\| (!$new instanceof \stdClass && !is_array($new))
164			) {
165			if ($original !== $new) {
166			$this->modifiedCnt++;
167			$this->modifiedPaths [] = $this->path;
168			JsonProcessor::pushByPath($this->modifiedOriginal, $this->path, $original);
169			JsonProcessor::pushByPath($this->modifiedNew, $this->path, $new);
170			if ($this->options & self::STOP_ON_DIFF) {
171			return;
172			}
173			}
174			return $new;
175			}
176
177			if (
178			!($this->options & self::SKIP_REARRANGE_ARRAY)
179			&& is_array($original) && is_array($new)
180			) {
181			$new = $this->rearrangeArray($original, $new);
182			}
183
184			$newArray = $new instanceof \stdClass ? get_object_vars($new) : $new;
185			$newOrdered = array();
186
187			$originalKeys = $original instanceof \stdClass ? get_object_vars($original) : $original;
188
189			foreach ($originalKeys as $key => $originalValue) {
190			$path = $this->path;
191			$this->path .= '/' . urlencode($key);
192
193			if (array_key_exists($key, $newArray)) {
194			$newOrdered[$key] = $this->process($originalValue, $newArray[$key]);
195			unset($newArray[$key]);
196			} else {
197			$this->removedCnt++;
198			$this->removedPaths [] = $this->path;
199			JsonProcessor::pushByPath($this->removed, $this->path, $originalValue);
200			if ($this->options & self::STOP_ON_DIFF) {
201			return;
202			}
203			}
204			$this->path = $path;
205			}
206
207			// additions
208			foreach ($newArray as $key => $value) {
209			$newOrdered[$key] = $value;
210			$path = $this->path . '/' . urlencode($key);
211			JsonProcessor::pushByPath($this->added, $path, $value);
212			$this->addedCnt++;
213			$this->addedPaths [] = $path;
214			if ($this->options & self::STOP_ON_DIFF) {
215			return;
216			}
217			}
218
219			return is_array($new) ? $newOrdered : (object)$newOrdered;
220			}
221
222			private function rearrangeArray(array $original, array $new)
223			{
224			$first = reset($original);
225			if (!$first instanceof \stdClass) {
226			return $new;
227			}
228
229			$uniqueKey = false;
230			$uniqueIdx = array();
231
232			// find unique key for all items
233			$f = get_object_vars($first);
234			foreach ($f as $key => $value) {
235			if (is_array($value) \|\| $value instanceof \stdClass) {
236			continue;
237			}
238
239			$keyIsUnique = true;
240			$uniqueIdx = array();
241			foreach ($original as $item) {
242			if (!$item instanceof \stdClass) {
243			return $new;
244			}
245			if (!isset($item->$key)) {
246			$keyIsUnique = false;
247			break;
248			}
249			$value = $item->$key;
250			if ($value instanceof \stdClass \|\| is_array($value)) {
251			$keyIsUnique = false;
252			break;
253			}
254
255			if (isset($uniqueIdx[$value])) {
256			$keyIsUnique = false;
257			break;
258			}
259			$uniqueIdx[$value] = true;
260			}
261
262			if ($keyIsUnique) {
263			$uniqueKey = $key;
264			break;
265			}
266			}
267
268			if ($uniqueKey) {
269			$newIdx = array();
270			foreach ($new as $item) {
271			if (!$item instanceof \stdClass) {
272			return $new;
273			}
274
275			if (!property_exists($item, $uniqueKey)) {
276			return $new;
277			}
278
279			$value = $item->$uniqueKey;
280
281			if ($value instanceof \stdClass \|\| is_array($value)) {
282			return $new;
283			}
284
285			if (isset($newIdx[$value])) {
286			return $new;
287			}
288
289			$newIdx[$value] = $item;
290			}
291
292			$newRearranged = array();
293			foreach ($uniqueIdx as $key => $item) {
294			if (isset($newIdx[$key])) {
295			$newRearranged [] = $newIdx[$key];
296			unset($newIdx[$key]);
297			}
298			}
299			foreach ($newIdx as $item) {
300			$newRearranged [] = $item;
301			}
302			return $newRearranged;
303			}
304
305			return $new;
306			}
307			}

swaggest / json-diff

Push — master ( b0bc1b...c71b41 )

JsonDiff::getRearranged() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like