AssetManifest - Code Metrics - Inspection of "Daily Inspection: Prep Barista and Asset Managemen..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — barista-prod (8f1757)

unknown

created 2020-09-15 21:48 UTC

AssetManifest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	328
Duplicated Lines	7.93 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

Metric	Value
dl	26
loc	328
rs	9.1199
c	0
b	0
f	0
wmc	41
lcom	1
cbo	2

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	initialize()	0	12	2
A	setManifestFilepath()	0	18	3
A	loadManifest()	0	8	2
A	trimAssetFilename()	0	4	1
A	getAssetFiles()	13	13	4
A	getEntryPoints()	13	13	4
A	getAsset()	0	6	2
B	getAssetDependencies()	0	26	7
A	getAssetDetails()	0	15	4
A	getAssetHandle()	0	4	1
A	getAssetsPath()	0	4	1
A	getEntryPointFromHandle()	0	4	1
A	getAssetPath()	0	5	2
A	getAssetUrl()	0	5	2
A	getAssetVersion()	0	7	3
A	hasAsset()	0	5	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AssetManifest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AssetManifest, and based on these observations, apply Extract Interface, too.

<?php

namespace EventEspresso\core\services\assets;

use EventEspresso\core\domain\DomainInterface;

/**
 * Class for loading parsing and retrieving data from an asset manifest file
 *
 * @package EventEspresso\core\services\assets
 * @author  Brent Christensen
 * @since   $VID:$
 */
class AssetManifest implements AssetManifestInterface
{

    const ASSET_EXT_CSS      = '.css';

    const ASSET_EXT_JS      = '.js';

    const ASSET_EXT_PHP     = '.php';

    const FILE_NAME         = 'asset-manifest.json';

    const KEY_DEPENDENCIES  = 'dependencies';

    const KEY_ENTRY_POINTS  = 'entrypoints';

    const KEY_FILES         = 'files';

    const KEY_VERSION       = 'version';


    /**
     * @var array
     */
    private $asset_files;

    /**
     * @var string
     */
    private $assets_namespace;

    /**
     * @var string
     */
    private $assets_path;

    /**
     * @var DomainInterface
     */
    protected $domain;

    /**
     * @var array
     */
    private $entry_points;

    /**
     * @var array
     */
    private $manifest;

    /**
     * @var string
     */
    private $manifest_path;

    /**
     * This is a list of known handles that are used for css.
     * @var array
     */
    private $wp_css_handle_dependencies = [
        'wp-components',
        'wp-block-editor',
        'wp-block-library',
        'wp-edit-post',
        'wp-edit-widgets',
        'wp-editor',
        'wp-format-library',
        'wp-list-reusable-blocks',
        'wp-nux',
    ];


    /**
     * AssetManifest constructor.
     *
     * @param DomainInterface $domain
     */
    public function __construct(DomainInterface $domain)
    {
        $this->domain = $domain;
        $this->initialize();
    }


    /**
     * @return void
     */
    public function initialize()
    {
        if (! $this->manifest) {

            $this->assets_namespace = $this->domain->assetNamespace();
            $assets_path = $this->domain->distributionAssetsPath();
            $this->assets_path = trailingslashit($assets_path);
            $this->setManifestFilepath();
            $this->loadManifest();
            $this->getAssetFiles();
            $this->getEntryPoints();
        }
    }


    /**
     * @param string $manifest_path
     */
    public function setManifestFilepath($manifest_path = '')
    {
        $manifest_path = $manifest_path ? $manifest_path : $this->assets_path . AssetManifest::FILE_NAME;
        if (! is_readable($manifest_path)) {
            throw new AssetManifestException(
                $manifest_path,
                '',
                sprintf(
                    esc_html__(
                        'The "%1$s" file was not found or is not readable. Please verify that the file exists and has appropriate permissions.',
                        'event_espresso'
                    ),
                    $manifest_path
                )
            );
        }
        $this->manifest_path = $manifest_path;
    }


