Respect\Validation\Message\Creator

Complexity

Total Complexity

32

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	create()	0	24	3
A	getTemplate()	0	13	3
A	quoteCode()	0	8	2
B	normalize()	0	24	6
B	normalizeObject()	0	33	5
A	normalizeException()	0	10	1
C	normalizeArray()	0	33	7
A	normalizeFloat()	0	12	4

<?php

/*
 * This file is part of Respect/Validation.
 *
 * (c) Alexandre Gomes Gaigalas <alexandre@gaigalas.net>
 *
 * For the full copyright and license information, please view the "LICENSE.md"
 * file that was distributed with this source code.
 */

namespace Respect\Validation\Message;

use DateTimeInterface;
use Exception;
use Traversable;

/**
 * Message creator.
 *
 * @author Henrique Moody <henriquemoody@gmail.com>
 *
 * @since 2.0.0
 */
final class Creator
{
    /**
     * @var Translator
     */
    private $translator;

    /**
     * @var int
     */
    private $maxDepth;

    /**
     * @var int
     */
    private $maxChildren;

    /**
     * Initializes the message creator.
     *
     * @param Translator $translator  Message translator to translate the templates
     * @param int        $maxDepth    Maximum depth level to show when normalizing data
     * @param int        $maxChildren Maximum children level to show when normalizing data
     */
    public function __construct(Translator $translator, int $maxDepth, int $maxChildren)
    {
        $this->translator = $translator;
        $this->maxDepth = $maxDepth;
        $this->maxChildren = $maxChildren;
    }

    /**
     * Creates a message based on a result and some templates.
     *
     * @param mixed $input
     * @param array $properties
     * @param array $templates
     *
     * @return string
     */
    public function create($input, array $properties, array $templates): string
    {
        $properties += ['placeholder' => $this->normalize($input)];

        $template = $this->getTemplate($properties, $templates);
        $templateTranslated = $this->translator->translate($template);

        return preg_replace_callback(
            '/{{(\w+)}}/',
            function ($matches) use ($properties) {
                $value = $matches[0];
                if (array_key_exists($matches[1], $properties)) {
                    $value = $properties[$matches[1]];
                }

                if ($matches[1] === 'placeholder') {
                    return $value;
                }

                return $this->normalize($value);
            },
            $templateTranslated
        );
    }

    private function getTemplate(array $properties, array $templates): string
    {
        if (array_key_exists('template', $properties)) {
            return $properties['template'];
        }

        $templateKey = $properties['templateId'] ?? 0;
        if (array_key_exists($templateKey, $templates)) {
            return $templates[$templateKey];
        }

        return current($templates);
    }

    private function quoteCode(string $string, $currentDepth): string
    {
        if ($currentDepth === 0) {
            $string = sprintf('`%s`', $string);
        }

        return $string;
    }

    private function normalize($raw, $currentDepth = 0): string
    {
        if (is_object($raw)) {
            return $this->normalizeObject($raw, $currentDepth);
        }

        if (is_array($raw)) {
            return $this->normalizeArray($raw, $currentDepth);
        }

        if (is_resource($raw)) {
            return $this->quoteCode(sprintf('[resource] (%s)', get_resource_type($raw)), $currentDepth);
        }

        if (is_float($raw)) {
            return $this->normalizeFloat($raw);
        }

        if (is_bool($raw)) {
            return $this->quoteCode(var_export($raw, true), $currentDepth);
        }

        return json_encode($raw, (JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
    }

    private function normalizeObject($raw, int $currentDepth): string
    {
        $nextDepth = $currentDepth + 1;

        if ($raw instanceof Traversable) {
            $array = iterator_to_array($raw);
            $normalized = sprintf('[traversable] (%s: %s)', get_class($raw), $this->normalize($array, $nextDepth));

            return $this->quoteCode($normalized, $currentDepth);
        }

        if ($raw instanceof DateTimeInterface) {
            return sprintf('"%s"', $raw->format('c'));
        }

        if ($raw instanceof Exception) {
            $normalized = $this->normalizeException($raw, $nextDepth);

            return $this->quoteCode($normalized, $currentDepth);
        }

        if (method_exists($raw, '__toString')) {
            return $this->normalize($raw->__toString(), $nextDepth);
        }

        $normalized = sprintf(
            '[object] (%s: %s)',
            get_class($raw),
            $this->normalize(get_object_vars($raw), $currentDepth)
        );

        return $this->quoteCode($normalized, $currentDepth);
    }

    private function normalizeException(Exception $exception, int $currentDepth): string
    {
        $properties = [
            'message' => $exception->getMessage(),
            'code' => $exception->getCode(),
            'file' => str_replace(getcwd().'/', '', $exception->getFile()).':'.$exception->getLine(),
        ];

        return sprintf('[exception] (%s: %s)', get_class($exception), $this->normalize($properties, $currentDepth));
    }

    private function normalizeArray(array $raw, int $currentDepth): string
    {
        if ($currentDepth >= $this->maxDepth) {
            return '...';
        }

        if (empty($raw)) {
            return '{ }';
        }

        $string = '';
        $total = count($raw);
        $current = 0;
        $nextDepth = $currentDepth + 1;
        foreach ($raw as $key => $value) {
            if ($current++ >= $this->maxChildren) {
                $string .= ' ... ';
                break;
            }

            if (!is_int($key)) {
                $string .= sprintf('%s: ', $this->normalize($key, $nextDepth));
            }

            $string .= $this->normalize($value, $nextDepth);

            if ($current !== $total) {
                $string .= ', ';
            }
        }

        return sprintf('{ %s }', $string);
    }

    private function normalizeFloat(float $raw): string
    {
        if (is_infinite($raw)) {
            return ($raw > 0 ? '' : '-').'INF';
        }

        if (is_nan($raw)) {
            return 'NaN';
        }

        return var_export($raw, true);
    }
}