PluginState::shouldMergeScriptsDeep() - Code Metrics - Inspection of "Allow merging "scripts" in a deep way" - wikimedia/composer-merge-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#177)

by Christopher

created 2019-06-26 03:48 UTC

PluginState::shouldMergeScriptsDeep() A

↳ Parent: PluginState

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	0
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	2

<?php
/**
 * This file is part of the Composer Merge plugin.
 *
 * Copyright (C) 2015 Bryan Davis, Wikimedia Foundation, and contributors
 *
 * This software may be modified and distributed under the terms of the MIT
 * license. See the LICENSE file for details.
 */

namespace Wikimedia\Composer\Merge;

use Composer\Composer;

/**
 * Mutable plugin state
 *
 * @author Bryan Davis <[email protected]>
 */
class PluginState
{
    /**
     * @var Composer $composer
     */
    protected $composer;

    /**
     * @var array $includes
     */
    protected $includes = array();

    /**
     * @var array $requires
     */
    protected $requires = array();

    /**
     * @var array $duplicateLinks
     */
    protected $duplicateLinks = array();

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

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

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

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

    /**
     * Whether to merge the -dev sections.
     * @var bool $mergeDev
     */
    protected $mergeDev = true;

    /**
     * Whether to merge the extra section.
     *
     * By default, the extra section is not merged and there will be many
     * cases where the merge of the extra section is performed too late
     * to be of use to other plugins. When enabled, merging uses one of
     * two strategies - either 'first wins' or 'last wins'. When enabled,
     * 'first wins' is the default behaviour. If Replace mode is activated
     * then 'last wins' is used.
     *
     * @var bool $mergeExtra
     */
    protected $mergeExtra = false;

    /**
     * Whether to merge the extra section in a deep / recursive way.
     *
     * By default the extra section is merged with array_merge() and duplicate
     * keys are ignored. When enabled this allows to merge the arrays recursively
     * using the following rule: Integer keys are merged, while array values are
     * replaced where the later values overwrite the former.
     *
     * This is useful especially for the extra section when plugins use larger
     * structures like a 'patches' key with the packages as sub-keys and the
     * patches as values.
     *
     * When 'replace' mode is activated the order of array merges is exchanged.
     *
     * @var bool $mergeExtraDeep
     */
    protected $mergeExtraDeep = false;

    /**
     * Whether to merge the scripts section.
     *
     * @var bool $mergeScripts
     */
    protected $mergeScripts = false;

    /**
     * Whether to merge the scripts section in a deep / recursive way.
     *
     * By default the scripts section is merged with array_merge() and duplicate
     * keys are ignored. When enabled this allows to merge the arrays recursively
     * using the following rule: Integer keys are merged, while array values are
     * replaced where the later values overwrite the former.
     *
     * When 'replace' mode is activated the order of array merges is exchanged.
     *
     * @var bool $mergeScriptsDeep
     */
    protected $mergeScriptsDeep;

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

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

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

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

    /**
     * @param Composer $composer
     */
    public function __construct(Composer $composer)
    {
        $this->composer = $composer;
    }

    /**
     * Load plugin settings
     */
    public function loadSettings()
    {
        $extra = $this->composer->getPackage()->getExtra();
        $config = array_merge(
            array(
                'include' => array(),
                'require' => array(),
                'recurse' => true,
                'replace' => false,
                'ignore-duplicates' => false,
                'merge-dev' => true,
                'merge-extra' => false,
                'merge-extra-deep' => false,
                'merge-scripts' => false,
                'merge-scripts-deep' => false,
            ),
            isset($extra['merge-plugin']) ? $extra['merge-plugin'] : array()
        );

        $this->includes = (is_array($config['include'])) ?
            $config['include'] : array($config['include']);
        $this->requires = (is_array($config['require'])) ?
            $config['require'] : array($config['require']);
        $this->recurse = (bool)$config['recurse'];
        $this->replace = (bool)$config['replace'];
        $this->ignore = (bool)$config['ignore-duplicates'];
        $this->mergeDev = (bool)$config['merge-dev'];
        $this->mergeExtra = (bool)$config['merge-extra'];
        $this->mergeExtraDeep = (bool)$config['merge-extra-deep'];
        $this->mergeScripts = (bool)$config['merge-scripts'];
        $this->mergeScriptsDeep = (bool)$config['merge-scripts-deep'];
    }

