CommandsHelper::createCloud() - Code Metrics - Inspection of "Precise box collision is now possible" - sixty-nine/php-cloud-lib - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( a0e7d0...b649da )

by Dan

created 2017-04-04 16:17 UTC

CommandsHelper::createCloud() D

↳ Parent: CommandsHelper

Complexity

Conditions	10
Paths	35

Size

Total Lines	95
Code Lines	58

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	95
rs	4.983
c	1
b	0
f	0
cc	10
eloc	58
nc	35
nop	2

How to fix Long Method Complexity

<?php

namespace SixtyNine\Cloud\Command;

use Imagine\Image\ImageInterface;
use SixtyNine\Cloud\Builder\CloudBuilder;
use SixtyNine\Cloud\Builder\FiltersBuilder;
use SixtyNine\Cloud\Builder\PalettesBuilder;
use SixtyNine\Cloud\Builder\WordsListBuilder;
use SixtyNine\Cloud\Color\ColorGeneratorInterface;
use SixtyNine\Cloud\Color\RandomColorGenerator;
use SixtyNine\Cloud\Color\RotateColorGenerator;
use SixtyNine\Cloud\Factory\FontsFactory;
use SixtyNine\Cloud\Factory\PlacerFactory;
use SixtyNine\Cloud\FontSize\BoostFontSizeGenerator;
use SixtyNine\Cloud\FontSize\DimFontSizeGenerator;
use SixtyNine\Cloud\FontSize\FontSizeGeneratorInterface;
use SixtyNine\Cloud\FontSize\LinearFontSizeGenerator;
use SixtyNine\Cloud\Placer\PlacerInterface;
use SixtyNine\Cloud\Renderer\CloudRenderer;
use Symfony\Component\Console\Input\InputInterface;

class CommandsHelper
{
    protected $allowedFontSizeBoosts = array('linear', 'dim', 'boost');
    protected $allowedPaletteTypes = array('cycle', 'random');
    protected $allowedOutputFormats = array('gif', 'jpeg', 'png');

    /**
     * @param string $name
     * @return PlacerInterface
     * @throws \InvalidArgumentException
     */
    public function getPlacer($name)
    {
        $availablePlacers = PlacerFactory::getInstance()->getPlacersNames();

        if ($name) {
            if (!in_array($name, $availablePlacers)) {
                throw new \InvalidArgumentException('Word placer not found: ' . $name);
            }
            return $name;
        }

        if (!count($availablePlacers)) {
            throw new \InvalidArgumentException('No word placers available');
        }

        return $availablePlacers[0];
    }

    /**
     * @param FontsFactory $factory
     * @param string $font
     * @return string
     * @throws \InvalidArgumentException
     */
    public function getFont(FontsFactory $factory, $font)
    {
        if ($font) {
            return $font;
        }

        if (0 === count($factory->getFonts())) {
            throw new \InvalidArgumentException('No font file found');
        }

        return $factory->getFonts()[0];
    }

    /**
     * @param string $type
     * @return FontSizeGeneratorInterface
     * @throws \InvalidArgumentException
     */
    public function getFontSizeGenerator($type = 'linear')
    {
        if (!in_array($type, $this->allowedFontSizeBoosts)) {
            throw new \InvalidArgumentException('Invalid font size boost: ' . $type);
        }

        $generatorClass = LinearFontSizeGenerator::class;
        if ($type === 'dim') {
            $generatorClass = DimFontSizeGenerator::class;
        }
        if ($type === 'boost') {
            $generatorClass = BoostFontSizeGenerator::class;
        }

        return new $generatorClass();
    }

    /**
     * @param string $paletteName
     * @param string $paletteType
     * @param string $palettesFile
     * @return bool|ColorGeneratorInterface
     * @throws \InvalidArgumentException
     */
    public function getColorGenerator($paletteName, $paletteType, $palettesFile = null)
    {
        if ($paletteName && $paletteType) {

            if (!in_array($paletteType, $this->allowedPaletteTypes)) {
                throw new \InvalidArgumentException('Palette type must be either "cycle" or "random"');
            }

            $file = $palettesFile
                ? $palettesFile
                : __DIR__ . '/../Resources/palettes.yml'
            ;
            $paletteBuilder = PalettesBuilder::create()->importPalettes($file);

            $palette = $paletteBuilder->getNamedPalette($paletteName);
            $generatorClass = ($paletteType === 'cycle')
                ? RotateColorGenerator::class
                : RandomColorGenerator::class
            ;
            return new $generatorClass($palette);
        }

        return false;
    }

