Bludata\Common\Traits\AttributesTrait

Complexity

Total Complexity

20

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	2
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getAttributes()	0	23	2
A	getMethod()	0	4	1
A	setMethod()	0	4	1
A	toJson()	0	4	1
A	toString()	0	4	1
A	__toString()	0	4	1
A	__get()	0	4	1
A	__set()	0	4	1
A	__isset()	0	4	1
A	__unset()	0	4	1
A	get()	0	17	2
A	set()	0	16	2
B	toArray()	0	24	5

<?php

namespace Bludata\Common\Traits;

use ArrayAccess;
use InvalidArgumentException;

trait AttributesTrait
{
    public function getAttributes()
    {
        $attributes = array_keys(
            get_class_vars(
                get_class($this)
            )
        );

        return array_combine(
            $attributes,
            array_map(
                function ($attr) {
                    $getMethod = $this->getMethod($attr);
                    if (method_exists($this, $getMethod)) {
                        return $this->$getMethod();
                    }

                    return $this->$attr;
                },
                $attributes
            )
        );
    }

    public function getMethod($attr)
    {
        return sprintf('get%s', ucfirst($attr));
    }

    public function setMethod($attr)
    {
        return sprintf('set%s', ucfirst($attr));
    }

    public function get($attr)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $attributes = $this->getAttributes();

$attributes is not used, you could remove the assignment.

        $getMethod = $this->getMethod($attr);
        if (method_exists($this, $getMethod)) {
            return $this->$getMethod();
        }

        throw new InvalidArgumentException(
            sprintf(
                'The class "%s" don\'t have a method "%s"',
                get_class($this),
                $getMethod
            )
        );
    }

    public function set($attr, $value)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $setMethod = $this->setMethod($attr);

        if (method_exists($this, $setMethod)) {
            return $this->$setMethod($value);
        }

        throw new InvalidArgumentException(
            sprintf(
                'The class "%s" don\'t have a method "%s"',
                get_class($this),
                $setMethod
            )
        );
    }

    public function toArray()
    {
        return array_map(function ($attr) {
            if (method_exists($attr, 'toArray')) {
                return $attr->toArray();
            }

            if ($attr instanceof ArrayAccess) {
                $newParam = [];
                foreach ($attr as $p) {
                    if (method_exists($p, 'toArray')) {
                        $newParam[] = $p->toArray();
                        continue;
                    }

                    $newParam[] = $p;
                }

                return $newParam;
            }

            return $attr;
        }, $this->getAttributes());
    }

    public function toJson()
    {
        return json_encode($this->toArray());
    }

    public function toString()
    {
        return print_r($this, true);
    }

    public function __toString()
    {
        return $this->toString();
    }

    public function __get($attr)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->get($attr);
    }

    public function __set($attr, $value)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->set($attr, $value);
    }

    public function __isset($attr)
    {
        return isset($this->$attr);
    }

    public function __unset($attr)
    {
        unset($this->$attr);
    }
}