OpenStack\Common\Resource\Alias

Complexity

Total Complexity

20

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setObjectProperty()	0	11	2
A	add()	0	11	3
A	remove()	0	14	4
A	getAliases()	0	8	1
A	hasAliases()	0	4	1
B	normalizePropertyValue()	0	16	7
A	ensureClassName()	0	4	2

<?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);

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.

        $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) {

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.

            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;
    }
}