    /**
     * @param ImageInterface $image
     * @param string $outputFormat
     * @param string $outputFile
     * @throws \InvalidArgumentException
     */
    public function output(ImageInterface $image, $outputFormat, $outputFile = null)
    {
        if (!in_array($outputFormat, $this->allowedOutputFormats)) {
            throw new \InvalidArgumentException('Invalid output format: ' . $outputFormat);
        }

        if ($outputFile) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $image->save($outputFile, array('format' => $outputFormat));
            return;
        }

        echo $image->get($outputFormat);
    }

    /**
     * @param CloudBuilder $cloudBuilder
     * @param FontsFactory $factory
     * @param PlacerInterface $placer
     * @param bool $renderBoxes
     * @return \Imagine\Gd\Image|ImageInterface
     */
    protected function render(CloudBuilder $cloudBuilder, FontsFactory $factory, PlacerInterface $placer = null, $renderBoxes = false)
    {
        $renderer = new CloudRenderer();
        $image = $renderer->render($cloudBuilder->build(), $factory, $renderBoxes);

        if ($placer) {
            $renderer->renderUsher($image, $placer, '#FF0000');
        }

        return $image;
    }

    public function getFilterBuilder(
        $minWordLength,
        $maxWordLength,
        $changeCase = null,
        $noRemoveNumbers = false,
        $noRemoveUnwanted = false,
        $noRemoveTrailing = false
    ) {
        $filtersBuilder = FiltersBuilder::create()
            ->setMinLength($minWordLength)
            ->setMaxLength($maxWordLength)
            ->setRemoveNumbers(!$noRemoveNumbers)
            ->setRemoveUnwanted(!$noRemoveTrailing)
            ->setRemoveTrailing(!$noRemoveUnwanted)
        ;

        if ($changeCase && in_array($changeCase, $filtersBuilder->getAllowedCase())) {
            $filtersBuilder->setCase($changeCase);
        }

        return $filtersBuilder;
    }

    /**
     * @param string $type
     * @param InputInterface $input
     * @throws \InvalidArgumentException
     */
    public function createCloud($type, InputInterface $input)
    {
        if (!in_array($type, array('from-url', 'from-file'))) {
            throw new \InvalidArgumentException('Invalid type for createCloud: ' . $type);
        }

        // Build the filters
        $filtersBuilder = $this->getFilterBuilder(
            $input->getOption('min-word-length'),
            $input->getOption('max-word-length'),
            $input->getOption('case'),
            $input->getOption('no-remove-numbers'),
            $input->getOption('no-remove-unwanted'),
            $input->getOption('no-remove-trailing')
        );

        // Create a placer
        $placerName = $this->getPlacer($input->getOption('placer'));
        $placer = PlacerFactory::getInstance()->getPlacer(
            $placerName,
            $input->getOption('width'),
            $input->getOption('height')
        );

        // Get the font file
        $fontsPath = $input->getOption('fonts-path')
            ? realpath($input->getOption('fonts-path'))
            : constant('BASE_PATH') . '/fonts'
        ;
        $factory = FontsFactory::create($fontsPath);
        $font = $this->getFont($factory, $input->getOption('font'));

        // Create the list builder
        $listBuilder = WordsListBuilder::create()
            ->setMaxWords($input->getOption('max-word-count'))
            ->setFilters($filtersBuilder->build())
            ->randomizeOrientation($input->getOption('vertical-probability'))
        ;

        if ($type === 'from-file') {
            $file = $input->getArgument('file');
            if (!file_exists($file)) {
                throw new \InvalidArgumentException('File not found: ' . $file);
            }
            $listBuilder->importWords(file_get_contents($file));
        } else {
            $listBuilder->importUrl($input->getArgument('url'));
        }

        $sortBy = $input->getOption('sort-by');
        $sortOrder = $input->getOption('sort-order');

        if ($sortBy && $sortOrder) {
            $listBuilder->sort($sortBy, $sortOrder);
        }

        // Apply a color generator if needed
        $colorGenerator = $this->getColorGenerator(
            $input->getOption('palette'),
            $input->getOption('palette-type'),
            $input->getOption('palettes-file')
        );

        if ($colorGenerator) {
            $listBuilder->randomizeColors($colorGenerator);
        }

        // Build the list
        $list = $listBuilder->build('list');

        // Create a cloud builder
        $cloudBuilder = CloudBuilder::create($factory)
            ->setBackgroundColor($input->getOption('background-color'))
            ->setDimension($input->getOption('width'), $input->getOption('height'))
            ->setFont($font)
            ->setFontSizes($input->getOption('min-font-size'), $input->getOption('max-font-size'))
            ->setPlacer($placerName)
            ->setSizeGenerator($this->getFontSizeGenerator($input->getOption('font-size-boost')))
            ->useList($list)
        ;

        if ($input->getOption('precise')) {
            $cloudBuilder->setPrecise();
        }

        // Render the cloud and show the bounding boxes and the usher if needed
        $image = $this->render(
            $cloudBuilder,
            $factory,
            $input->getOption('render-usher') ? $placer : null,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $input->getOption('render-boxes')
        );

        $this->output($image, $input->getOption('format'), $input->getOption('save-to-file'));
    }
}


