Alias::add() - Code Metrics - Inspection of "Removed usage of docblocks, fixed several parsing..." - php-opencloud/openstack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#159)

by Roman

created 2017-10-19 19:53 UTC

Alias::add() A

↳ Parent: Alias

Complexity

Conditions	3
Paths	4

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	11
rs	9.4285
cc	3
eloc	5
nc	4
nop	5

<?php declare(strict_types=1);

namespace OpenStack\Common\Resource;

/**
 * Represents a top-level abstraction of a remote API resource. Usually a resource represents a discrete
 * entity such as a Server, Container, Load Balancer. Apart from a representation of state, a resource can
 * also execute RESTFul operations on itself (updating, deleting, listing) or on other models.
 *
 * @package OpenStack\Common\Resource
 */
class Alias
{
    /**
     * An array of aliases that will be checked when the resource is being populated. For example,
     *
     * 'CLASS_NAME' => ['FOO_BAR' => 'fooBar']
     *
     * will extract FOO_BAR from the response, and save it as 'fooBar' in the resource.
     *
     * 'CLASS_NAME' => ['FOO_BAR' => ['fooBar', \DateTimeImmutable::class]]
     *
     * will extract FOO_BAR from the response, and save it as 'fooBar' with type \DateTimeImmutable in the resource.
     *
     * 'CLASS_NAME' => ['FOO_BAR' => ['fooBar', \DateTimeImmutable::class, true]]
     *
     * do the same as above plus indicates that target property is a list
     *
     * @var array
     */
    protected $aliases = [];

    /**
     * @param ResourceInterface $object
     * @param string            $key
     * @param mixed             $value
     *
     * @return void
     */
    public function setObjectProperty(ResourceInterface $object, $key, $value)
    {
        $alias = (array)($this->aliases[get_class($object)][$key] ?? $key);

        if (property_exists($object, $property = $alias[0])) {
            $class = $alias[1] ?? false;
            $isList = $alias[2] ?? false;

            $object->{$property} = $this->normalizePropertyValue($object, $value, $class, $isList);
        }
    }

    /**
     * Adds a new alias for class property
     *
     * @param string      $resourceClass
     * @param string      $alias
     * @param string      $property
     * @param string|null $class
     * @param bool        $isList
     *
     * @return $this
     */
    public function add($resourceClass, $alias, $property, $class = null, $isList = false)
    {
        $resourceClass = $this->ensureClassName($resourceClass);

        // make sure that target class exists
        $class = (($class && class_exists($class)) ? $class : false);
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false

        $this->aliases[$resourceClass][$alias] = [$property, $class, $isList];

        return $this;
    }

    /**
     * Removes an alias(es) for a class
     *
     * @param string      $resourceClass
     * @param string|null $alias
     *
     * @return $this
     */
    public function remove($resourceClass, $alias = null)
    {
        $resourceClass = $this->ensureClassName($resourceClass);

        if (isset($this->aliases[$resourceClass])) {
            if ($alias === null) {
                unset($this->aliases[$resourceClass]);
            } elseif (isset($this->aliases[$resourceClass][$alias])) {
                unset($this->aliases[$resourceClass][$alias]);
            }
        }

        return $this;
    }

    /**
     * Returns
     *
     * @param string $resourceClass
     *
     * @return array
     */
    public function getAliases($resourceClass)
    {
        $resourceClass = $this->ensureClassName($resourceClass);

        $aliases = $this->aliases[$resourceClass] ?? [];

        return array_map('array_shift', $aliases);
    }

    /**
     * Checks whether aliases added for a class or not
     *
     * @param string $resourceClass
     *
     * @return bool
     */
    public function hasAliases($resourceClass)
    {
        return isset($this->aliases[$resourceClass]);
    }

    /**
     * @param ResourceInterface $object
     * @param mixed             $value
     * @param string|false      $class
     * @param bool              $isList
     *
     * @return mixed
     */
    protected function normalizePropertyValue(ResourceInterface $object, $value, $class, $isList)
    {
        if ($value === null || !$class) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return $value;
        } elseif ($isList && is_array($value)) {
            $array = [];
            foreach ($value as $subVal) {
                $array[] = $object->model($class, $subVal);
            }
            return $array;
        } elseif ($class === \DateTimeImmutable::class) {
            return new \DateTimeImmutable($value);
        }

        return $object->model($class, $value);
    }

    /**
     * @param mixed $object
     *
     * @return string
     */
    private function ensureClassName($object)
    {
        return is_object($object) ? get_class($object) : (string)$object;
    }
}