    /**
     * @return void
     */
    private function loadManifest()
    {
        if (! $this->manifest) {

            // TODO May be use WP File system? ¯\_(ツ)_/¯
            $manifest_json  = file_get_contents($this->manifest_path);
            $this->manifest = json_decode($manifest_json, true);
        }
    }


    /**
     * @param string $file_name
     * @return string
     */
    private function trimAssetFilename($file_name)
    {
        return ltrim($file_name, '/');
    }


    /**
     * @return array
     */
    public function getAssetFiles()
    {
        if (! $this->asset_files) {

            if (empty($this->manifest[ AssetManifest::KEY_FILES ])) {
                if (WP_DEBUG) {
                    throw new AssetManifestException(AssetManifest::KEY_FILES, $this->manifest_path);
                }
                return [];
            }
            $this->asset_files = $this->manifest[ AssetManifest::KEY_FILES ];
        }
        return $this->asset_files;
    }


    /**
     * @return array
     */
    public function getEntryPoints()
    {
        if (! $this->entry_points) {

            if (empty($this->manifest[ AssetManifest::KEY_ENTRY_POINTS ])) {
                if (WP_DEBUG) {
                    throw new AssetManifestException(AssetManifest::KEY_ENTRY_POINTS, $this->manifest_path);
                }
                return [];
            }
            $this->entry_points = array_keys($this->manifest[ AssetManifest::KEY_ENTRY_POINTS ]);
        }
        return $this->entry_points;
    }


    /**
     * @param string $entry_point
     * @param string $type
     * @return string
     */
    private function getAsset($entry_point, $type = AssetManifest::ASSET_EXT_JS)
    {
        return $this->hasAsset($entry_point, $type)
            ? $this->trimAssetFilename($this->asset_files[ $entry_point . $type ])
            : '';
    }


    /**
     * @param string $entry_point
     * @param string $type
     * @return array
     */
    public function getAssetDependencies($entry_point, $type = AssetManifest::ASSET_EXT_JS)
    {
        $asset = $this->getAssetDetails($entry_point);
        if (! isset($asset[AssetManifest::KEY_DEPENDENCIES])) {
            return [];
        }
        $dependencies = $asset[AssetManifest::KEY_DEPENDENCIES];
        // remove cyclical dependencies, if any
        if (($key = array_search($this->assets_namespace . '-' . $entry_point, $dependencies, true)) !== false) {
            unset($dependencies[ $key ]);
        }
        // currently need to derive dependencies for CSS from the JS dependencies
        if ($type === AssetManifest::ASSET_EXT_CSS) {
            $css_dependencies = [];
            foreach ($dependencies as $handle) {
                $dependency_style = $this->getEntryPointFromHandle($handle) . AssetManifest::ASSET_EXT_CSS;
                if (isset($this->asset_files[ $dependency_style ])
                    || in_array($handle, $this->wp_css_handle_dependencies)
                ) {
                    $css_dependencies[] = $handle;
                }
            }
            return $css_dependencies;
        }
        return $dependencies;
    }


    /**
     * @param string $entry_point
     * @return array
     */
    public function getAssetDetails($entry_point)
    {
        $file_name = $this->getAsset($entry_point, AssetManifest::ASSET_EXT_PHP);
        if (! $file_name) {
            return [];
        }
        $full_path = $this->assets_path . $file_name;
        if (! is_readable($full_path)) {
            if (WP_DEBUG) {
                throw new AssetManifestException(AssetManifest::KEY_DEPENDENCIES, $full_path);
            }
            return [];
        }
        return require($full_path);
    }


    /**
     * @param string $entry_point
     * @return string|int|false
     */
    public function getAssetHandle($entry_point)
    {
        return $this->assets_namespace . '-' . $entry_point;
    }


    /**
     * @return string
     */
    public function getAssetsPath()
    {
        return $this->assets_path;
    }