1			<?php
2
3			namespace SixtyNine\Cloud\Command;
4
5			use Imagine\Image\ImageInterface;
6			use SixtyNine\Cloud\Builder\CloudBuilder;
7			use SixtyNine\Cloud\Builder\FiltersBuilder;
8			use SixtyNine\Cloud\Builder\PalettesBuilder;
9			use SixtyNine\Cloud\Builder\WordsListBuilder;
10			use SixtyNine\Cloud\Color\ColorGeneratorInterface;
11			use SixtyNine\Cloud\Color\RandomColorGenerator;
12			use SixtyNine\Cloud\Color\RotateColorGenerator;
13			use SixtyNine\Cloud\Factory\FontsFactory;
14			use SixtyNine\Cloud\Factory\PlacerFactory;
15			use SixtyNine\Cloud\FontSize\BoostFontSizeGenerator;
16			use SixtyNine\Cloud\FontSize\DimFontSizeGenerator;
17			use SixtyNine\Cloud\FontSize\FontSizeGeneratorInterface;
18			use SixtyNine\Cloud\FontSize\LinearFontSizeGenerator;
19			use SixtyNine\Cloud\Placer\PlacerInterface;
20			use SixtyNine\Cloud\Renderer\CloudRenderer;
21			use Symfony\Component\Console\Input\InputInterface;
22
23			class CommandsHelper
24			{
25			protected $allowedFontSizeBoosts = array('linear', 'dim', 'boost');
26			protected $allowedPaletteTypes = array('cycle', 'random');
27			protected $allowedOutputFormats = array('gif', 'jpeg', 'png');
28
29			/**
30			* @param string $name
31			* @return PlacerInterface
32			* @throws \InvalidArgumentException
33			*/
34			public function getPlacer($name)
35			{
36			$availablePlacers = PlacerFactory::getInstance()->getPlacersNames();
37
38			if ($name) {
39			if (!in_array($name, $availablePlacers)) {
40			throw new \InvalidArgumentException('Word placer not found: ' . $name);
41			}
42			return $name;
43			}
44
45			if (!count($availablePlacers)) {
46			throw new \InvalidArgumentException('No word placers available');
47			}
48
49			return $availablePlacers[0];
50			}
51
52			/**
53			* @param FontsFactory $factory
54			* @param string $font
55			* @return string
56			* @throws \InvalidArgumentException
57			*/
58			public function getFont(FontsFactory $factory, $font)
59			{
60			if ($font) {
61			return $font;
62			}
63
64			if (0 === count($factory->getFonts())) {
65			throw new \InvalidArgumentException('No font file found');
66			}
67
68			return $factory->getFonts()[0];
69			}
70
71			/**
72			* @param string $type
73			* @return FontSizeGeneratorInterface
74			* @throws \InvalidArgumentException
75			*/
76			public function getFontSizeGenerator($type = 'linear')
77			{
78			if (!in_array($type, $this->allowedFontSizeBoosts)) {
79			throw new \InvalidArgumentException('Invalid font size boost: ' . $type);
80			}
81
82			$generatorClass = LinearFontSizeGenerator::class;
83			if ($type === 'dim') {
84			$generatorClass = DimFontSizeGenerator::class;
85			}
86			if ($type === 'boost') {
87			$generatorClass = BoostFontSizeGenerator::class;
88			}
89
90			return new $generatorClass();
91			}
92
93			/**
94			* @param string $paletteName
95			* @param string $paletteType
96			* @param string $palettesFile
97			* @return bool\|ColorGeneratorInterface
98			* @throws \InvalidArgumentException
99			*/
100			public function getColorGenerator($paletteName, $paletteType, $palettesFile = null)
101			{
102			if ($paletteName && $paletteType) {
103
104			if (!in_array($paletteType, $this->allowedPaletteTypes)) {
105			throw new \InvalidArgumentException('Palette type must be either "cycle" or "random"');
106			}
107
108			$file = $palettesFile
109			? $palettesFile
110			: __DIR__ . '/../Resources/palettes.yml'
111			;
112			$paletteBuilder = PalettesBuilder::create()->importPalettes($file);
113
114			$palette = $paletteBuilder->getNamedPalette($paletteName);
115			$generatorClass = ($paletteType === 'cycle')
116			? RotateColorGenerator::class
117			: RandomColorGenerator::class
118			;
119			return new $generatorClass($palette);
120			}
121
122			return false;
123			}
124
125			/**
126			* @param ImageInterface $image
127			* @param string $outputFormat
128			* @param string $outputFile
129			* @throws \InvalidArgumentException
130			*/
131			public function output(ImageInterface $image, $outputFormat, $outputFile = null)
132			{
133			if (!in_array($outputFormat, $this->allowedOutputFormats)) {
134			throw new \InvalidArgumentException('Invalid output format: ' . $outputFormat);
135			}
136
137			if ($outputFile) {
			0 ignored issues – show Bug Best Practice introduced 2017-04-03 14:23 UTC by Report Bug Copy Issue Report The expression `$outputFile` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
138			$image->save($outputFile, array('format' => $outputFormat));
139			return;
140			}
141
142			echo $image->get($outputFormat);
143			}
144
145			/**
146			* @param CloudBuilder $cloudBuilder
147			* @param FontsFactory $factory
148			* @param PlacerInterface $placer
149			* @param bool $renderBoxes
150			* @return \Imagine\Gd\Image\|ImageInterface
151			*/
152			protected function render(CloudBuilder $cloudBuilder, FontsFactory $factory, PlacerInterface $placer = null, $renderBoxes = false)
153			{
154			$renderer = new CloudRenderer();
155			$image = $renderer->render($cloudBuilder->build(), $factory, $renderBoxes);
156
157			if ($placer) {
158			$renderer->renderUsher($image, $placer, '#FF0000');
159			}
160
161			return $image;
162			}
163
164			public function getFilterBuilder(
165			$minWordLength,
166			$maxWordLength,
167			$changeCase = null,
168			$noRemoveNumbers = false,
169			$noRemoveUnwanted = false,
170			$noRemoveTrailing = false
171			) {
172			$filtersBuilder = FiltersBuilder::create()
173			->setMinLength($minWordLength)
174			->setMaxLength($maxWordLength)
175			->setRemoveNumbers(!$noRemoveNumbers)
176			->setRemoveUnwanted(!$noRemoveTrailing)
177			->setRemoveTrailing(!$noRemoveUnwanted)
178			;
179
180			if ($changeCase && in_array($changeCase, $filtersBuilder->getAllowedCase())) {
181			$filtersBuilder->setCase($changeCase);
182			}
183
184			return $filtersBuilder;
185			}
186
187			/**
188			* @param string $type
189			* @param InputInterface $input
190			* @throws \InvalidArgumentException
191			*/
192			public function createCloud($type, InputInterface $input)
193			{
194			if (!in_array($type, array('from-url', 'from-file'))) {
195			throw new \InvalidArgumentException('Invalid type for createCloud: ' . $type);
196			}
197
198			// Build the filters
199			$filtersBuilder = $this->getFilterBuilder(
200			$input->getOption('min-word-length'),
201			$input->getOption('max-word-length'),
202			$input->getOption('case'),
203			$input->getOption('no-remove-numbers'),
204			$input->getOption('no-remove-unwanted'),
205			$input->getOption('no-remove-trailing')
206			);
207
208			// Create a placer
209			$placerName = $this->getPlacer($input->getOption('placer'));
210			$placer = PlacerFactory::getInstance()->getPlacer(
211			$placerName,
212			$input->getOption('width'),
213			$input->getOption('height')
214			);
215
216			// Get the font file
217			$fontsPath = $input->getOption('fonts-path')
218			? realpath($input->getOption('fonts-path'))
219			: constant('BASE_PATH') . '/fonts'
220			;
221			$factory = FontsFactory::create($fontsPath);
222			$font = $this->getFont($factory, $input->getOption('font'));
223
224			// Create the list builder
225			$listBuilder = WordsListBuilder::create()
226			->setMaxWords($input->getOption('max-word-count'))
227			->setFilters($filtersBuilder->build())
228			->randomizeOrientation($input->getOption('vertical-probability'))
229			;
230
231			if ($type === 'from-file') {
232			$file = $input->getArgument('file');
233			if (!file_exists($file)) {
234			throw new \InvalidArgumentException('File not found: ' . $file);
235			}
236			$listBuilder->importWords(file_get_contents($file));
237			} else {
238			$listBuilder->importUrl($input->getArgument('url'));
239			}
240
241			$sortBy = $input->getOption('sort-by');
242			$sortOrder = $input->getOption('sort-order');
243
244			if ($sortBy && $sortOrder) {
245			$listBuilder->sort($sortBy, $sortOrder);
246			}
247
248			// Apply a color generator if needed
249			$colorGenerator = $this->getColorGenerator(
250			$input->getOption('palette'),
251			$input->getOption('palette-type'),
252			$input->getOption('palettes-file')
253			);
254
255			if ($colorGenerator) {
256			$listBuilder->randomizeColors($colorGenerator);
257			}
258
259			// Build the list
260			$list = $listBuilder->build('list');
261
262			// Create a cloud builder
263			$cloudBuilder = CloudBuilder::create($factory)
264			->setBackgroundColor($input->getOption('background-color'))
265			->setDimension($input->getOption('width'), $input->getOption('height'))
266			->setFont($font)
267			->setFontSizes($input->getOption('min-font-size'), $input->getOption('max-font-size'))
268			->setPlacer($placerName)
269			->setSizeGenerator($this->getFontSizeGenerator($input->getOption('font-size-boost')))
270			->useList($list)
271			;
272
273			if ($input->getOption('precise')) {
274			$cloudBuilder->setPrecise();
275			}
276
277			// Render the cloud and show the bounding boxes and the usher if needed
278			$image = $this->render(
279			$cloudBuilder,
280			$factory,
281			$input->getOption('render-usher') ? $placer : null,
			0 ignored issues – show Bug introduced 2017-04-03 16:40 UTC by Report Bug Copy Issue Report It seems like `$input->getOption('rende...sher') ? $placer : null` can also be of type `object`; however, `SixtyNine\Cloud\Command\CommandsHelper::render()` does only seem to accept `null\|object<SixtyNine\Cl...Placer\PlacerInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
282			$input->getOption('render-boxes')
283			);
284
285			$this->output($image, $input->getOption('format'), $input->getOption('save-to-file'));
286			}
287			}
288

sixty-nine / php-cloud-lib

Push — master ( a0e7d0...b649da )

CommandsHelper::createCloud() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like