Iris\Transfer\Base

Complexity

Total Complexity

26

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

98.75%

Importance

Changes	5
Bugs	1	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	4
A	toCamelCase()	0	4	1
A	offsetUnset()	0	4	1
B	__call()	0	21	5
A	toArray()	0	21	4
A	toStudlyCapsArray()	0	11	2
A	toCleanArray()	0	13	3
A	getValue()	0	13	3
A	offsetGet()	0	5	1
A	offsetSet()	0	5	1
A	offsetExists()	0	5	1

<?php

namespace Iris\Transfer;

abstract class Base implements \ArrayAccess
{

    /**
     * Base constructor - you may use an array to initialize the Transfer
     */
    public function __construct(array $data = array())
    {
        if (!empty($data)) {
            $ref = new \ReflectionObject($this);
            foreach ($ref->getProperties() as $property) {
                try {
                    $value = $this->getValue($data, $property->getName());
                    $property->setAccessible(true);
                    $property->setValue($this, $value);
                } catch (\OutOfBoundsException $e) {
                    // does nothing when we don't have a certain property in the $data array
                }
            }
        }
    }

    /**
     * Getter and Setters
     */
    public function __call($name, array $args)
    {
        if (in_array(substr($name, 0, 3), array('get', 'set'))) {
            $property = lcfirst(substr($name, 3));
            $ref = new \ReflectionObject($this);
            if ($ref->hasProperty($property)) {
                $property = $ref->getProperty($property);
                $property->setAccessible(true);
                switch (substr($name, 0, 3)) {
                    case 'get':
                        return $property->getValue($this);
                    case 'set':
                    default:
                        $property->setValue($this, $args[0]);
                        return $this;
                }
            }
            throw new \InvalidArgumentException(sprintf('Property %s does not exists', $property));
        }
        throw new \InvalidArgumentException('Method does not exists');
    }

    /**
     * Export transfer values as an array
     * @return array
     */
    public function toArray()
    {
        $ref = new \ReflectionObject($this);
        $export = array();

        foreach ($ref->getProperties() as $property) {
            $property->setAccessible(true);
            $name = strtolower(preg_replace('@([A-Z])@', '_\1', $property->getName()));
            $export[$name] = $property->getValue($this);

            if ($export[$name] instanceof self) {
                $export[$name] = $export[$name]->toArray();
            }

            if ($export[$name] instanceof \DateTime) {
                $export[$name] = $export[$name]->format('Y-m-d');
            }
        }

        return $export;
    }

    /**
     * Export transfer values as an array in studly caps format.
     * @return array
     */
    public function toStudlyCapsArray()
    {
        $export = $this->toArray();

        $result = array();
        foreach ($export as $key => $value) {
            $result[ucfirst($this->toCamelCase($key))] = $value;
        }

        return $result;
    }

    /**
     * toArray with unset null fields
     * @return array
     */
    public function toCleanArray()
    {
        $export = $this->toArray();

        $cleanExport = array();
        foreach ($export as $key => $value) {
            if ($value) {
                $cleanExport[$key] = $value;
            }
        }

        return $cleanExport;
    }

    /**
     * Extract transfer $property value from $data
     */
    private function getValue(array $data, $property)
    {
        if (isset($data[$property])) {
            return $data[$property];
        }

        $property = strtolower(preg_replace('@([A-Z])@', '_\1', $property));
        if (isset($data[$property])) {
            return $data[$property];
        }

        throw new \OutOfBoundsException('');
    }

    private function toCamelCase($name)
    {
        return lcfirst(str_replace(' ', '', ucwords(str_replace('_', ' ', $name))));
    }

    public function offsetGet($offset)
    {
        $property = $this->toCamelCase($offset);
        return call_user_func(array($this, 'get' . ucfirst($property)));
    }

    public function offsetSet($offset, $value)
    {
        $property = $this->toCamelCase($offset);
        return call_user_func(array($this, 'set' . ucfirst($property)), $value);
    }

    public function offsetExists($offset)
    {
        $property = $this->toCamelCase($offset);
        return (new \ReflectionObject($this))->hasProperty($property);
    }

    public function offsetUnset($offset)
    {
        $this->offsetSet($offset, null);
    }
}