Thruster\Component\DataMapper\DataMapper

Complexity

Total Complexity

13

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getValidator()	0	4	1
A	getDataMapper()	0	4	1
A	setValidator()	0	6	1
A	mapCollection()	0	19	4
B	map()	0	28	5

<?php

namespace Thruster\Component\DataMapper;

use Symfony\Component\Validator\Validator\ValidatorInterface;
use Thruster\Component\DataMapper\Exception\DataMapperOutputNotValidException;
use Thruster\Component\DataMapper\Exception\NotSupportedInputForDataMapperException;

/**
 * Class DataMapper
 *
 * @package Thruster\Component\DataMapper
 * @author  Aurimas Niekis <aurimas@niekis.lt>
 */
class DataMapper
{
    /**
     * @var DataMapperInterface
     */
    protected $dataMapper;

    /**
     * @var ValidatorInterface
     */
    protected $validator;

    public function __construct(DataMapperInterface $dataMapper)
    {
        $this->dataMapper = $dataMapper;
    }

    /**
     * @return ValidatorInterface
     */
    public function getValidator()
    {
        return $this->validator;
    }

    /**
     * @param ValidatorInterface $validator
     *
     * @return $this
     */
    public function setValidator($validator)
    {
        $this->validator = $validator;

        return $this;
    }

    /**
     * @return DataMapperInterface
     */
    public function getDataMapper()
    {
        return $this->dataMapper;
    }

    /**
     * @param mixed $input
     * @param bool $preserveKey
     *
     * @return array
     * @throws DataMapperOutputNotValidException
     * @throws NotSupportedInputForDataMapperException
     */
    public function mapCollection($input, bool $preserveKey = true) : array
    {
        if (empty($input)) {
            return [];
        }

        $result = [];

        foreach ($input as $key => $item) {
            if (true === $preserveKey) {
                $result[$key] = $this->map($item);
                continue;
            }

            $result[] = $this->map($item);
        }

        return $result;
    }

    /**
     * @param mixed $input
     *
     * @return mixed
     * @throws DataMapperOutputNotValidException
     * @throws NotSupportedInputForDataMapperException
     */
    public function map($input)
    {
        if (null === $input) {
            return null;
        }

        $dataMapper = $this->getDataMapper();

        if (false === $dataMapper->supports($input)) {
            throw new NotSupportedInputForDataMapperException($input, $dataMapper);
        }

        $output = $dataMapper->map($input);

        if ($dataMapper instanceof ValidateableDataMapperInterface) {
            $violations = $this->getValidator()->validate(
                $output,
                null,
                $dataMapper->getValidationGroups($input)
            );

            if (count($violations) > 0) {
                throw new DataMapperOutputNotValidException($violations);
            }
        }

        return $output;
    }
}