    /**
     * @param string $handle
     * @return string|int|false
     */
    private function getEntryPointFromHandle($handle)
    {   $find = $this->assets_namespace . '-';
        return str_replace($find, '', $handle);
    }


    /**
     * @param string $entry_point
     * @param string $type
     * @return string
     */
    public function getAssetPath($entry_point, $type = AssetManifest::ASSET_EXT_JS)
    {
        $file_name = $this->getAsset($entry_point, $type);
        return $file_name ? $this->domain->distributionAssetsPath($file_name) : '';
    }


    /**
     * @param string $entry_point
     * @param string $type
     * @return string
     */
    public function getAssetUrl($entry_point, $type = AssetManifest::ASSET_EXT_JS)
    {
        $file_name = $this->getAsset($entry_point, $type);
        return $file_name ? $this->domain->distributionAssetsUrl($file_name) : '';
    }


    /**
     * @param string $entry_point
     * @param string $type
     * @return string|int|false
     */
    public function getAssetVersion($entry_point, $type = AssetManifest::ASSET_EXT_JS)
    {
        $asset = $this->getAssetDetails($entry_point);
        return $type === AssetManifest::ASSET_EXT_JS && isset($asset[AssetManifest::KEY_VERSION])
            ? $asset[AssetManifest::KEY_VERSION]
            : filemtime($this->getAssetPath($entry_point, $type));
    }


    /**
     * @param string $entry_point
     * @param string $type
     * @return string
     */
    public function hasAsset($entry_point, $type = AssetManifest::ASSET_EXT_JS)
    {
        $file_name = $entry_point . $type;
        return ! empty($this->asset_files[ $file_name ]);
    }
}


