Representer::property() - Code Metrics - iJackUA/einfach-representer - Measure and Improve Code Quality continuously with Scrutinizer

Representer::property() A
last analyzed 2016-02-10 18:24 UTC

↳ 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	1
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			*
56			* @return null \| string
57			*/
58	2		public function collectionWrapper()
59			{
60	2		return null;
61			}
62
63	5		public function setTargetClassName($name)
64			{
65	5		$this->targetClassName = $name;
66	5		}
67
68			/**
69			* @param $name
70			* @return PropertyRule
71			*/
72	10		public function property($name)
73			{
74	10		return new PropertyRule($this->source, $name);
75			}
76
77			/**
78			* Represent one instance
79			*
80			* @param $source
81			* @return static
82			*/
83	8		public static function one($source)
84			{
85	8		return new static($source, 1);
86			}
87
88			/**
89			* Represent collection of instances
90			*
91			* @param array $array
92			* @return static
93			*/
94	4		public static function collection(array $array)
95			{
96	4		return new static($array, 2);
97			}
98
99	4		protected function getCollectionRepresentation()
100			{
101	4		if (is_array($this->source) && count($this->source) > 0) {
102			$representation = array_map(function ($object) {
103	4		return static::one($object)->getOneRepresentation();
104	4		}, $this->source);
105
106	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...
107	2		return [$wrapperName => $representation];
108			} else {
109	2		return $representation;
110			}
111			}
112			}
113
114	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...
115			{
116	8		$rules = $this->rules();
117	8		if (empty($rules)) {
118			throw new \Exception("There are rules specified in " . static::class . " representer");
119			}
120
121	8		$represented = [];
122
123	8		foreach ($rules as $rule) {
124			/** @var $rule PropertyRule */
125	8		$resultArray = $rule->compile();
126
127	8		reset($resultArray);
128	8		$key = key($resultArray);
129	8		$value = $resultArray[$key];
130
131	8		$represented[$key] = $value;
132	8		}
133
134	8		return $represented;
135			}
136
137	8		protected function getRepresentation()
138			{
139	8		switch ($this->strategy) {
140	8		case 1:
141	4		return $this->getOneRepresentation();
142	4		case 2:
143	4		return $this->getCollectionRepresentation();
144			default:
145			throw new \Exception('Wrong representation strategy selected. Maybe you have accidentally
146			called `toJSON` instead of `fromJSON`?');
147			}
148
149			}
150
151
152			/**
153			* @param $className
154			* @return static
155			*/
156	5		public static function restore($className)
157			{
158	5		$instance = new static(null, 3);
159	5		$instance->setTargetClassName($className);
160	5		return $instance;
161			}
162
163			/**
164			* @param string $className
165			* @return static
166			*/
167	2		public static function restoreCollection($className)
168			{
169	2		$instance = new static(null, 4);
170	2		$instance->setTargetClassName($className);
171	2		return $instance;
172			}
173
174	5		protected function getReverseRepresentation($projection)
175			{
176	5		switch ($this->strategy) {
177	5		case 3:
178	3		return $this->getOneReverseRepresentation($projection);
179	2		case 4:
180	2		return $this->getCollectionReverseRepresentation($projection);
181			default:
182			throw new \Exception('Reverse representation strategy not defined');
183			}
184
185			}
186
187	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...
188			{
189	5		$rules = $this->rules();
190	5		if (empty($rules)) {
191			throw new \Exception("There are rules specified in " . static::class . " representer");
192			}
193
194	5		$target = new $this->targetClassName();
195
196	5		foreach ($rules as $rule) {
197			/** @var $rule PropertyRule */
198	5		$resultArray = $rule->reverseCompile($projection);
199	5		reset($resultArray);
200	5		$key = key($resultArray);
201	5		$value = $resultArray[$key];
202
203	5		$target->$key = $value;
204	5		}
205
206	5		return $target;
207			}
208
209	2		protected function getCollectionReverseRepresentation($projectionArray)
210			{
211	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...
212	1		if (!isset($projectionArray[$wrapperName])) {
213			$siblingKeys = join(',', array_keys($projectionArray));
214			throw new \Exception("Collection wrapper `{$wrapperName}` not found during restore
215			(instead following keys found: {$siblingKeys} ). In " . static::class . " representer");
216			}
217	1		$projectionArray = $projectionArray[$wrapperName];
218	1		}
219
220	2		if (is_array($projectionArray) && count($projectionArray) > 0) {
221	2		return array_map(function ($projection) {
222	2		return static::restore($this->targetClassName)->getOneReverseRepresentation($projection);
223	2		}, $projectionArray);
224			}
225			}
226			}
227

iJackUA / einfach-representer

Representer::property() A last analyzed 2016-02-10 18:24 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Representer::property() A
last analyzed 2016-02-10 18:24 UTC