Conversion::nonOptimized() - Code Metrics - Inspection of "Make compatible with Laravel 5.5 (#735)" - spatie/laravel-medialibrary - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 42602c...0491a1 )

by Freek

created 2017-08-30 11:44 UTC

Conversion::nonOptimized() A

↳ Parent: Conversion

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	0

<?php

namespace Spatie\MediaLibrary\Conversion;

use BadMethodCallException;
use Spatie\Image\Manipulations;

/** @mixin \Spatie\Image\Manipulations */
class Conversion
{
    /** @var string */
    protected $name = '';

    /** @var int */
    protected $extractVideoFrameAtSecond = 0;

    /** @var \Spatie\Image\Manipulations */
    protected $manipulations;

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

    /** @var bool */
    protected $performOnQueue = true;

    /** @var bool */
    protected $keepOriginalImageFormat = false;

    public function __construct(string $name)
    {
        $this->name = $name;

        $this->manipulations = (new Manipulations())
            ->optimize(config('medialibrary.image_optimizers'))
            ->format('jpg');
    }

    public static function create(string $name)
    {
        return new static($name);
    }

    public function getName(): string
    {
        return $this->name;
    }

    /*
     * Set the timecode in seconds to extract a video thumbnail.
     * Only used on video media.
     */
    public function extractVideoFrameAtSecond(int $timecode): Conversion
    {
        $this->extractVideoFrameAtSecond = $timecode;

        return $this;
    }

    public function getExtractVideoFrameAtSecond(): int
    {
        return $this->extractVideoFrameAtSecond;
    }

    public function keepOriginalImageFormat(): Conversion
    {
        $this->keepOriginalImageFormat = true;

        return $this;
    }

    public function shouldKeepOriginalImageFormat(): Bool
    {
        return $this->keepOriginalImageFormat;
    }

    public function getManipulations(): Manipulations
    {
        return $this->manipulations;
    }

    public function removeManipulation(string $manipulationName)
    {
        $this->manipulations->removeManipulation($manipulationName);

        return $this;
    }

    public function __call($name, $arguments)
    {
        if (! method_exists($this->manipulations, $name)) {
            throw new BadMethodCallException("Manipulation `{$name}` does not exist");
        }

        $this->manipulations->$name(...$arguments);

        return $this;
    }

    /**
     * Set the manipulations for this conversion.
     *
     * @param \Spatie\Image\Manipulations|closure $manipulations
     *
     * @return $this
     */
    public function setManipulations($manipulations)
    {
        if ($manipulations instanceof Manipulations) {
            $this->manipulations = $this->manipulations->mergeManipulations($manipulations);
        }

        if (is_callable($manipulations)) {
            $manipulations($this->manipulations);
        }

        return $this;
    }

    /**
     * Add the given manipulations as the first ones.
     *
     * @param \Spatie\Image\Manipulations $manipulations
     *
     * @return $this
     */
    public function addAsFirstManipulations(Manipulations $manipulations)
    {
        $manipulationSequence = $manipulations->getManipulationSequence()->toArray();

        $this->manipulations
            ->getManipulationSequence()
            ->mergeArray($manipulationSequence);

        return $this;
    }

    /**
     * Set the collection names on which this conversion must be performed.
     *
     * @param  $collectionNames
     *
     * @return $this
     */
    public function performOnCollections(...$collectionNames)
    {
        $this->performOnCollections = $collectionNames;

        return $this;
    }

    /*
     * Determine if this conversion should be performed on the given
     * collection.
     */
    public function shouldBePerformedOn(string $collectionName): bool
    {
        //if no collections were specified, perform conversion on all collections
        if (! count($this->performOnCollections)) {
            return true;
        }

        if (in_array('*', $this->performOnCollections)) {
            return true;
        }

        return in_array($collectionName, $this->performOnCollections);
    }

    /**
     * Mark this conversion as one that should be queued.
     *
     * @return $this
     */
    public function queued()
    {
        $this->performOnQueue = true;

        return $this;
    }

    /**
     * Mark this conversion as one that should not be queued.
     *
     * @return $this
     */
    public function nonQueued()
    {
        $this->performOnQueue = false;

        return $this;
    }

    /**
     * Avoid optimization of the converted image.
     *
     * @return $this
     */
    public function nonOptimized()
    {
        $this->removeManipulation('optimize');

        return $this;
    }

    /*
     * Determine if the conversion should be queued.
     */
    public function shouldBeQueued(): bool
    {
        return $this->performOnQueue;
    }

    /*
     * Get the extension that the result of this conversion must have.
     */
    public function getResultExtension(string $originalFileExtension = ''): string
    {
        if ($this->shouldKeepOriginalImageFormat()) {
            return $originalFileExtension;
        }

        if ($manipulationArgument = $this->manipulations->getManipulationArgument('format')) {
            return $manipulationArgument;
        }

        return $originalFileExtension;
    }
}


