DCP\Mapper\ObjectMapper

Complexity

Total Complexity

16

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	2
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	map()	0	33	4
A	ensureIsObject()	0	6	2
A	findGetterMethods()	0	6	1
A	filterMethodsWithPrefix()	0	14	3
A	processPropertyRules()	0	15	3
A	processPropertyTransformers()	0	12	2

<?php

namespace DCP\Mapper;

use DCP\Mapper\Collections\Maps\RuleMap;
use DCP\Mapper\Collections\Maps\TransformerMap;
use DCP\Mapper\Exception\InvalidArgumentException;

class ObjectMapper implements MapperInterface
{
    /**
     * @var RuleMap
     */
    private $ruleMap;

    /**
     * @var TransformerMap
     */
    private $transformerMap;

    public function __construct(RuleMap $ruleMap, TransformerMap $transformerMap)
    {
        $this->ruleMap = $ruleMap;
        $this->transformerMap = $transformerMap;
    }

    public function map($source, $target)
    {
        $this->ensureIsObject('source', $source);
        $this->ensureIsObject('target', $target);

        $sourceClass = new \ReflectionClass($source);
        $targetClass = new \ReflectionClass($target);

        $sourceGetters = $this->findGetterMethods($sourceClass);

        foreach ($sourceGetters as $getter) {
            $getterPropertyName = lcfirst(substr($getter->getName(), 3)); // getLastName -> lastName

Consider using $getter->name. There is an issue with getName() and APC-enabled PHP versions.

            if (!$this->processPropertyRules($getterPropertyName)) {
                continue;
            }

            $setterMethodName = 'set' . ucfirst($getterPropertyName); // lastName -> setLastName

            if (!$targetClass->hasMethod($setterMethodName)) {
                continue;
            }

            $setter = $targetClass->getMethod($setterMethodName);

            $propertyValue = $getter->invoke($source);
            $propertyValue = $this->processPropertyTransformers($getterPropertyName, $propertyValue);

            $setter->invokeArgs($target, [$propertyValue]);
        }

        return $target;
    }

    private function ensureIsObject($variableName, $object)
    {
        if (!is_object($object)) {
            throw new InvalidArgumentException(sprintf('$%s must be an object', $variableName));
        }
    }

    private function findGetterMethods(\ReflectionClass $class)
    {
        $methods = $class->getMethods(\ReflectionMethod::IS_PUBLIC);

        return $this->filterMethodsWithPrefix($methods, 'get');
    }

    /**
     * @param \ReflectionMethod[] $methods
     * @param string $prefix
     * @return \ReflectionMethod[]
     */
    private function filterMethodsWithPrefix($methods, $prefix)
    {
        $result = [];

        foreach ($methods as $method) {
            $methodName = $method->getName();

Consider using $method->name. There is an issue with getName() and APC-enabled PHP versions.

            if (strpos($methodName, $prefix) === 0) {
                $result[] = $method;
            }
        }

        return $result;
    }

    private function processPropertyRules($property)
    {
        $rules = $this->ruleMap->get($property);

        $proceed = true;

        foreach ($rules as $rule) {
            if (!$rule->execute()) {
                $proceed = false;
                break;
            }
        }

        return $proceed;
    }

    private function processPropertyTransformers($property, $value)
    {
        $transformers = $this->transformerMap->get($property);

        $result = $value;

        foreach ($transformers as $transformer) {
            $result = $transformer->transform($result);
        }

        return $result;
    }
}