1			<?php declare(strict_types=1);
2
3			namespace OpenStack\Common\Resource;
4
5			/**
6			* Represents a top-level abstraction of a remote API resource. Usually a resource represents a discrete
7			* entity such as a Server, Container, Load Balancer. Apart from a representation of state, a resource can
8			* also execute RESTFul operations on itself (updating, deleting, listing) or on other models.
9			*
10			* @package OpenStack\Common\Resource
11			*/
12			class Alias
13			{
14			/**
15			* An array of aliases that will be checked when the resource is being populated. For example,
16			*
17			* 'CLASS_NAME' => ['FOO_BAR' => 'fooBar']
18			*
19			* will extract FOO_BAR from the response, and save it as 'fooBar' in the resource.
20			*
21			* 'CLASS_NAME' => ['FOO_BAR' => ['fooBar', \DateTimeImmutable::class]]
22			*
23			* will extract FOO_BAR from the response, and save it as 'fooBar' with type \DateTimeImmutable in the resource.
24			*
25			* 'CLASS_NAME' => ['FOO_BAR' => ['fooBar', \DateTimeImmutable::class, true]]
26			*
27			* do the same as above plus indicates that target property is a list
28			*
29			* @var array
30			*/
31			protected $aliases = [];
32
33			/**
34			* @param ResourceInterface $object
35			* @param string $key
36			* @param mixed $value
37			*
38			* @return void
39			*/
40			public function setObjectProperty(ResourceInterface $object, $key, $value)
41			{
42			$alias = (array)($this->aliases[get_class($object)][$key] ?? $key);
43
44			if (property_exists($object, $property = $alias[0])) {
45			$class = $alias[1] ?? false;
46			$isList = $alias[2] ?? false;
47
48			$object->{$property} = $this->normalizePropertyValue($object, $value, $class, $isList);
49			}
50			}
51
52			/**
53			* Adds a new alias for class property
54			*
55			* @param string $resourceClass
56			* @param string $alias
57			* @param string $property
58			* @param string\|null $class
59			* @param bool $isList
60			*
61			* @return $this
62			*/
63			public function add($resourceClass, $alias, $property, $class = null, $isList = false)
64			{
65			$resourceClass = $this->ensureClassName($resourceClass);
66
67			// make sure that target class exists
68			$class = (($class && class_exists($class)) ? $class : false);
			0 ignored issues – show Bug Best Practice introduced 2017-10-19 19:54 UTC by Report Bug Copy Issue Report The expression `$class` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
69
70			$this->aliases[$resourceClass][$alias] = [$property, $class, $isList];
71
72			return $this;
73			}
74
75			/**
76			* Removes an alias(es) for a class
77			*
78			* @param string $resourceClass
79			* @param string\|null $alias
80			*
81			* @return $this
82			*/
83			public function remove($resourceClass, $alias = null)
84			{
85			$resourceClass = $this->ensureClassName($resourceClass);
86
87			if (isset($this->aliases[$resourceClass])) {
88			if ($alias === null) {
89			unset($this->aliases[$resourceClass]);
90			} elseif (isset($this->aliases[$resourceClass][$alias])) {
91			unset($this->aliases[$resourceClass][$alias]);
92			}
93			}
94
95			return $this;
96			}
97
98			/**
99			* Returns
100			*
101			* @param string $resourceClass
102			*
103			* @return array
104			*/
105			public function getAliases($resourceClass)
106			{
107			$resourceClass = $this->ensureClassName($resourceClass);
108
109			$aliases = $this->aliases[$resourceClass] ?? [];
110
111			return array_map('array_shift', $aliases);
112			}
113
114			/**
115			* Checks whether aliases added for a class or not
116			*
117			* @param string $resourceClass
118			*
119			* @return bool
120			*/
121			public function hasAliases($resourceClass)
122			{
123			return isset($this->aliases[$resourceClass]);
124			}
125
126			/**
127			* @param ResourceInterface $object
128			* @param mixed $value
129			* @param string\|false $class
130			* @param bool $isList
131			*
132			* @return mixed
133			*/
134			protected function normalizePropertyValue(ResourceInterface $object, $value, $class, $isList)
135			{
136			if ($value === null \|\| !$class) {
			0 ignored issues – show Bug Best Practice introduced 2017-10-19 19:54 UTC by Report Bug Copy Issue Report The expression `$class` of type `string\|false` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
137			return $value;
138			} elseif ($isList && is_array($value)) {
139			$array = [];
140			foreach ($value as $subVal) {
141			$array[] = $object->model($class, $subVal);
142			}
143			return $array;
144			} elseif ($class === \DateTimeImmutable::class) {
145			return new \DateTimeImmutable($value);
146			}
147
148			return $object->model($class, $value);
149			}
150
151			/**
152			* @param mixed $object
153			*
154			* @return string
155			*/
156			private function ensureClassName($object)
157			{
158			return is_object($object) ? get_class($object) : (string)$object;
159			}
160			}
161

php-opencloud / openstack

GitHub Access Token became invalid

Pull Request — master (#159)

Alias::add() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like