ResolveCacheCommand::execute() - Code Metrics - Inspection of "[Console] Add forced resolve to command and pritti..." - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.0 (#967)

by Rob

created 2017-08-31 00:10 UTC

ResolveCacheCommand::execute() C

↳ Parent: ResolveCacheCommand

Complexity

Conditions	8
Paths	40

Size

Total Lines	42
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	42
rs	5.3846
c	0
b	0
f	0
cc	8
eloc	27
nc	40
nop	2

<?php

/*
 * This file is part of the `liip/LiipImagineBundle` project.
 *
 * (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
 *
 * For the full copyright and license information, please view the LICENSE.md
 * file that was distributed with this source code.
 */

namespace Liip\ImagineBundle\Command;

use Liip\ImagineBundle\Imagine\Cache\CacheManager;
use Liip\ImagineBundle\Imagine\Data\DataManager;
use Liip\ImagineBundle\Imagine\Filter\FilterManager;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class ResolveCacheCommand extends ContainerAwareCommand
{
    protected function configure()
    {
        $this
            ->setName('liip:imagine:cache:resolve')
            ->setDescription('Resolve cache for given path and set of filters.')
            ->addArgument('paths', InputArgument::REQUIRED | InputArgument::IS_ARRAY,
                'Any number of image paths to act on.')
            ->addOption('filters', null, InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY,
                'List of filters to apply to passed images (Deprecated, use "filter").')
            ->addOption('filter', 'f', InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY,
                'List of filters to apply to passed images.')
            ->addOption('force', 'F', InputOption::VALUE_NONE,
                'Force image resolution regardless of cache.')
            ->addOption('as-script', 's', InputOption::VALUE_NONE,
                'Only print machine-parseable results.')
            ->setHelp(<<<'EOF'
The <comment>%command.name%</comment> command resolves the passed image(s) for the resolved
filter(s), outputting results using the following basic format:
  <info>- "image.ext[filter]" (resolved|cached|failed) as "path/to/cached/image.ext"</>

<comment># bin/console %command.name% --filter=thumb1 foo.ext bar.ext</comment>
Resolve <options=bold>both</> <comment>foo.ext</comment> and <comment>bar.ext</comment> using <comment>thumb1</comment> filter, outputting:
  <info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
  <info>- "bar.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/bar.ext"</>

<comment># bin/console %command.name% --filter=thumb1 --filter=thumb2 foo.ext</comment>
Resolve <comment>foo.ext</comment> using <options=bold>both</> <comment>thumb1</comment> and <comment>thumb2</comment> filters, outputting:
  <info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
  <info>- "foo.ext[thumb2]" resolved as "http://localhost/media/cache/thumb2/foo.ext"</>

<comment># bin/console %command.name% foo.ext</comment>
Resolve <comment>foo.ext</comment> using <options=bold>all configured filters</> (as none are specified), outputting:
  <info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
  <info>- "foo.ext[thumb2]" resolved as "http://localhost/media/cache/thumb2/foo.ext"</>

<comment># bin/console %command.name% --force --filter=thumb1 foo.ext</comment>
Resolve <comment>foo.ext</comment> using <comment>thumb1</comment> and <options=bold>force creation</> regardless of cache, outputting:
  <info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>

EOF
            );
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $force = $input->getOption('force');
        $paths = $input->getArgument('paths');
        $filters = $this->resolveInputFilters($input);
        $machine = $input->getOption('as-script');
        $failed = 0;

        $filterManager = $this->getFilterManager();
        $dataManager = $this->getDataManager();
        $cacheManager = $this->getCacheManager();

        if (0 === count($filters)) {
            $filters = array_keys($filterManager->getFilterConfiguration()->all());
        }

        $this->outputTitle($output, $machine);

        foreach ($paths as $path) {
            foreach ($filters as $filter) {
                $output->write(sprintf('- %s[%s] ', $path, $filter));

                try {
                    if ($force || !$cacheManager->isStored($path, $filter)) {
                        $cacheManager->store($filterManager->applyFilter($dataManager->find($filter, $path), $filter), $path, $filter);
                        $output->write('resolved: ');
                    } else {
                        $output->write('cached: ');
                    }

                    $output->writeln($cacheManager->resolve($path, $filter));
                } catch (\Exception $e) {
                    $output->writeln(sprintf('failed: %s', $e->getMessage()));
                    ++$failed;
                }
            }
        }

        $this->outputSummary($output, $machine, count($filters), count($paths), $failed);

        return 0 === $failed ? 0 : 255;
    }

    /**
     * @param OutputInterface $output
     * @param bool            $machine
     */
    private function outputTitle(OutputInterface $output, $machine)
    {
        if (!$machine) {
            $title = '[liip/imagine-bundle] Image Resolver';

            $output->writeln(sprintf('<info>%s</info>', $title));
            $output->writeln(str_repeat('=', strlen($title)));
            $output->writeln('');
        }
    }

    /**
     * @param OutputInterface $output
     * @param bool            $machine
     * @param int             $filters
     * @param int             $paths
     * @param int             $failed
     */
    private function outputSummary(OutputInterface $output, $machine, $filters, $paths, $failed)
    {
        if (!$machine) {
            $operations = ($filters * $paths) - $failed;

            $output->writeln('');
            $output->writeln(vsprintf('Completed %d %s (%d %s on %d %s) <fg=red;options=bold>%s</>', array(
                $operations,
                $this->pluralizeWord($operations, 'operation'),
                $filters,
                $this->pluralizeWord($filters, 'filter'),
                $paths,
                $this->pluralizeWord($paths, 'image'),
                0 === $failed ? '' : sprintf('[encountered %d %s]', $failed, $this->pluralizeWord($failed, 'failure')),
            )));
        }
    }

    /**
     * @param int    $count
     * @param string $singular
     * @param string $pluralEnding
     *
     * @return string
     */
    private function pluralizeWord($count, $singular, $pluralEnding = 's')
    {
        return 1 === $count ? $singular : $singular.$pluralEnding;
    }

    /**
     * @param InputInterface $input
     *
     * @return array|mixed
     */
    private function resolveInputFilters(InputInterface $input)

    {
        $filters = $input->getOption('filter');

        if (count($filtersDeprecated = $input->getOption('filters'))) {
            $filters = array_merge($filters, $filtersDeprecated);
            @trigger_error('As of 1.9, use of the "--filters" option has been deprecated in favor of "--filter" and will be removed in 2.0.', E_USER_DEPRECATED);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
        }

        return $filters;
    }

    /**
     * @return FilterManager
     */
    private function getFilterManager()
    {
        return $this->getContainer()->get('liip_imagine.filter.manager');
    }

    /**
     * @return DataManager
     */
    private function getDataManager()
    {
        return $this->getContainer()->get('liip_imagine.data.manager');
    }

    /**
     * @return CacheManager
     */
    private function getCacheManager()
    {
        return $this->getContainer()->get('liip_imagine.cache.manager');
    }
}


1		<?php
2
3		/*
4		* This file is part of the `liip/LiipImagineBundle` project.
5		*
6		* (c) https://github.com/liip/LiipImagineBundle/graphs/contributors
7		*
8		* For the full copyright and license information, please view the LICENSE.md
9		* file that was distributed with this source code.
10		*/
11
12		namespace Liip\ImagineBundle\Command;
13
14		use Liip\ImagineBundle\Imagine\Cache\CacheManager;
15		use Liip\ImagineBundle\Imagine\Data\DataManager;
16		use Liip\ImagineBundle\Imagine\Filter\FilterManager;
17		use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
18		use Symfony\Component\Console\Input\InputArgument;
19		use Symfony\Component\Console\Input\InputInterface;
20		use Symfony\Component\Console\Input\InputOption;
21		use Symfony\Component\Console\Output\OutputInterface;
22
23		class ResolveCacheCommand extends ContainerAwareCommand
24		{
25		protected function configure()
26		{
27		$this
28		->setName('liip:imagine:cache:resolve')
29		->setDescription('Resolve cache for given path and set of filters.')
30		->addArgument('paths', InputArgument::REQUIRED \| InputArgument::IS_ARRAY,
31		'Any number of image paths to act on.')
32		->addOption('filters', null, InputOption::VALUE_OPTIONAL \| InputOption::VALUE_IS_ARRAY,
33		'List of filters to apply to passed images (Deprecated, use "filter").')
34		->addOption('filter', 'f', InputOption::VALUE_OPTIONAL \| InputOption::VALUE_IS_ARRAY,
35		'List of filters to apply to passed images.')
36		->addOption('force', 'F', InputOption::VALUE_NONE,
37		'Force image resolution regardless of cache.')
38		->addOption('as-script', 's', InputOption::VALUE_NONE,
39		'Only print machine-parseable results.')
40		->setHelp(<<<'EOF'
41		The <comment>%command.name%</comment> command resolves the passed image(s) for the resolved
42		filter(s), outputting results using the following basic format:
43		<info>- "image.ext[filter]" (resolved\|cached\|failed) as "path/to/cached/image.ext"</>
44
45		<comment># bin/console %command.name% --filter=thumb1 foo.ext bar.ext</comment>
46		Resolve <options=bold>both</> <comment>foo.ext</comment> and <comment>bar.ext</comment> using <comment>thumb1</comment> filter, outputting:
47		<info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
48		<info>- "bar.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/bar.ext"</>
49
50		<comment># bin/console %command.name% --filter=thumb1 --filter=thumb2 foo.ext</comment>
51		Resolve <comment>foo.ext</comment> using <options=bold>both</> <comment>thumb1</comment> and <comment>thumb2</comment> filters, outputting:
52		<info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
53		<info>- "foo.ext[thumb2]" resolved as "http://localhost/media/cache/thumb2/foo.ext"</>
54
55		<comment># bin/console %command.name% foo.ext</comment>
56		Resolve <comment>foo.ext</comment> using <options=bold>all configured filters</> (as none are specified), outputting:
57		<info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
58		<info>- "foo.ext[thumb2]" resolved as "http://localhost/media/cache/thumb2/foo.ext"</>
59
60		<comment># bin/console %command.name% --force --filter=thumb1 foo.ext</comment>
61		Resolve <comment>foo.ext</comment> using <comment>thumb1</comment> and <options=bold>force creation</> regardless of cache, outputting:
62		<info>- "foo.ext[thumb1]" resolved as "http://localhost/media/cache/thumb1/foo.ext"</>
63
64		EOF
65		);
66		}
67
68		protected function execute(InputInterface $input, OutputInterface $output)
69		{
70		$force = $input->getOption('force');
71		$paths = $input->getArgument('paths');
72		$filters = $this->resolveInputFilters($input);
73		$machine = $input->getOption('as-script');
74		$failed = 0;
75
76		$filterManager = $this->getFilterManager();
77		$dataManager = $this->getDataManager();
78		$cacheManager = $this->getCacheManager();
79
80		if (0 === count($filters)) {
81		$filters = array_keys($filterManager->getFilterConfiguration()->all());
82		}
83
84		$this->outputTitle($output, $machine);
85
86		foreach ($paths as $path) {
87		foreach ($filters as $filter) {
88		$output->write(sprintf('- %s[%s] ', $path, $filter));
89
90		try {
91		if ($force \|\| !$cacheManager->isStored($path, $filter)) {
92		$cacheManager->store($filterManager->applyFilter($dataManager->find($filter, $path), $filter), $path, $filter);
93		$output->write('resolved: ');
94		} else {
95		$output->write('cached: ');
96		}
97
98		$output->writeln($cacheManager->resolve($path, $filter));
99		} catch (\Exception $e) {
100		$output->writeln(sprintf('failed: %s', $e->getMessage()));
101		++$failed;
102		}
103		}
104		}
105
106		$this->outputSummary($output, $machine, count($filters), count($paths), $failed);
107
108		return 0 === $failed ? 0 : 255;
109		}
110
111		/**
112		* @param OutputInterface $output
113		* @param bool $machine
114		*/
115		private function outputTitle(OutputInterface $output, $machine)
116		{
117		if (!$machine) {
118		$title = '[liip/imagine-bundle] Image Resolver';
119
120		$output->writeln(sprintf('<info>%s</info>', $title));
121		$output->writeln(str_repeat('=', strlen($title)));
122		$output->writeln('');
123		}
124		}
125
126		/**
127		* @param OutputInterface $output
128		* @param bool $machine
129		* @param int $filters
130		* @param int $paths
131		* @param int $failed
132		*/
133		private function outputSummary(OutputInterface $output, $machine, $filters, $paths, $failed)
134		{
135		if (!$machine) {
136		$operations = ($filters * $paths) - $failed;
137
138		$output->writeln('');
139		$output->writeln(vsprintf('Completed %d %s (%d %s on %d %s) <fg=red;options=bold>%s</>', array(
140		$operations,
141		$this->pluralizeWord($operations, 'operation'),
142		$filters,
143		$this->pluralizeWord($filters, 'filter'),
144		$paths,
145		$this->pluralizeWord($paths, 'image'),
146		0 === $failed ? '' : sprintf('[encountered %d %s]', $failed, $this->pluralizeWord($failed, 'failure')),
147		)));
148		}
149		}
150
151		/**
152		* @param int $count
153		* @param string $singular
154		* @param string $pluralEnding
155		*
156		* @return string
157		*/
158		private function pluralizeWord($count, $singular, $pluralEnding = 's')
159		{
160		return 1 === $count ? $singular : $singular.$pluralEnding;
161		}
162
163		/**
164		* @param InputInterface $input
165		*
166		* @return array\|mixed
167		*/
168	View Code Duplication	private function resolveInputFilters(InputInterface $input)
		0 ignored issues – show Duplication introduced 2017-08-31 00:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
169		{
170		$filters = $input->getOption('filter');
171
172		if (count($filtersDeprecated = $input->getOption('filters'))) {
173		$filters = array_merge($filters, $filtersDeprecated);
174		@trigger_error('As of 1.9, use of the "--filters" option has been deprecated in favor of "--filter" and will be removed in 2.0.', E_USER_DEPRECATED);
		0 ignored issues – show Security Best Practice introduced 2017-08-31 00:12 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
175		}
176
177		return $filters;
178		}
179
180		/**
181		* @return FilterManager
182		*/
183		private function getFilterManager()
184		{
185		return $this->getContainer()->get('liip_imagine.filter.manager');
186		}
187
188		/**
189		* @return DataManager
190		*/
191		private function getDataManager()
192		{
193		return $this->getContainer()->get('liip_imagine.data.manager');
194		}
195
196		/**
197		* @return CacheManager
198		*/
199		private function getCacheManager()
200		{
201		return $this->getContainer()->get('liip_imagine.cache.manager');
202		}
203		}
204

liip / LiipImagineBundle

Pull Request — 1.0 (#967)

ResolveCacheCommand::execute() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like