1		<?php
2
3		namespace EventEspresso\core\services\assets;
4
5		use EventEspresso\core\domain\DomainInterface;
6
7		/**
8		* Class for loading parsing and retrieving data from an asset manifest file
9		*
10		* @package EventEspresso\core\services\assets
11		* @author Brent Christensen
12		* @since $VID:$
13		*/
14		class AssetManifest implements AssetManifestInterface
15		{
16
17		const ASSET_EXT_CSS = '.css';
18
19		const ASSET_EXT_JS = '.js';
20
21		const ASSET_EXT_PHP = '.php';
22
23		const FILE_NAME = 'asset-manifest.json';
24
25		const KEY_DEPENDENCIES = 'dependencies';
26
27		const KEY_ENTRY_POINTS = 'entrypoints';
28
29		const KEY_FILES = 'files';
30
31		const KEY_VERSION = 'version';
32
33
34		/**
35		* @var array
36		*/
37		private $asset_files;
38
39		/**
40		* @var string
41		*/
42		private $assets_namespace;
43
44		/**
45		* @var string
46		*/
47		private $assets_path;
48
49		/**
50		* @var DomainInterface
51		*/
52		protected $domain;
53
54		/**
55		* @var array
56		*/
57		private $entry_points;
58
59		/**
60		* @var array
61		*/
62		private $manifest;
63
64		/**
65		* @var string
66		*/
67		private $manifest_path;
68
69		/**
70		* This is a list of known handles that are used for css.
71		* @var array
72		*/
73		private $wp_css_handle_dependencies = [
74		'wp-components',
75		'wp-block-editor',
76		'wp-block-library',
77		'wp-edit-post',
78		'wp-edit-widgets',
79		'wp-editor',
80		'wp-format-library',
81		'wp-list-reusable-blocks',
82		'wp-nux',
83		];
84
85
86		/**
87		* AssetManifest constructor.
88		*
89		* @param DomainInterface $domain
90		*/
91		public function __construct(DomainInterface $domain)
92		{
93		$this->domain = $domain;
94		$this->initialize();
95		}
96
97
98		/**
99		* @return void
100		*/
101		public function initialize()
102		{
103		if (! $this->manifest) {
		0 ignored issues – show Bug Best Practice introduced 2020-08-26 21:50 UTC by Report Bug Copy Issue Report The expression `$this->manifest` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
104		$this->assets_namespace = $this->domain->assetNamespace();
105		$assets_path = $this->domain->distributionAssetsPath();
106		$this->assets_path = trailingslashit($assets_path);
107		$this->setManifestFilepath();
108		$this->loadManifest();
109		$this->getAssetFiles();
110		$this->getEntryPoints();
111		}
112		}
113
114
115		/**
116		* @param string $manifest_path
117		*/
118		public function setManifestFilepath($manifest_path = '')
119		{
120		$manifest_path = $manifest_path ? $manifest_path : $this->assets_path . AssetManifest::FILE_NAME;
121		if (! is_readable($manifest_path)) {
122		throw new AssetManifestException(
123		$manifest_path,
124		'',
125		sprintf(
126		esc_html__(
127		'The "%1$s" file was not found or is not readable. Please verify that the file exists and has appropriate permissions.',
128		'event_espresso'
129		),
130		$manifest_path
131		)
132		);
133		}
134		$this->manifest_path = $manifest_path;
135		}
136
137
138		/**
139		* @return void
140		*/
141		private function loadManifest()
142		{
143		if (! $this->manifest) {
		0 ignored issues – show Bug Best Practice introduced 2020-08-26 21:50 UTC by Report Bug Copy Issue Report The expression `$this->manifest` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
144		// TODO May be use WP File system? ¯\_(ツ)_/¯
145		$manifest_json = file_get_contents($this->manifest_path);
146		$this->manifest = json_decode($manifest_json, true);
147		}
148		}
149
150
151		/**
152		* @param string $file_name
153		* @return string
154		*/
155		private function trimAssetFilename($file_name)
156		{
157		return ltrim($file_name, '/');
158		}
159
160
161		/**
162		* @return array
163		*/
164	View Code Duplication	public function getAssetFiles()
165		{
166		if (! $this->asset_files) {
		0 ignored issues – show Bug Best Practice introduced 2020-08-26 21:50 UTC by Report Bug Copy Issue Report The expression `$this->asset_files` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
167		if (empty($this->manifest[ AssetManifest::KEY_FILES ])) {
168		if (WP_DEBUG) {
169		throw new AssetManifestException(AssetManifest::KEY_FILES, $this->manifest_path);
170		}
171		return [];
172		}
173		$this->asset_files = $this->manifest[ AssetManifest::KEY_FILES ];
174		}
175		return $this->asset_files;
176		}
177
178
179		/**
180		* @return array
181		*/
182	View Code Duplication	public function getEntryPoints()
183		{
184		if (! $this->entry_points) {
		0 ignored issues – show Bug Best Practice introduced 2020-08-26 21:50 UTC by Report Bug Copy Issue Report The expression `$this->entry_points` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
185		if (empty($this->manifest[ AssetManifest::KEY_ENTRY_POINTS ])) {
186		if (WP_DEBUG) {
187		throw new AssetManifestException(AssetManifest::KEY_ENTRY_POINTS, $this->manifest_path);
188		}
189		return [];
190		}
191		$this->entry_points = array_keys($this->manifest[ AssetManifest::KEY_ENTRY_POINTS ]);
192		}
193		return $this->entry_points;
194		}
195
196
197		/**
198		* @param string $entry_point
199		* @param string $type
200		* @return string
201		*/
202		private function getAsset($entry_point, $type = AssetManifest::ASSET_EXT_JS)
203		{
204		return $this->hasAsset($entry_point, $type)
205		? $this->trimAssetFilename($this->asset_files[ $entry_point . $type ])
206		: '';
207		}
208
209
210		/**
211		* @param string $entry_point
212		* @param string $type
213		* @return array
214		*/
215		public function getAssetDependencies($entry_point, $type = AssetManifest::ASSET_EXT_JS)
216		{
217		$asset = $this->getAssetDetails($entry_point);
218		if (! isset($asset[AssetManifest::KEY_DEPENDENCIES])) {
219		return [];
220		}
221		$dependencies = $asset[AssetManifest::KEY_DEPENDENCIES];
222		// remove cyclical dependencies, if any
223		if (($key = array_search($this->assets_namespace . '-' . $entry_point, $dependencies, true)) !== false) {
224		unset($dependencies[ $key ]);
225		}
226		// currently need to derive dependencies for CSS from the JS dependencies
227		if ($type === AssetManifest::ASSET_EXT_CSS) {
228		$css_dependencies = [];
229		foreach ($dependencies as $handle) {
230		$dependency_style = $this->getEntryPointFromHandle($handle) . AssetManifest::ASSET_EXT_CSS;
231		if (isset($this->asset_files[ $dependency_style ])
232		\|\| in_array($handle, $this->wp_css_handle_dependencies)
233		) {
234		$css_dependencies[] = $handle;
235		}
236		}
237		return $css_dependencies;
238		}
239		return $dependencies;
240		}
241
242
243		/**
244		* @param string $entry_point
245		* @return array
246		*/
247		public function getAssetDetails($entry_point)
248		{
249		$file_name = $this->getAsset($entry_point, AssetManifest::ASSET_EXT_PHP);
250		if (! $file_name) {
251		return [];
252		}
253		$full_path = $this->assets_path . $file_name;
254		if (! is_readable($full_path)) {
255		if (WP_DEBUG) {
256		throw new AssetManifestException(AssetManifest::KEY_DEPENDENCIES, $full_path);
257		}
258		return [];
259		}
260		return require($full_path);
261		}
262
263
264		/**
265		* @param string $entry_point
266		* @return string\|int\|false
267		*/
268		public function getAssetHandle($entry_point)
269		{
270		return $this->assets_namespace . '-' . $entry_point;
271		}
272
273
274		/**
275		* @return string
276		*/
277		public function getAssetsPath()
278		{
279		return $this->assets_path;
280		}
281
282
283		/**
284		* @param string $handle
285		* @return string\|int\|false
286		*/
287		private function getEntryPointFromHandle($handle)
288		{ $find = $this->assets_namespace . '-';
289		return str_replace($find, '', $handle);
290		}
291
292
293		/**
294		* @param string $entry_point
295		* @param string $type
296		* @return string
297		*/
298		public function getAssetPath($entry_point, $type = AssetManifest::ASSET_EXT_JS)
299		{
300		$file_name = $this->getAsset($entry_point, $type);
301		return $file_name ? $this->domain->distributionAssetsPath($file_name) : '';
302		}
303
304
305		/**
306		* @param string $entry_point
307		* @param string $type
308		* @return string
309		*/
310		public function getAssetUrl($entry_point, $type = AssetManifest::ASSET_EXT_JS)
311		{
312		$file_name = $this->getAsset($entry_point, $type);
313		return $file_name ? $this->domain->distributionAssetsUrl($file_name) : '';
314		}
315
316
317		/**
318		* @param string $entry_point
319		* @param string $type
320		* @return string\|int\|false
321		*/
322		public function getAssetVersion($entry_point, $type = AssetManifest::ASSET_EXT_JS)
323		{
324		$asset = $this->getAssetDetails($entry_point);
325		return $type === AssetManifest::ASSET_EXT_JS && isset($asset[AssetManifest::KEY_VERSION])
326		? $asset[AssetManifest::KEY_VERSION]
327		: filemtime($this->getAssetPath($entry_point, $type));
328		}
329
330
331		/**
332		* @param string $entry_point
333		* @param string $type
334		* @return string
335		*/
336		public function hasAsset($entry_point, $type = AssetManifest::ASSET_EXT_JS)
337		{
338		$file_name = $entry_point . $type;
339		return ! empty($this->asset_files[ $file_name ]);
340		}
341		}
342

eventespresso / event-espresso-core