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

Completed

Pull Request — 1.0 (#967)

by Rob

created 2017-07-28 05:24 UTC

ResolveCacheCommand::outputTitle() A

↳ Parent: ResolveCacheCommand

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	6
nc	2
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('machine', 'm', 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('machine');
        $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(sprintf('as "%s"', $cacheManager->resolve($path, $filter)));
                } catch (\Exception $e) {
                    $output->writeln(sprintf('failed as "%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 (cache 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.8, 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('machine', 'm', 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('machine');
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(sprintf('as "%s"', $cacheManager->resolve($path, $filter)));
99			} catch (\Exception $e) {
100			$output->writeln(sprintf('failed as "%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 (cache 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			private function resolveInputFilters(InputInterface $input)
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.8, 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-07-28 05:26 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::outputTitle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like