Representer::getReverseRepresentation() - Code Metrics - Inspection of "add deserialization from Yaml and JSON" - iJackUA/einfach-representer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 18d699...ab33d5 )

by Ievgen

created 2016-01-18 21:03 UTC

Representer::getReverseRepresentation() A

↳ Parent: Representer

Complexity

Conditions	3
Paths	3

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	4.5435

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	12
ccs	4
cts	9
cp	0.4444
rs	9.4285
cc	3
eloc	8
nc	3
nop	1
crap	4.5435

<?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 = null, $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 [];
    }

    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
     */
    public static function collection(array $array)

    {
        //TBD
    }

    protected function getCollectionRepresentation()
    {
        //TBD
        return ['collection', 'tbd'];
    }

    protected function getOneRepresentation()

    {
        $rules = $this->rules();
        $represented = [];

        if (!empty($rules)) {
            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('Representation strategy not defined');
        }

    }


    /**
     * @param $className
     * @return static
     */
    public static function restore($className)
    {
        $instance = new static(null, 3);
        $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();
        $target = new $this->targetClassName();

        if (!empty($rules)) {
            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($projection)

    {
        //TBD
    }
}


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	6		public function __construct($source = null, $strategy)
38			{
39	6		if (is_null($strategy)) {
40			throw new \Exception('Representer can not be initialized without a strategy param');
41			}
42
43	6		$this->source = $source;
44	6		$this->strategy = $strategy;
45	6		}
46
47			public function rules()
48			{
49			return [];
50			}
51
52	3		public function setTargetClassName($name)
53			{
54	3		$this->targetClassName = $name;
55	3		}
56
57			/**
58			* @param $name
59			* @return PropertyRule
60			*/
61	6		public function property($name)
62			{
63	6		return new PropertyRule($this->source, $name);
64			}
65
66			/**
67			* Represent one instance
68			*
69			* @param $source
70			* @return static
71			*/
72	4		public static function one($source)
73			{
74	4		return new static($source, 1);
75			}
76
77			/**
78			* Represent collection of instances
79			*
80			* @param array $array
81			*/
82			public static function collection(array $array)
			0 ignored issues – show Unused Code introduced 2016-01-17 18:19 UTC by Report Bug Copy Issue Report The parameter `$array` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
83			{
84			//TBD
85			}
86
87			protected function getCollectionRepresentation()
88			{
89			//TBD
90			return ['collection', 'tbd'];
91			}
92
93	4	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...
94			{
95	4		$rules = $this->rules();
96	4		$represented = [];
97
98	4		if (!empty($rules)) {
99	4		foreach ($rules as $rule) {
100			/** @var $rule PropertyRule */
101	4		$resultArray = $rule->compile();
102
103	4		reset($resultArray);
104	4		$key = key($resultArray);
105	4		$value = $resultArray[$key];
106
107	4		$represented[$key] = $value;
108	4		}
109	4		}
110
111	4		return $represented;
112			}
113
114	4		protected function getRepresentation()
115			{
116	4		switch ($this->strategy) {
117	4		case 1:
118	4		return $this->getOneRepresentation();
119			case 2:
120			return $this->getCollectionRepresentation();
121			default:
122			throw new \Exception('Representation strategy not defined');
123			}
124
125			}
126
127
128			/**
129			* @param $className
130			* @return static
131			*/
132	3		public static function restore($className)
133			{
134	3		$instance = new static(null, 3);
135	3		$instance->setTargetClassName($className);
136	3		return $instance;
137			}
138
139	3		protected function getReverseRepresentation($projection)
140			{
141	3		switch ($this->strategy) {
142	3		case 3:
143	3		return $this->getOneReverseRepresentation($projection);
144			case 4:
145			return $this->getCollectionReverseRepresentation($projection);
146			default:
147			throw new \Exception('Reverse representation strategy not defined');
148			}
149
150			}
151
152	3	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...
153			{
154	3		$rules = $this->rules();
155	3		$target = new $this->targetClassName();
156
157	3		if (!empty($rules)) {
158	3		foreach ($rules as $rule) {
159			/** @var $rule PropertyRule */
160	3		$resultArray = $rule->reverseCompile($projection);
161
162	3		reset($resultArray);
163	3		$key = key($resultArray);
164	3		$value = $resultArray[$key];
165
166	3		$target->$key = $value;
167	3		}
168	3		}
169	3		return $target;
170			}
171
172			protected function getCollectionReverseRepresentation($projection)
			0 ignored issues – show Unused Code introduced 2016-01-18 21:06 UTC by Report Bug Copy Issue Report The parameter `$projection` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
173			{
174			//TBD
175			}
176			}
177

iJackUA / einfach-representer

Push — master ( 18d699...ab33d5 )

Representer::getReverseRepresentation() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like