Representer::collectionWrapper() - Code Metrics - Inspection of "add basic collection wrapping" - iJackUA/einfach-representer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2625d3...593253 )

by Ievgen

created 2016-01-28 11:45 UTC

Representer::collectionWrapper() A

↳ Parent: Representer

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php
namespace einfach\representer;

use einfach\representer\serializer\ArraySerializer;

/**
 * Trait Representer
 *
 * @package einfach\representer
 */
trait Representer
{
    use ArraySerializer;

    /**
     * Object that is being represented
     * or a collection handler
     */
    protected $source;
    /**
     * Class name to be restored
     *
     * @var string
     */
    protected $targetClassName;
    /**
     * Strategy indicator
     * 1 = one
     * 2 = collection
     * 3 = restore one
     * 4 = restore collection
     *
     * @var string
     */
    protected $strategy;

    public function __construct($source, $strategy)
    {
        if (is_null($strategy)) {
            throw new \Exception('Representer can not be initialized without a strategy param');
        }

        $this->source = $source;
        $this->strategy = $strategy;
    }

    public function rules()
    {
        return [];
    }

    /**
     * Return property name to wrap a collection representation
     * If `null` - no wrapper added
     * @return null | string
     */
    public function collectionWrapper()
    {
        return null;
    }

    public function setTargetClassName($name)
    {
        $this->targetClassName = $name;
    }

    /**
     * @param $name
     * @return PropertyRule
     */
    public function property($name)
    {
        return new PropertyRule($this->source, $name);
    }

    /**
     * Represent one instance
     *
     * @param $source
     * @return static
     */
    public static function one($source)
    {
        return new static($source, 1);
    }

    /**
     * Represent collection of instances
     *
     * @param array $array
     * @return static
     */
    public static function collection(array $array)
    {
        return new static($array, 2);
    }

    protected function getCollectionRepresentation()
    {
        if (is_array($this->source) && count($this->source) > 0) {
            $representation = array_map(function ($object) {
                return static::one($object)->getOneRepresentation();
            }, $this->source);

            if ($wrapperName = $this->collectionWrapper()) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                return [$wrapperName => $representation];
            } else {
                return $representation;
            }
        }
    }

    protected function getOneRepresentation()

    {
        $rules = $this->rules();
        if (empty($rules)) {
            throw new \Exception("There are rules specified in " . static::class . " representer");
        }

        $represented = [];

        foreach ($rules as $rule) {
            /** @var $rule PropertyRule */
            $resultArray = $rule->compile();

            reset($resultArray);
            $key = key($resultArray);
            $value = $resultArray[$key];

            $represented[$key] = $value;
        }

        return $represented;
    }

    protected function getRepresentation()
    {
        switch ($this->strategy) {
            case 1:
                return $this->getOneRepresentation();
            case 2:
                return $this->getCollectionRepresentation();
            default:
                throw new \Exception('Wrong representation strategy selected. Maybe you have accidentally called `toJSON` instead of `fromJSON`?');
        }

    }


    /**
     * @param $className
     * @return static
     */
    public static function restore($className)
    {
        $instance = new static(null, 3);
        $instance->setTargetClassName($className);
        return $instance;
    }

    /**
     * @param string $className
     * @return static
     */
    public static function restoreCollection($className)
    {
        $instance = new static(null, 4);
        $instance->setTargetClassName($className);
        return $instance;
    }

    protected function getReverseRepresentation($projection)
    {
        switch ($this->strategy) {
            case 3:
                return $this->getOneReverseRepresentation($projection);
            case 4:
                return $this->getCollectionReverseRepresentation($projection);
            default:
                throw new \Exception('Reverse representation strategy not defined');
        }

    }

    protected function getOneReverseRepresentation($projection)

    {
        $rules = $this->rules();
        if (empty($rules)) {
            throw new \Exception("There are rules specified in " . static::class . " representer");
        }

        $target = new $this->targetClassName();

        foreach ($rules as $rule) {
            /** @var $rule PropertyRule */
            $resultArray = $rule->reverseCompile($projection);

            reset($resultArray);
            $key = key($resultArray);
            $value = $resultArray[$key];

            $target->$key = $value;
        }

        return $target;
    }

    protected function getCollectionReverseRepresentation($projectionArray)
    {
        if ($wrapperName = $this->collectionWrapper()) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
            if (!isset($projectionArray[$wrapperName])) {
                $siblingKeys = join(',', array_keys($projectionArray));
                throw new \Exception("Collection wrapper `{$wrapperName}` not found during restore (instead following keys found: {$siblingKeys} ). In " . static::class . " representer");
            }
            $projectionArray = $projectionArray[$wrapperName];
        }

        if (is_array($projectionArray) && count($projectionArray) > 0) {
            return array_map(function ($projection) {
                return static::restore($this->targetClassName)->getOneReverseRepresentation($projection);
            }, $projectionArray);
        }
    }
}