    /**
     * Get list of filenames and/or glob patterns to include
     *
     * @return array
     */
    public function getIncludes()
    {
        return $this->includes;
    }

    /**
     * Get list of filenames and/or glob patterns to require
     *
     * @return array
     */
    public function getRequires()
    {
        return $this->requires;
    }

    /**
     * Set the first install flag
     *
     * @param bool $flag
     */
    public function setFirstInstall($flag)
    {
        $this->firstInstall = (bool)$flag;
    }

    /**
     * Is this the first time that the plugin has been installed?
     *
     * @return bool
     */
    public function isFirstInstall()
    {
        return $this->firstInstall;
    }

    /**
     * Set the locked flag
     *
     * @param bool $flag
     */
    public function setLocked($flag)
    {
        $this->locked = (bool)$flag;
    }

    /**
     * Was a lockfile present when the plugin was installed?
     *
     * @return bool
     */
    public function isLocked()
    {
        return $this->locked;
    }

    /**
     * Should an update be forced?
     *
     * @return true If packages are not locked
     */
    public function forceUpdate()
    {
        return !$this->locked;
    }

    /**
     * Set the devMode flag
     *
     * @param bool $flag
     */
    public function setDevMode($flag)
    {
        $this->devMode = (bool)$flag;
    }

    /**
     * Should devMode settings be processed?
     *
     * @return bool
     */
    public function isDevMode()
    {
        return $this->shouldMergeDev() && $this->devMode;
    }

    /**
     * Should devMode settings be merged?
     *
     * @return bool
     */
    public function shouldMergeDev()
    {
        return $this->mergeDev;
    }

    /**
     * Set the dumpAutoloader flag
     *
     * @param bool $flag
     */
    public function setDumpAutoloader($flag)
    {
        $this->dumpAutoloader = (bool)$flag;
    }

    /**
     * Is the autoloader file supposed to be written out?
     *
     * @return bool
     */
    public function shouldDumpAutoloader()
    {
        return $this->dumpAutoloader;
    }

    /**
     * Set the optimizeAutoloader flag
     *
     * @param bool $flag
     */
    public function setOptimizeAutoloader($flag)
    {
        $this->optimizeAutoloader = (bool)$flag;
    }

    /**
     * Should the autoloader be optimized?
     *
     * @return bool
     */
    public function shouldOptimizeAutoloader()
    {
        return $this->optimizeAutoloader;
    }

    /**
     * Add duplicate packages
     *
     * @param string $type Package type
     * @param array $packages
     */
    public function addDuplicateLinks($type, array $packages)
    {
        if (!isset($this->duplicateLinks[$type])) {
            $this->duplicateLinks[$type] = array();
        }
        $this->duplicateLinks[$type] =
            array_merge($this->duplicateLinks[$type], $packages);
    }

    /**
     * Get duplicate packages
     *
     * @param string $type Package type
     * @return array
     */
    public function getDuplicateLinks($type)
    {
        return isset($this->duplicateLinks[$type]) ?
            $this->duplicateLinks[$type] : array();
    }

    /**
     * Should includes be recursively processed?
     *
     * @return bool
     */
    public function recurseIncludes()
    {
        return $this->recurse;
    }

    /**
     * Should duplicate links be replaced in a 'last definition wins' order?
     *
     * @return bool
     */
    public function replaceDuplicateLinks()
    {
        return $this->replace;
    }

    /**
     * Should duplicate links be ignored?
     *
     * @return bool
     */
    public function ignoreDuplicateLinks()
    {
        return $this->ignore;
    }

    /**
     * Should the extra section be merged?
     *
     * By default, the extra section is not merged and there will be many
     * cases where the merge of the extra section is performed too late
     * to be of use to other plugins. When enabled, merging uses one of
     * two strategies - either 'first wins' or 'last wins'. When enabled,
     * 'first wins' is the default behaviour. If Replace mode is activated
     * then 'last wins' is used.
     *
     * @return bool
     */
    public function shouldMergeExtra()
    {
        return $this->mergeExtra;
    }

    /**
     * Should the extra section be merged deep / recursively?
     *
     * By default the extra section is merged with array_merge() and duplicate
     * keys are ignored. When enabled this allows to merge the arrays recursively
     * using the following rule: Integer keys are merged, while array values are
     * replaced where the later values overwrite the former.
     *
     * This is useful especially for the extra section when plugins use larger
     * structures like a 'patches' key with the packages as sub-keys and the
     * patches as values.
     *
     * When 'replace' mode is activated the order of array merges is exchanged.
     *
     * @return bool
     */
    public function shouldMergeExtraDeep()
    {
        return $this->mergeExtraDeep;
    }


