Merger::merge() - Code Metrics - davewwww/Aggregator - Measure and Improve Code Quality continuously with Scrutinizer

Merger::merge() D
last analyzed 2016-11-14 12:52 UTC

↳ Parent: Merger

Complexity

Conditions	10
Paths	5

Size

Total Lines	34
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	34
rs	4.8196
c	0
b	0
f	0
cc	10
eloc	25
nc	5
nop	4

How to fix Complexity

<?php

namespace Dwo\Aggregator;

use Dwo\Aggregator\Exception\AggregatorException;
use Dwo\Aggregator\Model\Aggregate;
use Dwo\Aggregator\Model\PreAggregate;

/**
 * Class Merger
 *
 * @author Dave Www <[email protected]>
 */
class Merger
{
    /**
     * merges Aggregate+Aggregate | Aggregate+PreAggregate | PreAggregate+PreAggregate | array()+array()
     *
     * @param mixed       $origin Aggregate|PreAggregate|array
     * @param mixed       $merge  Aggregate|PreAggregate|array
     * @param array       $saveKeys
     * @param string|null $idKey
     */
    public static function merge(&$origin, $merge, array $saveKeys = [], $idKey = null)
    {
        $checkMergeType = function ($a) {
            if ($a instanceof Aggregate) {
                return 16;
            } elseif ($a instanceof PreAggregate) {
                return 4;
            } else {
                if (is_array($a)) {
                    return 1;
                }
            }

            return null;
        };

        $typeOne = $checkMergeType($origin);
        $typeTwo = $checkMergeType($merge);
        $mergeType = $typeOne + $typeTwo;

        if (32 === $mergeType) {
            self::mergePre($origin, $merge, $saveKeys, $idKey);
            self::mergeAgg($origin, $merge);
        } elseif (16 === $typeOne && 4 === $typeTwo) {
            self::mergePre($origin, $merge, $saveKeys, $idKey);
            self::mergePreToAgg($origin, $merge);
        } elseif (4 <= $typeOne && 4 <= $typeTwo) {
            self::mergePre($origin, $merge, $saveKeys, $idKey);
        } elseif (2 === $mergeType) {
            self::mergeArrays($origin, $merge, $saveKeys);
        } else {
            throw new AggregatorException('cant be merged');
        }
    }

    /**
     * @param Aggregate $origin
     * @param Aggregate $merge
     */
    private static function mergeAgg(Aggregate $origin, Aggregate $merge)
    {
        foreach ($merge->getOriginIds() as $id) {
            $origin->addOriginId($id);
        }
    }

    /**
     * @param Aggregate    $origin
     * @param PreAggregate $merge
     */
    private static function mergePreToAgg(Aggregate $origin, PreAggregate $merge)
    {
        if (null !== $id = $merge->getId()) {
            $origin->addOriginId($id);
        }
    }

    /**
     * @param PreAggregate $origin
     * @param PreAggregate $merge
     * @param array        $saveKeys
     * @param string|null  $idKey
     */
    private static function mergePre(PreAggregate $origin, PreAggregate $merge, array $saveKeys = [], $idKey = null)
    {
        $originData = $origin->getData();
        $data = $merge->getData();
        if (null !== $idKey) {
            unset($data[$idKey]);
        }

        self::mergeArrays($originData, $data, $saveKeys);

        $origin->setData($originData);
        $origin->incrementCount($merge->getCount());
    }

    /**
     * @param array $dataOrigin
     * @param array $data
     * @param array $saveKeys
     */
    private static function mergeArrays(array &$dataOrigin, array $data, array $saveKeys = [])
    {
        foreach ($data as $key => $value) {
            if (!isset($dataOrigin[$key])) {
                $dataOrigin[$key] = null;
            }

            $mergeable = !in_array($key, $saveKeys);
            $operation = isset($saveKeys[$key]);

            switch (true) {
                case is_numeric($value) && $mergeable && !$operation:
                    $dataOrigin[$key] += $value;
                    break;

                case is_array($value) && $mergeable && !$operation:
                    if (null === $dataOrigin[$key]) {
                        $dataOrigin[$key] = [];
                    }
                    self::mergeArrays($dataOrigin[$key], $value);
                    break;

                case $mergeable && $operation:
                    if (null === $dataOrigin[$key]) {
                        $dataOrigin[$key] = [];
                    } elseif (!is_array($dataOrigin[$key])) {
                        $dataOrigin[$key] = array($dataOrigin[$key]);
                    }
                    if (is_array($value)) {
                        $dataOrigin[$key] = array_merge($dataOrigin[$key], $value);
                    } else {
                        $dataOrigin[$key][] = $value;
                    }
                    break;

                default:
                    if (null === $dataOrigin[$key]) {
                        $dataOrigin[$key] = $value;
                    }
                    break;
            }
        }
    }
}