1			<?php
2
3			namespace Spatie\MediaLibrary\Conversion;
4
5			use BadMethodCallException;
6			use Spatie\Image\Manipulations;
7
8			/** @mixin \Spatie\Image\Manipulations */
9			class Conversion
10			{
11			/** @var string */
12			protected $name = '';
13
14			/** @var int */
15			protected $extractVideoFrameAtSecond = 0;
16
17			/** @var \Spatie\Image\Manipulations */
18			protected $manipulations;
19
20			/** @var array */
21			protected $performOnCollections = [];
22
23			/** @var bool */
24			protected $performOnQueue = true;
25
26			/** @var bool */
27			protected $keepOriginalImageFormat = false;
28
29			public function __construct(string $name)
30			{
31			$this->name = $name;
32
33			$this->manipulations = (new Manipulations())
34			->optimize(config('medialibrary.image_optimizers'))
35			->format('jpg');
36			}
37
38			public static function create(string $name)
39			{
40			return new static($name);
41			}
42
43			public function getName(): string
44			{
45			return $this->name;
46			}
47
48			/*
49			* Set the timecode in seconds to extract a video thumbnail.
50			* Only used on video media.
51			*/
52			public function extractVideoFrameAtSecond(int $timecode): Conversion
53			{
54			$this->extractVideoFrameAtSecond = $timecode;
55
56			return $this;
57			}
58
59			public function getExtractVideoFrameAtSecond(): int
60			{
61			return $this->extractVideoFrameAtSecond;
62			}
63
64			public function keepOriginalImageFormat(): Conversion
65			{
66			$this->keepOriginalImageFormat = true;
67
68			return $this;
69			}
70
71			public function shouldKeepOriginalImageFormat(): Bool
72			{
73			return $this->keepOriginalImageFormat;
74			}
75
76			public function getManipulations(): Manipulations
77			{
78			return $this->manipulations;
79			}
80
81			public function removeManipulation(string $manipulationName)
82			{
83			$this->manipulations->removeManipulation($manipulationName);
84
85			return $this;
86			}
87
88			public function __call($name, $arguments)
89			{
90			if (! method_exists($this->manipulations, $name)) {
91			throw new BadMethodCallException("Manipulation `{$name}` does not exist");
92			}
93
94			$this->manipulations->$name(...$arguments);
95
96			return $this;
97			}
98
99			/**
100			* Set the manipulations for this conversion.
101			*
102			* @param \Spatie\Image\Manipulations\|closure $manipulations
103			*
104			* @return $this
105			*/
106			public function setManipulations($manipulations)
107			{
108			if ($manipulations instanceof Manipulations) {
109			$this->manipulations = $this->manipulations->mergeManipulations($manipulations);
110			}
111
112			if (is_callable($manipulations)) {
113			$manipulations($this->manipulations);
114			}
115
116			return $this;
117			}
118
119			/**
120			* Add the given manipulations as the first ones.
121			*
122			* @param \Spatie\Image\Manipulations $manipulations
123			*
124			* @return $this
125			*/
126			public function addAsFirstManipulations(Manipulations $manipulations)
127			{
128			$manipulationSequence = $manipulations->getManipulationSequence()->toArray();
129
130			$this->manipulations
131			->getManipulationSequence()
132			->mergeArray($manipulationSequence);
133
134			return $this;
135			}
136
137			/**
138			* Set the collection names on which this conversion must be performed.
139			*
140			* @param $collectionNames
141			*
142			* @return $this
143			*/
144			public function performOnCollections(...$collectionNames)
145			{
146			$this->performOnCollections = $collectionNames;
147
148			return $this;
149			}
150
151			/*
152			* Determine if this conversion should be performed on the given
153			* collection.
154			*/
155			public function shouldBePerformedOn(string $collectionName): bool
156			{
157			//if no collections were specified, perform conversion on all collections
158			if (! count($this->performOnCollections)) {
159			return true;
160			}
161
162			if (in_array('*', $this->performOnCollections)) {
163			return true;
164			}
165
166			return in_array($collectionName, $this->performOnCollections);
167			}
168
169			/**
170			* Mark this conversion as one that should be queued.
171			*
172			* @return $this
173			*/
174			public function queued()
175			{
176			$this->performOnQueue = true;
177
178			return $this;
179			}
180
181			/**
182			* Mark this conversion as one that should not be queued.
183			*
184			* @return $this
185			*/
186			public function nonQueued()
187			{
188			$this->performOnQueue = false;
189
190			return $this;
191			}
192
193			/**
194			* Avoid optimization of the converted image.
195			*
196			* @return $this
197			*/
198			public function nonOptimized()
199			{
200			$this->removeManipulation('optimize');
201
202			return $this;
203			}
204
205			/*
206			* Determine if the conversion should be queued.
207			*/
208			public function shouldBeQueued(): bool
209			{
210			return $this->performOnQueue;
211			}
212
213			/*
214			* Get the extension that the result of this conversion must have.
215			*/
216			public function getResultExtension(string $originalFileExtension = ''): string
217			{
218			if ($this->shouldKeepOriginalImageFormat()) {
219			return $originalFileExtension;
220			}
221
222			if ($manipulationArgument = $this->manipulations->getManipulationArgument('format')) {
223			return $manipulationArgument;
224			}
225
226			return $originalFileExtension;
227			}
228			}
229

spatie / laravel-medialibrary

Push — master ( 42602c...0491a1 )

Conversion::nonOptimized() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like