1			<?php
2			namespace einfach\representer;
3
4			use einfach\representer\serializer\ArraySerializer;
5
6			/**
7			* Trait Representer
8			*
9			* @package einfach\representer
10			*/
11			trait Representer
12			{
13			use ArraySerializer;
14
15			/**
16			* Object that is being represented
17			* or a collection handler
18			*/
19			protected $source;
20			/**
21			* Class name to be restored
22			*
23			* @var string
24			*/
25			protected $targetClassName;
26			/**
27			* Strategy indicator
28			* 1 = one
29			* 2 = collection
30			* 3 = restore one
31			* 4 = restore collection
32			*
33			* @var string
34			*/
35			protected $strategy;
36
37	10		public function __construct($source, $strategy)
38			{
39	10		if (is_null($strategy)) {
40			throw new \Exception('Representer can not be initialized without a strategy param');
41			}
42
43	10		$this->source = $source;
44	10		$this->strategy = $strategy;
45	10		}
46
47			public function rules()
48			{
49			return [];
50			}
51
52			/**
53			* Return property name to wrap a collection representation
54			* If `null` - no wrapper added
55			* @return null \| string
56			*/
57	2		public function collectionWrapper()
58			{
59	2		return null;
60			}
61
62	5		public function setTargetClassName($name)
63			{
64	5		$this->targetClassName = $name;
65	5		}
66
67			/**
68			* @param $name
69			* @return PropertyRule
70			*/
71	10		public function property($name)
72			{
73	10		return new PropertyRule($this->source, $name);
74			}
75
76			/**
77			* Represent one instance
78			*
79			* @param $source
80			* @return static
81			*/
82	8		public static function one($source)
83			{
84	8		return new static($source, 1);
85			}
86
87			/**
88			* Represent collection of instances
89			*
90			* @param array $array
91			* @return static
92			*/
93	4		public static function collection(array $array)
94			{
95	4		return new static($array, 2);
96			}
97
98	4		protected function getCollectionRepresentation()
99			{
100	4		if (is_array($this->source) && count($this->source) > 0) {
101			$representation = array_map(function ($object) {
102	4		return static::one($object)->getOneRepresentation();
103	4		}, $this->source);
104
105	4		if ($wrapperName = $this->collectionWrapper()) {
			0 ignored issues – show Bug introduced 2016-01-28 11:49 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$wrapperName` is correct as `$this->collectionWrapper()` (which targets `einfach\representer\Repr...er::collectionWrapper()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
106	2		return [$wrapperName => $representation];
107			} else {
108	2		return $representation;
109			}
110			}
111			}
112
113	8	View Code Duplication	protected function getOneRepresentation()
			0 ignored issues – show Duplication introduced 2016-01-18 21:06 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
114			{
115	8		$rules = $this->rules();
116	8		if (empty($rules)) {
117			throw new \Exception("There are rules specified in " . static::class . " representer");
118			}
119
120	8		$represented = [];
121
122	8		foreach ($rules as $rule) {
123			/** @var $rule PropertyRule */
124	8		$resultArray = $rule->compile();
125
126	8		reset($resultArray);
127	8		$key = key($resultArray);
128	8		$value = $resultArray[$key];
129
130	8		$represented[$key] = $value;
131	8		}
132
133	8		return $represented;
134			}
135
136	8		protected function getRepresentation()
137			{
138	8		switch ($this->strategy) {
139	8		case 1:
140	4		return $this->getOneRepresentation();
141	4		case 2:
142	4		return $this->getCollectionRepresentation();
143			default:
144			throw new \Exception('Wrong representation strategy selected. Maybe you have accidentally called `toJSON` instead of `fromJSON`?');
145			}
146
147			}
148
149
150			/**
151			* @param $className
152			* @return static
153			*/
154	5		public static function restore($className)
155			{
156	5		$instance = new static(null, 3);
157	5		$instance->setTargetClassName($className);
158	5		return $instance;
159			}
160
161			/**
162			* @param string $className
163			* @return static
164			*/
165	2		public static function restoreCollection($className)
166			{
167	2		$instance = new static(null, 4);
168	2		$instance->setTargetClassName($className);
169	2		return $instance;
170			}
171
172	5		protected function getReverseRepresentation($projection)
173			{
174	5		switch ($this->strategy) {
175	5		case 3:
176	3		return $this->getOneReverseRepresentation($projection);
177	2		case 4:
178	2		return $this->getCollectionReverseRepresentation($projection);
179			default:
180			throw new \Exception('Reverse representation strategy not defined');
181			}
182
183			}
184
185	5	View Code Duplication	protected function getOneReverseRepresentation($projection)
			0 ignored issues – show Duplication introduced 2016-01-18 21:06 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
186			{
187	5		$rules = $this->rules();
188	5		if (empty($rules)) {
189			throw new \Exception("There are rules specified in " . static::class . " representer");
190			}
191
192	5		$target = new $this->targetClassName();
193
194	5		foreach ($rules as $rule) {
195			/** @var $rule PropertyRule */
196	5		$resultArray = $rule->reverseCompile($projection);
197
198	5		reset($resultArray);
199	5		$key = key($resultArray);
200	5		$value = $resultArray[$key];
201
202	5		$target->$key = $value;
203	5		}
204
205	5		return $target;
206			}
207
208	2		protected function getCollectionReverseRepresentation($projectionArray)
209			{
210	2		if ($wrapperName = $this->collectionWrapper()) {
			0 ignored issues – show Bug introduced 2016-01-28 11:49 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$wrapperName` is correct as `$this->collectionWrapper()` (which targets `einfach\representer\Repr...er::collectionWrapper()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
211	1		if (!isset($projectionArray[$wrapperName])) {
212			$siblingKeys = join(',', array_keys($projectionArray));
213			throw new \Exception("Collection wrapper `{$wrapperName}` not found during restore (instead following keys found: {$siblingKeys} ). In " . static::class . " representer");
214			}
215	1		$projectionArray = $projectionArray[$wrapperName];
216	1		}
217
218	2		if (is_array($projectionArray) && count($projectionArray) > 0) {
219	2		return array_map(function ($projection) {
220	2		return static::restore($this->targetClassName)->getOneReverseRepresentation($projection);
221	2		}, $projectionArray);
222			}
223			}
224			}
225

iJackUA / einfach-representer

Push — master ( 2625d3...593253 )

Representer::collectionWrapper() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like