1			<?php
2
3			namespace Dwo\Aggregator;
4
5			use Dwo\Aggregator\Exception\AggregatorException;
6			use Dwo\Aggregator\Model\Aggregate;
7			use Dwo\Aggregator\Model\PreAggregate;
8
9			/**
10			* Class Merger
11			*
12			* @author Dave Www <[email protected]>
13			*/
14			class Merger
15			{
16			/**
17			* merges Aggregate+Aggregate \| Aggregate+PreAggregate \| PreAggregate+PreAggregate \| array()+array()
18			*
19			* @param mixed $origin Aggregate\|PreAggregate\|array
20			* @param mixed $merge Aggregate\|PreAggregate\|array
21			* @param array $saveKeys
22			* @param string\|null $idKey
23			*/
24			public static function merge(&$origin, $merge, array $saveKeys = [], $idKey = null)
25			{
26			$checkMergeType = function ($a) {
27			if ($a instanceof Aggregate) {
28			return 16;
29			} elseif ($a instanceof PreAggregate) {
30			return 4;
31			} else {
32			if (is_array($a)) {
33			return 1;
34			}
35			}
36
37			return null;
38			};
39
40			$typeOne = $checkMergeType($origin);
41			$typeTwo = $checkMergeType($merge);
42			$mergeType = $typeOne + $typeTwo;
43
44			if (32 === $mergeType) {
45			self::mergePre($origin, $merge, $saveKeys, $idKey);
46			self::mergeAgg($origin, $merge);
47			} elseif (16 === $typeOne && 4 === $typeTwo) {
48			self::mergePre($origin, $merge, $saveKeys, $idKey);
49			self::mergePreToAgg($origin, $merge);
50			} elseif (4 <= $typeOne && 4 <= $typeTwo) {
51			self::mergePre($origin, $merge, $saveKeys, $idKey);
52			} elseif (2 === $mergeType) {
53			self::mergeArrays($origin, $merge, $saveKeys);
54			} else {
55			throw new AggregatorException('cant be merged');
56			}
57			}
58
59			/**
60			* @param Aggregate $origin
61			* @param Aggregate $merge
62			*/
63			private static function mergeAgg(Aggregate $origin, Aggregate $merge)
64			{
65			foreach ($merge->getOriginIds() as $id) {
66			$origin->addOriginId($id);
67			}
68			}
69
70			/**
71			* @param Aggregate $origin
72			* @param PreAggregate $merge
73			*/
74			private static function mergePreToAgg(Aggregate $origin, PreAggregate $merge)
75			{
76			if (null !== $id = $merge->getId()) {
77			$origin->addOriginId($id);
78			}
79			}
80
81			/**
82			* @param PreAggregate $origin
83			* @param PreAggregate $merge
84			* @param array $saveKeys
85			* @param string\|null $idKey
86			*/
87			private static function mergePre(PreAggregate $origin, PreAggregate $merge, array $saveKeys = [], $idKey = null)
88			{
89			$originData = $origin->getData();
90			$data = $merge->getData();
91			if (null !== $idKey) {
92			unset($data[$idKey]);
93			}
94
95			self::mergeArrays($originData, $data, $saveKeys);
96
97			$origin->setData($originData);
98			$origin->incrementCount($merge->getCount());
99			}
100
101			/**
102			* @param array $dataOrigin
103			* @param array $data
104			* @param array $saveKeys
105			*/
106			private static function mergeArrays(array &$dataOrigin, array $data, array $saveKeys = [])
107			{
108			foreach ($data as $key => $value) {
109			if (!isset($dataOrigin[$key])) {
110			$dataOrigin[$key] = null;
111			}
112
113			$mergeable = !in_array($key, $saveKeys);
114			$operation = isset($saveKeys[$key]);
115
116			switch (true) {
117			case is_numeric($value) && $mergeable && !$operation:
118			$dataOrigin[$key] += $value;
119			break;
120
121			case is_array($value) && $mergeable && !$operation:
122			if (null === $dataOrigin[$key]) {
123			$dataOrigin[$key] = [];
124			}
125			self::mergeArrays($dataOrigin[$key], $value);
126			break;
127
128			case $mergeable && $operation:
129			if (null === $dataOrigin[$key]) {
130			$dataOrigin[$key] = [];
131			} elseif (!is_array($dataOrigin[$key])) {
132			$dataOrigin[$key] = array($dataOrigin[$key]);
133			}
134			if (is_array($value)) {
135			$dataOrigin[$key] = array_merge($dataOrigin[$key], $value);
136			} else {
137			$dataOrigin[$key][] = $value;
138			}
139			break;
140
141			default:
142			if (null === $dataOrigin[$key]) {
143			$dataOrigin[$key] = $value;
144			}
145			break;
146			}
147			}
148			}
149			}

davewwww / Aggregator

Merger::merge() D last analyzed 2016-11-14 12:52 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Merger::merge() D
last analyzed 2016-11-14 12:52 UTC