    /**
     * Should the scripts section be merged?
     *
     * By default, the scripts section is not merged.
     *
     * @return bool
     */
    public function shouldMergeScripts()
    {
        return $this->mergeScripts;
    }

    /**
     * Should the scripts section be merged deep / recursively?
     *
     * By default the scripts section is merged with array_merge() and duplicate
     * keys are ignored. When enabled this allows to merge the arrays recursively
     * using the following rule: Integer keys are merged, while array values are
     * replaced where the later values overwrite the former.
     *
     * When 'replace' mode is activated the order of array merges is exchanged.
     *
     * @return bool
     */
    public function shouldMergeScriptsDeep()
    {
        return $this->mergeScriptsDeep;
    }
}
// vim:sw=4:ts=4:sts=4:et:


1		<?php
2		/**
3		* This file is part of the Composer Merge plugin.
4		*
5		* Copyright (C) 2015 Bryan Davis, Wikimedia Foundation, and contributors
6		*
7		* This software may be modified and distributed under the terms of the MIT
8		* license. See the LICENSE file for details.
9		*/
10
11		namespace Wikimedia\Composer\Merge;
12
13		use Composer\Composer;
14
15		/**
16		* Mutable plugin state
17		*
18		* @author Bryan Davis <[email protected]>
19		*/
20		class PluginState
21		{
22		/**
23		* @var Composer $composer
24		*/
25		protected $composer;
26
27		/**
28		* @var array $includes
29		*/
30		protected $includes = array();
31
32		/**
33		* @var array $requires
34		*/
35		protected $requires = array();
36
37		/**
38		* @var array $duplicateLinks
39		*/
40		protected $duplicateLinks = array();
41
42		/**
43		* @var bool $devMode
44		*/
45		protected $devMode = false;
46
47		/**
48		* @var bool $recurse
49		*/
50		protected $recurse = true;
51
52		/**
53		* @var bool $replace
54		*/
55		protected $replace = false;
56
57		/**
58		* @var bool $ignore
59		*/
60		protected $ignore = false;
61
62		/**
63		* Whether to merge the -dev sections.
64		* @var bool $mergeDev
65		*/
66		protected $mergeDev = true;
67
68		/**
69		* Whether to merge the extra section.
70		*
71		* By default, the extra section is not merged and there will be many
72		* cases where the merge of the extra section is performed too late
73		* to be of use to other plugins. When enabled, merging uses one of
74		* two strategies - either 'first wins' or 'last wins'. When enabled,
75		* 'first wins' is the default behaviour. If Replace mode is activated
76		* then 'last wins' is used.
77		*
78		* @var bool $mergeExtra
79		*/
80		protected $mergeExtra = false;
81
82		/**
83		* Whether to merge the extra section in a deep / recursive way.
84		*
85		* By default the extra section is merged with array_merge() and duplicate
86		* keys are ignored. When enabled this allows to merge the arrays recursively
87		* using the following rule: Integer keys are merged, while array values are
88		* replaced where the later values overwrite the former.
89		*
90		* This is useful especially for the extra section when plugins use larger
91		* structures like a 'patches' key with the packages as sub-keys and the
92		* patches as values.
93		*
94		* When 'replace' mode is activated the order of array merges is exchanged.
95		*
96		* @var bool $mergeExtraDeep
97		*/
98		protected $mergeExtraDeep = false;
99
100		/**
101		* Whether to merge the scripts section.
102		*
103		* @var bool $mergeScripts
104		*/
105		protected $mergeScripts = false;
106
107		/**
108		* Whether to merge the scripts section in a deep / recursive way.
109		*
110		* By default the scripts section is merged with array_merge() and duplicate
111		* keys are ignored. When enabled this allows to merge the arrays recursively
112		* using the following rule: Integer keys are merged, while array values are
113		* replaced where the later values overwrite the former.
114		*
115		* When 'replace' mode is activated the order of array merges is exchanged.
116		*
117		* @var bool $mergeScriptsDeep
118		*/
119		protected $mergeScriptsDeep;
120
121		/**
122		* @var bool $firstInstall
123		*/
124		protected $firstInstall = false;
125
126		/**
127		* @var bool $locked
128		*/
129		protected $locked = false;
130	210
131		/**
132	210	* @var bool $dumpAutoloader
133	210	*/
134		protected $dumpAutoloader = false;
135
136		/**
137		* @var bool $optimizeAutoloader
138	175	*/
139		protected $optimizeAutoloader = false;
140	175
141	175	/**
142		* @param Composer $composer
143	175	*/
144	175	public function __construct(Composer $composer)
145	175	{
146	175	$this->composer = $composer;
147	175	}
148	175
149	175	/**
150	175	* Load plugin settings
151	175	*/
152	175	public function loadSettings()
153	175	{
154	175	$extra = $this->composer->getPackage()->getExtra();
155		$config = array_merge(
156	175	array(
157	175	'include' => array(),
158	175	'require' => array(),
159	175	'recurse' => true,
160	175	'replace' => false,
161	175	'ignore-duplicates' => false,
162	175	'merge-dev' => true,
163	175	'merge-extra' => false,
164	175	'merge-extra-deep' => false,
165	175	'merge-scripts' => false,
166	175	'merge-scripts-deep' => false,
167	175	),
168		isset($extra['merge-plugin']) ? $extra['merge-plugin'] : array()
169		);
170
171		$this->includes = (is_array($config['include'])) ?
172		$config['include'] : array($config['include']);
173		$this->requires = (is_array($config['require'])) ?
174	175	$config['require'] : array($config['require']);
175		$this->recurse = (bool)$config['recurse'];
176	175	$this->replace = (bool)$config['replace'];
177		$this->ignore = (bool)$config['ignore-duplicates'];
178		$this->mergeDev = (bool)$config['merge-dev'];
179		$this->mergeExtra = (bool)$config['merge-extra'];
180		$this->mergeExtraDeep = (bool)$config['merge-extra-deep'];
181		$this->mergeScripts = (bool)$config['merge-scripts'];
182		$this->mergeScriptsDeep = (bool)$config['merge-scripts-deep'];
183		}
184	175
185		/**
186	175	* Get list of filenames and/or glob patterns to include
187		*
188		* @return array
189		*/
190		public function getIncludes()
191		{
192		return $this->includes;
193		}
194	10
195		/**
196	10	* Get list of filenames and/or glob patterns to require
197	10	*
198		* @return array
199		*/
200		public function getRequires()
201		{
202		return $this->requires;
203		}
204	185
205		/**
206	185	* Set the first install flag
207		*
208		* @param bool $flag
209		*/
210		public function setFirstInstall($flag)
211		{
212		$this->firstInstall = (bool)$flag;
213		}
214	15
215		/**
216	15	* Is this the first time that the plugin has been installed?
217	15	*
218		* @return bool
219		*/
220		public function isFirstInstall()
221		{
222		return $this->firstInstall;
223		}
224	20
225		/**
226	20	* Set the locked flag
227		*
228		* @param bool $flag
229		*/
230		public function setLocked($flag)
231		{
232		$this->locked = (bool)$flag;
233		}
234	5
235		/**
236	5	* Was a lockfile present when the plugin was installed?
237		*
238		* @return bool
239		*/
240		public function isLocked()
241		{
242		return $this->locked;
243		}
244	175
245		/**
246	175	* Should an update be forced?
247	175	*
248		* @return true If packages are not locked
249		*/
250		public function forceUpdate()
251		{
252		return !$this->locked;
253		}
254	170
255		/**
256	170	* Set the devMode flag
257		*
258		* @param bool $flag
259		*/
260		public function setDevMode($flag)
261		{
262		$this->devMode = (bool)$flag;
263		}
264	170
265		/**
266	170	* Should devMode settings be processed?
267		*
268		* @return bool
269		*/
270		public function isDevMode()
271		{
272		return $this->shouldMergeDev() && $this->devMode;
273		}
274	175
275		/**
276	175	* Should devMode settings be merged?
277	175	*
278		* @return bool
279		*/
280		public function shouldMergeDev()
281		{
282		return $this->mergeDev;
283		}
284	5
285		/**
286	5	* Set the dumpAutoloader flag
287		*
288		* @param bool $flag
289		*/
290		public function setDumpAutoloader($flag)
291		{
292		$this->dumpAutoloader = (bool)$flag;
293		}
294	175
295		/**
296	175	* Is the autoloader file supposed to be written out?
297	175	*
298		* @return bool
299		*/
300		public function shouldDumpAutoloader()
301		{
302		return $this->dumpAutoloader;
303		}
304	5
305		/**
306	5	* Set the optimizeAutoloader flag
307		*
308		* @param bool $flag
309		*/
310		public function setOptimizeAutoloader($flag)
311		{
312		$this->optimizeAutoloader = (bool)$flag;
313		}
314
315	95	/**
316		* Should the autoloader be optimized?
317	95	*
318	95	* @return bool
319	95	*/
320	95	public function shouldOptimizeAutoloader()
321	95	{
322	95	return $this->optimizeAutoloader;
323		}
324
325		/**
326		* Add duplicate packages
327		*
328		* @param string $type Package type
329		* @param array $packages
330	170	*/
331		public function addDuplicateLinks($type, array $packages)
332	170	{
333	170	if (!isset($this->duplicateLinks[$type])) {
334		$this->duplicateLinks[$type] = array();
335		}
336		$this->duplicateLinks[$type] =
337		array_merge($this->duplicateLinks[$type], $packages);
338		}
339
340		/**
341	170	* Get duplicate packages
342		*
343	170	* @param string $type Package type
344		* @return array
345		*/
346		public function getDuplicateLinks($type)
347		{
348		return isset($this->duplicateLinks[$type]) ?
349		$this->duplicateLinks[$type] : array();
350		}
351	95
352		/**
353	95	* Should includes be recursively processed?
354		*
355		* @return bool
356		*/
357		public function recurseIncludes()
358		{
359		return $this->recurse;
360		}
361	95
362		/**
363	95	* Should duplicate links be replaced in a 'last definition wins' order?
364		*
365		* @return bool
366		*/
367		public function replaceDuplicateLinks()
368		{
369		return $this->replace;
370		}
371
372		/**
373		* Should duplicate links be ignored?
374		*
375		* @return bool
376		*/
377		public function ignoreDuplicateLinks()
378	170	{
379		return $this->ignore;
380	170	}
381
382		/**
383		* Should the extra section be merged?
384		*
385		* By default, the extra section is not merged and there will be many
386		* cases where the merge of the extra section is performed too late
387		* to be of use to other plugins. When enabled, merging uses one of
388		* two strategies - either 'first wins' or 'last wins'. When enabled,
389		* 'first wins' is the default behaviour. If Replace mode is activated
390		* then 'last wins' is used.
391		*
392		* @return bool
393		*/
394		public function shouldMergeExtra()
395		{
396		return $this->mergeExtra;
397		}
398
399	30	/**
400		* Should the extra section be merged deep / recursively?
401	30	*
402		* By default the extra section is merged with array_merge() and duplicate
403		* keys are ignored. When enabled this allows to merge the arrays recursively
404		* using the following rule: Integer keys are merged, while array values are
405		* replaced where the later values overwrite the former.
406		*
407		* This is useful especially for the extra section when plugins use larger
408		* structures like a 'patches' key with the packages as sub-keys and the
409		* patches as values.
410		*
411		* When 'replace' mode is activated the order of array merges is exchanged.
412	170	*
413		* @return bool
414	170	*/
415		public function shouldMergeExtraDeep()
416		{
417		return $this->mergeExtraDeep;
418		}
419
420
421		/**
422		* Should the scripts section be merged?
423		*
424		* By default, the scripts section is not merged.
425		*
426		* @return bool
427		*/
428		public function shouldMergeScripts()
429		{
430		return $this->mergeScripts;
431		}
432
433		/**
434		* Should the scripts section be merged deep / recursively?
435		*
436		* By default the scripts section is merged with array_merge() and duplicate
437		* keys are ignored. When enabled this allows to merge the arrays recursively
438		* using the following rule: Integer keys are merged, while array values are
439		* replaced where the later values overwrite the former.
440		*
441		* When 'replace' mode is activated the order of array merges is exchanged.
442		*
443		* @return bool
444		*/
445		public function shouldMergeScriptsDeep()
446		{
447		return $this->mergeScriptsDeep;
448		}
449		}
450		// vim:sw=4:ts=4:sts=4:et:
451

wikimedia / composer-merge-plugin

Pull Request — master (#177)

PluginState::shouldMergeScriptsDeep() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like