ConsoleLogger::log() - Code Metrics - Inspection of "Merge branch 'master' into console" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — console ( 5778b8...1e780d )

by Arnaud

created 2020-04-28 16:16 UTC

ConsoleLogger::log() B

↳ Parent: ConsoleLogger

Complexity

Conditions	10
Paths	36

Size

Total Lines	57
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
cc	10
eloc	29
c	6
b	1
f	0
nc	36
nop	3
dl	0
loc	57
rs	7.6666

How to fix Long Method Complexity

<?php
/**
 * This file is part of the Cecil/Cecil package.
 *
 * Copyright (c) Arnaud Ligny <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cecil\Logger;

use Psr\Log\InvalidArgumentException;
use Psr\Log\LogLevel;
use Symfony\Component\Console\Formatter\OutputFormatterStyle;
use Symfony\Component\Console\Helper\ProgressBar;
use Symfony\Component\Console\Output\OutputInterface;

class ConsoleLogger extends PrintLogger
{
    const ERROR = 'error';
    const WARNING = 'comment';
    const NOTICE = 'info';
    const INFO = 'text';

    protected $output;
    protected $verbosityLevelMap = [
        LogLevel::EMERGENCY => OutputInterface::VERBOSITY_NORMAL,
        LogLevel::ALERT     => OutputInterface::VERBOSITY_NORMAL,
        LogLevel::CRITICAL  => OutputInterface::VERBOSITY_NORMAL,
        LogLevel::ERROR     => OutputInterface::VERBOSITY_NORMAL,
        LogLevel::WARNING   => OutputInterface::VERBOSITY_NORMAL,
        LogLevel::NOTICE    => OutputInterface::VERBOSITY_VERBOSE,
        LogLevel::INFO      => OutputInterface::VERBOSITY_VERY_VERBOSE,
        LogLevel::DEBUG     => OutputInterface::VERBOSITY_DEBUG,
    ];
    protected $formatLevelMap = [
        LogLevel::EMERGENCY => self::ERROR,
        LogLevel::ALERT     => self::ERROR,
        LogLevel::CRITICAL  => self::ERROR,
        LogLevel::ERROR     => self::ERROR,
        LogLevel::WARNING   => self::INFO,
        LogLevel::NOTICE    => self::NOTICE,
        LogLevel::INFO      => self::INFO,
        LogLevel::DEBUG     => self::INFO,
    ];

    /** @var ProgressBar */
    protected $progressBar = null;
    /** @var int */
    private $progressBarMax;

    public function __construct(OutputInterface $output, array $verbosityLevelMap = [], array $formatLevelMap = [])
    {
        $this->output = $output;
        $this->verbosityLevelMap = $verbosityLevelMap + $this->verbosityLevelMap;
        $this->formatLevelMap = $formatLevelMap + $this->formatLevelMap;
    }

    /**
     * {@inheritdoc}
     *
     * @return void
     */
    public function log($level, $message, array $context = [])
    {
        $output = $this->output;
        $outputStyle = new OutputFormatterStyle('white');
        $output->getFormatter()->setStyle('text', $outputStyle);

        // updates the levels mapping if output supports the Progress Bar
        if ($output->isDecorated()) {
            array_replace_recursive($this->verbosityLevelMap, [
                LogLevel::NOTICE    => OutputInterface::VERBOSITY_NORMAL,
                LogLevel::INFO      => OutputInterface::VERBOSITY_VERBOSE,
            ]);
        }

        if (!isset($this->verbosityLevelMap[$level])) {
            throw new InvalidArgumentException(sprintf('The log level "%s" does not exist.', $level));
        }

        // steps Progress Bar
        if ($output->isDecorated()) {
            if ($output->getVerbosity() == OutputInterface::VERBOSITY_NORMAL && array_key_exists('step', $context)) {
                $this->printProgressBar($context['step'][0], $context['step'][1]);

                return;
            }
        }

        // default pattern: <level>message</level>
        $pattern = '<%1$s>%2$s%3$s</%1$s>';
        $prefix = '';

        // steps prefix
        if (array_key_exists('step', $context)) {
            $prefix = sprintf('%s. ', $this->padPrefix($context['step'][0], $context['step'][1]));
        }

        // sub steps progress
        if (array_key_exists('progress', $context)) {
            // the verbose Progress Bar
            if ($output->isDecorated()) {
                if ($output->getVerbosity() == OutputInterface::VERBOSITY_VERBOSE) {
                    $this->printProgressBar($context['progress'][0], $context['progress'][1]);

                    return;
                }
            }
            // prefix
            $prefix = sprintf(
                '[%s/%s] ',
                $this->padPrefix($context['progress'][0], $context['progress'][1]),
                $context['progress'][1]
            );
        }

        $output->writeln(
            sprintf($pattern, $this->formatLevelMap[$level], $prefix, $this->interpolate($message, $context)),
            $this->verbosityLevelMap[$level]
        );
    }

    /**
     * Prints the Progress Bar.
     *
     * @param int $itemsCount
     * @param int $itemsMax
     *
     * @return void
     */
    protected function printProgressBar(int $itemsCount, int $itemsMax): void
    {
        $this->createProgressBar($itemsMax);
        $this->progressBar->clear();
        $this->progressBar->setProgress($itemsCount);
        $this->progressBar->display();
        if ($itemsCount == $itemsMax) {
            $this->progressBar->finish();
            $this->output->writeln('');
        }
    }

    /**
     * Creates the Progress bar.
     *
     * @param int $max
     *
     * @return void
     */
    private function createProgressBar(int $max): void
    {
        if ($this->progressBar === null || $max != $this->progressBarMax) {
            $this->progressBarMax = $max;
            $this->progressBar = new ProgressBar($this->output, $max);
            $this->progressBar->setOverwrite(true);
            $this->progressBar->setFormat('%percent:3s%% [%bar%] %current%/%max%');
            $this->progressBar->setBarCharacter('#');
            $this->progressBar->setEmptyBarCharacter(' ');
            $this->progressBar->setProgressCharacter('#');
            $this->progressBar->setRedrawFrequency(1);
            $this->progressBar->start();
        }
    }

    /**
     * Prefix padding.
     *
     * @param string $prefix
     * @param string $max
     *
     * @return string
     */
    private function padPrefix(string $prefix, string $max): string
    {
        return str_pad($prefix, strlen($max), ' ', STR_PAD_LEFT);
    }
}


