Overtrue\Cuttle\Config

Complexity

Total Complexity

32

Size/Duplication

Total Lines	246
Duplicated Lines	18.29 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getChannel()	0	11	2
A	getFormatters()	0	6	1
A	getHandlers()	0	6	1
A	getProcessors()	0	6	1
A	getFormatter()	0	10	2
A	getHandler()	0	8	2
A	getProcessor()	0	8	2
A	parse()	0	7	1
A	formatFormatters()	13	13	2
C	formatHandlers()	5	33	8
A	formatProcessors()	17	17	3
B	formatChannels()	10	19	6

<?php

/*
 * This file is part of the overtrue/cuttle.
 *
 * (c) overtrue <i@overtrue.me>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Overtrue\Cuttle;

use Closure;
use InvalidArgumentException;
use Monolog\Formatter\FormatterInterface;
use Monolog\Formatter\LineFormatter;
use Monolog\Handler\HandlerInterface;
use Monolog\Handler\StreamHandler;

/**
 * Class Config.
 *
 * @author overtrue <i@overtrue.me>
 */
class Config
{
    /**
     * @var array
     */
    protected $formatters = [];

    /**
     * @var array
     */
    protected $handlers = [];

    /**
     * @var array
     */
    protected $processors = [];

    /**
     * @var array
     */
    protected $channels = [];

    /**
     * Config constructor.
     *
     * @param array $config
     */
    public function __construct(array $config)
    {
        $this->parse($config);
    }

    /**
     * @param string $name
     *
     * @return array
     */
    public function getChannel(string $name)
    {
        if (empty($this->channels[$name])) {
            throw new InvalidArgumentException("No channel named '{$name}' found.");
        }

        $this->channels[$name]['handlers'] = $this->getHandlers($this->channels[$name]['handlers']);
        $this->channels[$name]['processors'] = $this->getProcessors($this->channels[$name]['processors']);

        return $this->channels[$name];
    }

    /**
     * @param array $names
     *
     * @return array
     */
    protected function getFormatters(array $names)
    {
        return array_map(function ($name) {
            return $this->getFormatter($name);
        }, $names);
    }

    /**
     * @param array $names
     *
     * @return array
     */
    protected function getHandlers(array $names)
    {
        return array_map(function ($name) {
            return $this->getHandler($name);
        }, $names);
    }

    /**
     * @param array $names
     *
     * @return array
     */
    protected function getProcessors(array $names)
    {
        return array_map(function ($name) {
            return $this->getProcessor($name);
        }, $names);
    }

    /**
     * @param string $formatterId
     *
     * @return \Monolog\Formatter\FormatterInterface
     */
    protected function getFormatter(string $formatterId)
    {
        if (!$this->formatters[$formatterId] instanceof FormatterInterface) {
            $this->formatters[$formatterId] = $this->makeInstance(

The method makeInstance() does not seem to exist on object<Overtrue\Cuttle\Config>.

                $this->formatters[$formatterId], 'formatter'
            );
        }

        return $this->formatters[$formatterId];
    }

    /**
     * @param string $handlerId
     *
     * @return \Monolog\Handler\HandlerInterface
     */
    protected function getHandler(string $handlerId)
    {
        if ($this->handlers[$handlerId] instanceof HandlerInterface) {
            return $this->handlers[$handlerId];
        }

        return $this->handlers[$handlerId] = $this->handlers[$handlerId]();
    }

    /**
     * @param string $processorId
     *
     * @return \Monolog\Handler\HandlerInterface
     */
    protected function getProcessor(string $processorId)
    {
        if ($this->processors[$processorId] instanceof Closure) {
            $this->processors[$processorId] = $this->processors[$processorId]();
        }

        return $this->processors[$processorId];
    }

    /**
     * @param array $config
     */
    protected function parse(array $config): void
    {
        $this->formatters = $this->formatFormatters($config['formatters'] ?? []);
        $this->handlers = $this->formatHandlers($config['handlers'] ?? []);
        $this->processors = $this->formatProcessors($config['processors'] ?? []);
        $this->channels = $this->formatChannels($config['channels'] ?? []);
    }

    /**
     * @param array $formatters
     *
     * @return array
     */
    protected function formatFormatters(array $formatters = [])

This method seems to be duplicated in your project.

    {
        foreach ($formatters as $id => $option) {
            $class = $option['formatter'] ?? LineFormatter::class;
            unset($option['formatter']);

            $formatters[$id] = function () use ($class, $option) {
                return (new ClassResolver($class))->resolve($option);
            };
        }

        return $formatters;
    }

    /**
     * @param array $handlers
     *
     * @return array
     */
    protected function formatHandlers(array $handlers = [])
    {
        foreach ($handlers as $id => $option) {
            if (isset($option['formatter']) && !isset($this->formatters[$option['formatter']])) {
                throw new InvalidArgumentException(sprintf('Formatter %s not configured.', $option['formatter']));
            }

            foreach ($option['processors'] ?? [] as $processorId) {

This code seems to be duplicated across your project.

                if (!isset($this->processors[$processorId])) {
                    throw new InvalidArgumentException(sprintf('Processor %s not configured.', $processorId));
                }
            }

            $class = $option['handler'] ?? StreamHandler::class;
            unset($option['handler']);

            $handlers[$id] = function () use ($class, $option) {
                $handler = (new ClassResolver($class))->resolve($option);

                if (!empty($option['formatter'])) {
                    $handler->setFormatter($this->getFormatter($option['formatter']));
                }

                if (!empty($option['processors'])) {
                    $handler->pushProcessor($this->getProcessors($option['processors']));
                }

                return $handler;
            };
        }

        return $handlers;
    }

    /**
     * @param array $processors
     *
     * @return array
     */
    protected function formatProcessors(array $processors = [])

This method seems to be duplicated in your project.

    {
        foreach ($processors as $id => $option) {
            if (empty($option['processor'])) {
                continue;
            }

            $class = $option['processor'];
            unset($option['processor']);

            $processors[$id] = function () use ($class, $option) {
                return (new ClassResolver($class))->resolve($option);
            };
        }

        return $processors;
    }

    /**
     * @param array $channels
     *
     * @return array
     */
    protected function formatChannels(array $channels = [])
    {
        foreach ($channels as $id => $option) {
            foreach ($option['processors'] ?? [] as $processorId) {

This code seems to be duplicated across your project.

                if (!isset($this->processors[$processorId])) {
                    throw new InvalidArgumentException(sprintf('Processor %s not configured.', $processorId));
                }
            }

            foreach ($option['handlers'] ?? [] as $handlerId) {

This code seems to be duplicated across your project.

                if (!isset($this->handlers[$handlerId])) {
                    throw new InvalidArgumentException(sprintf('Handler %s not configured.', $handlerId));
                }
            }
            $channels[$id] = array_merge(['handlers' => [], 'processors' => []], $option);
        }

        return $channels;
    }
}