1			<?php
2			/**
3			* This file is part of the Cecil/Cecil package.
4			*
5			* Copyright (c) Arnaud Ligny <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Cecil\Logger;
12
13			use Psr\Log\InvalidArgumentException;
14			use Psr\Log\LogLevel;
15			use Symfony\Component\Console\Formatter\OutputFormatterStyle;
16			use Symfony\Component\Console\Helper\ProgressBar;
17			use Symfony\Component\Console\Output\OutputInterface;
18
19			class ConsoleLogger extends PrintLogger
20			{
21			const ERROR = 'error';
22			const WARNING = 'comment';
23			const NOTICE = 'info';
24			const INFO = 'text';
25
26			protected $output;
27			protected $verbosityLevelMap = [
28			LogLevel::EMERGENCY => OutputInterface::VERBOSITY_NORMAL,
29			LogLevel::ALERT => OutputInterface::VERBOSITY_NORMAL,
30			LogLevel::CRITICAL => OutputInterface::VERBOSITY_NORMAL,
31			LogLevel::ERROR => OutputInterface::VERBOSITY_NORMAL,
32			LogLevel::WARNING => OutputInterface::VERBOSITY_NORMAL,
33			LogLevel::NOTICE => OutputInterface::VERBOSITY_VERBOSE,
34			LogLevel::INFO => OutputInterface::VERBOSITY_VERY_VERBOSE,
35			LogLevel::DEBUG => OutputInterface::VERBOSITY_DEBUG,
36			];
37			protected $formatLevelMap = [
38			LogLevel::EMERGENCY => self::ERROR,
39			LogLevel::ALERT => self::ERROR,
40			LogLevel::CRITICAL => self::ERROR,
41			LogLevel::ERROR => self::ERROR,
42			LogLevel::WARNING => self::INFO,
43			LogLevel::NOTICE => self::NOTICE,
44			LogLevel::INFO => self::INFO,
45			LogLevel::DEBUG => self::INFO,
46			];
47
48			/** @var ProgressBar */
49			protected $progressBar = null;
50			/** @var int */
51			private $progressBarMax;
52
53			public function __construct(OutputInterface $output, array $verbosityLevelMap = [], array $formatLevelMap = [])
54			{
55			$this->output = $output;
56			$this->verbosityLevelMap = $verbosityLevelMap + $this->verbosityLevelMap;
57			$this->formatLevelMap = $formatLevelMap + $this->formatLevelMap;
58			}
59
60			/**
61			* {@inheritdoc}
62			*
63			* @return void
64			*/
65			public function log($level, $message, array $context = [])
66			{
67			$output = $this->output;
68			$outputStyle = new OutputFormatterStyle('white');
69			$output->getFormatter()->setStyle('text', $outputStyle);
70
71			// updates the levels mapping if output supports the Progress Bar
72			if ($output->isDecorated()) {
73			array_replace_recursive($this->verbosityLevelMap, [
74			LogLevel::NOTICE => OutputInterface::VERBOSITY_NORMAL,
75			LogLevel::INFO => OutputInterface::VERBOSITY_VERBOSE,
76			]);
77			}
78
79			if (!isset($this->verbosityLevelMap[$level])) {
80			throw new InvalidArgumentException(sprintf('The log level "%s" does not exist.', $level));
81			}
82
83			// steps Progress Bar
84			if ($output->isDecorated()) {
85			if ($output->getVerbosity() == OutputInterface::VERBOSITY_NORMAL && array_key_exists('step', $context)) {
86			$this->printProgressBar($context['step'][0], $context['step'][1]);
87
88			return;
89			}
90			}
91
92			// default pattern: <level>message</level>
93			$pattern = '<%1$s>%2$s%3$s</%1$s>';
94			$prefix = '';
95
96			// steps prefix
97			if (array_key_exists('step', $context)) {
98			$prefix = sprintf('%s. ', $this->padPrefix($context['step'][0], $context['step'][1]));
99			}
100
101			// sub steps progress
102			if (array_key_exists('progress', $context)) {
103			// the verbose Progress Bar
104			if ($output->isDecorated()) {
105			if ($output->getVerbosity() == OutputInterface::VERBOSITY_VERBOSE) {
106			$this->printProgressBar($context['progress'][0], $context['progress'][1]);
107
108			return;
109			}
110			}
111			// prefix
112			$prefix = sprintf(
113			'[%s/%s] ',
114			$this->padPrefix($context['progress'][0], $context['progress'][1]),
115			$context['progress'][1]
116			);
117			}
118
119			$output->writeln(
120			sprintf($pattern, $this->formatLevelMap[$level], $prefix, $this->interpolate($message, $context)),
121			$this->verbosityLevelMap[$level]
122			);
123			}
124
125			/**
126			* Prints the Progress Bar.
127			*
128			* @param int $itemsCount
129			* @param int $itemsMax
130			*
131			* @return void
132			*/
133			protected function printProgressBar(int $itemsCount, int $itemsMax): void
134			{
135			$this->createProgressBar($itemsMax);
136			$this->progressBar->clear();
137			$this->progressBar->setProgress($itemsCount);
138			$this->progressBar->display();
139			if ($itemsCount == $itemsMax) {
140			$this->progressBar->finish();
141			$this->output->writeln('');
142			}
143			}
144
145			/**
146			* Creates the Progress bar.
147			*
148			* @param int $max
149			*
150			* @return void
151			*/
152			private function createProgressBar(int $max): void
153			{
154			if ($this->progressBar === null \|\| $max != $this->progressBarMax) {
155			$this->progressBarMax = $max;
156			$this->progressBar = new ProgressBar($this->output, $max);
157			$this->progressBar->setOverwrite(true);
158			$this->progressBar->setFormat('%percent:3s%% [%bar%] %current%/%max%');
159			$this->progressBar->setBarCharacter('#');
160			$this->progressBar->setEmptyBarCharacter(' ');
161			$this->progressBar->setProgressCharacter('#');
162			$this->progressBar->setRedrawFrequency(1);
163			$this->progressBar->start();
164			}
165			}
166
167			/**
168			* Prefix padding.
169			*
170			* @param string $prefix
171			* @param string $max
172			*
173			* @return string
174			*/
175			private function padPrefix(string $prefix, string $max): string
176			{
177			return str_pad($prefix, strlen($max), ' ', STR_PAD_LEFT);
178			}
179			}
180

Cecilapp / Cecil

Push — console ( 5778b8...1e780d )

ConsoleLogger::log() B

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like