CommandHelper::getPackagePath() - Code Metrics - Inspection of "Improve CommandHelper" - jeroennoten/Laravel-AdminLTE - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1283)

by Diego

created 2024-05-21 21:35 UTC

CommandHelper::getPackagePath() A

↳ Parent: CommandHelper

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php

namespace JeroenNoten\LaravelAdminLte\Helpers;

use Illuminate\Support\Facades\File;
use Illuminate\Support\Str;

class CommandHelper
{
    /**
     * The path to the package's root folder.
     *
     * @var string
     */
    protected static $packagePath = __DIR__.'/../../';

    /**
     * The path to the package's stubs folder.
     *
     * @var string
     */
    protected static $stubsPath = __DIR__.'/../Console/stubs';

    /**
     * Copies a directory to the specified destination. Returns whether the
     * directory could be copied successfully.
     *
     * @param  string  $directory  The path of the directory to be copied
     * @param  string  $destination  The path of the destination folder
     * @param  bool  $force  Whether to force the overwrite of existing files
     * @param  bool  $recursive  Whether to copy subfolders recursively
     * @param  array  $ignores  An array of name patterns to ignore while copying
     * @return bool
     */
    public static function copyDirectory(
        $directory,
        $destination,
        $force = false,
        $recursive = false,
        $ignores = []
    ) {
        // Check if we can open the source folder.

        if (! is_resource($dirHandler = @opendir($directory))) {
            return false;
        }

        // Ensure the destination folder exists.

        File::ensureDirectoryExists($destination);

        // Copy the folder to the destination. Note we will skip dots items.

        $avoids = array_merge($ignores, ['.', '..']);

        while (($item = readdir($dirHandler)) !== false) {
            $s = $directory.DIRECTORY_SEPARATOR.$item;
            $t = $destination.DIRECTORY_SEPARATOR.$item;

            // Check if this item should be copied or ignored.

            if (! self::shouldCopyItem($s, $t, $force, $recursive, $avoids)) {
                continue;
            }

            // Finally, copy the file/folder to destination. If the item is a
            // folder we proceed recursively. Otherwise, copy the file to the
            // destination.

            $res = File::isDirectory($s)
                ? self::copyDirectory($s, $t, $force, $recursive, $ignores)
                : File::copy($s, $t);

            if (! $res) {
                closedir($dirHandler);

                return false;
            }
        }

        closedir($dirHandler);

        return true;
    }

    /**
     * Compares two directories file by file. Returns a boolean indicating
     * whether the two directories are equal, or null when one of the
     * directories does not exists.
     *
     * @param  string  $dir1  The path of the first folder
     * @param  string  $dir2  The path of the second folder
     * @param  bool  $recursive  Whether to compare subfolders recursively
     * @param  array  $ignores  An array of name patterns to ignore while comparing
     * @return bool|null
     */
    public static function compareDirectories(
        $dir1,
        $dir2,
        $recursive = false,
        $ignores = []
    ) {
        // Check if we can open the first folder.

        if (! is_resource($dirHandler = @opendir($dir1))) {
            return;
        }

        // Check if the second folder exists.

        if (! is_dir($dir2)) {
            return;
        }

        // Now, compare the folders. Note we will skip dots items.

        $avoids = array_merge($ignores, ['.', '..']);

        while (($item = readdir($dirHandler)) !== false) {
            $s = $dir1.DIRECTORY_SEPARATOR.$item;
            $t = $dir2.DIRECTORY_SEPARATOR.$item;

            // Check if this item should be compared or ignored.

            if (! self::shouldCompareItem($s, $recursive, $avoids)) {
                continue;
            }

            // Finally, compare the files/folders. If the item to compare is a
            // folder we proceed recursively.

            $res = File::isDirectory($s)
                ? (bool) self::compareDirectories($s, $t, $recursive, $ignores)
                : self::compareFiles($s, $t);

            if (! $res) {
                closedir($dirHandler);

                return false;
            }
        }

        closedir($dirHandler);

        return true;
    }

    /**
     * Checks if two files are equals by comparing their hash values.
     *
     * @param  string  $file1  The path to the first file
     * @param  string  $file2  The path to the second file
     * @return bool
     */
    public static function compareFiles($file1, $file2)
    {
        if (! File::isFile($file1) || ! File::isFile($file2)) {
            return false;
        }

        return File::hash($file1) === File::hash($file2);
    }

    /**
     * Gets the fully qualified path to the specified package resource.
     *
     * @param  string  $path  Relative path to the resource
     * @return string
     */
    public static function getPackagePath($path = null)
    {
        if (empty($path)) {
            return self::$packagePath;
        }

        return self::$packagePath.DIRECTORY_SEPARATOR.$path;
    }

    /**
     * Gets the fully qualified path to the specified package stub resource.
     *
     * @param  string  $path  Relative path to the stub resource
     * @return string
     */
    public static function getStubPath($path = null)
    {
        if (empty($path)) {
            return self::$stubsPath;
        }

        return self::$stubsPath.DIRECTORY_SEPARATOR.$path;
    }

    /**
     * Gets the fully qualified path to the specified view resource, relative to
     * the configured view path.
     *
     * @param  string  $path  Relative path to some view resource
     * @return string
     */
    public static function getViewPath($path = null)
    {
        $basePath = config('view.paths')[0] ?? resource_path('views');

        if (empty($path)) {
            return $basePath;
        }

        return $basePath.DIRECTORY_SEPARATOR.$path;
    }

    /**
     * Checks whether an item (file or folder) should be copied to the
     * specified destination by analyzing the recursive and force flags, and a
     * set of item name patterns to be ignored.
     *
     * @param  string  $s  The source item path
     * @param  string  $t  The target destination path
     * @param  bool  $fFlag  The value of the force flag
     * @param  bool  $rFlag  The value of the recursive flag
     * @param  array  $ignores  An array of name patterns to be ignored
     * @return bool
     */
    protected static function shouldCopyItem($s, $t, $fFlag, $rFlag, $ignores)
    {
        // At first, we should copy the item when it's a directoy and the
        // recursive flag is set, or when it's a file and the target path does
        // not exists or the force flag is set.

        $shouldCopy = File::isDirectory($s)
            ? $rFlag
            : (! File::exists($t) || $fFlag);

        // Then we should also check the item name does not match any of the
        // ignore patterns.

        return $shouldCopy
            && ! self::isIgnoredItem(File::basename($s), $ignores);
    }

    /**
     * Checks whether an item (file or folder) should be compared by analyzing
     * the recursive flag, and a set of item name patterns to be ignored.
     *
     * @param  string  $s  The source item path
     * @param  bool  $rFlag  The value of the recursive flag
     * @param  array  $ignores  An array of name patterns to be ignored
     * @return bool
     */
    protected static function shouldCompareItem($s, $rFlag, $ignores)
    {
        // At first, we should compare the item when it's a file or when it's
        // a directory and the recursive flag is set.

        $shouldCompare = File::isFile($s) || $rFlag;

        // Then we should also check that the item name does not match any of
        // the ignore patterns.

        return $shouldCompare
            && ! self::isIgnoredItem(File::basename($s), $ignores);
    }

    /**
     * Checks if the name of a folder or file belongs to a set of specified
     * patterns to be ignored.
     *
     * @param  string  $name  The name of the folder or file to verify
     * @param  array  $ignores  An array of name patterns to be ignored
     * @return bool
     */
    protected static function isIgnoredItem($name, $ignores)
    {
        foreach ($ignores as $pattern) {
            $match = Str::startsWith($pattern, 'regex:')
                ? preg_match(Str::substr($pattern, 6), $name)
                : Str::is($pattern, $name);

            if ($match) {
                return true;
            }
        }

        return false;
    }
}


1		<?php
2
3		namespace JeroenNoten\LaravelAdminLte\Helpers;
4
5		use Illuminate\Support\Facades\File;
6		use Illuminate\Support\Str;
7
8		class CommandHelper
9		{
10		/**
11		* The path to the package's root folder.
12		*
13		* @var string
14		*/
15		protected static $packagePath = __DIR__.'/../../';
16
17		/**
18		* The path to the package's stubs folder.
19		*
20		* @var string
21		*/
22		protected static $stubsPath = __DIR__.'/../Console/stubs';
23
24		/**
25		* Copies a directory to the specified destination. Returns whether the
26		* directory could be copied successfully.
27		*
28		* @param string $directory The path of the directory to be copied
29		* @param string $destination The path of the destination folder
30		* @param bool $force Whether to force the overwrite of existing files
31		* @param bool $recursive Whether to copy subfolders recursively
32		* @param array $ignores An array of name patterns to ignore while copying
33		* @return bool
34		*/
35	28	public static function copyDirectory(
36		$directory,
37		$destination,
38		$force = false,
39		$recursive = false,
40		$ignores = []
41		) {
42		// Check if we can open the source folder.
43
44	28	if (! is_resource($dirHandler = @opendir($directory))) {
45	2	return false;
46		}
47
48		// Ensure the destination folder exists.
49
50	26	File::ensureDirectoryExists($destination);
51
52		// Copy the folder to the destination. Note we will skip dots items.
53
54	26	$avoids = array_merge($ignores, ['.', '..']);
55
56	26	while (($item = readdir($dirHandler)) !== false) {
57	26	$s = $directory.DIRECTORY_SEPARATOR.$item;
58	26	$t = $destination.DIRECTORY_SEPARATOR.$item;
59
60		// Check if this item should be copied or ignored.
61
62	26	if (! self::shouldCopyItem($s, $t, $force, $recursive, $avoids)) {
63	26	continue;
64		}
65
66		// Finally, copy the file/folder to destination. If the item is a
67		// folder we proceed recursively. Otherwise, copy the file to the
68		// destination.
69
70	26	$res = File::isDirectory($s)
71	21	? self::copyDirectory($s, $t, $force, $recursive, $ignores)
72	26	: File::copy($s, $t);
73
74	26	if (! $res) {
75		closedir($dirHandler);
76
77		return false;
78		}
79		}
80
81	26	closedir($dirHandler);
82
83	26	return true;
84		}
85
86		/**
87		* Compares two directories file by file. Returns a boolean indicating
88		* whether the two directories are equal, or null when one of the
89		* directories does not exists.
90		*
91		* @param string $dir1 The path of the first folder
92		* @param string $dir2 The path of the second folder
93		* @param bool $recursive Whether to compare subfolders recursively
94		* @param array $ignores An array of name patterns to ignore while comparing
95		* @return bool\|null
96		*/
97	25	public static function compareDirectories(
98		$dir1,
99		$dir2,
100		$recursive = false,
101		$ignores = []
102		) {
103		// Check if we can open the first folder.
104
105	25	if (! is_resource($dirHandler = @opendir($dir1))) {
106	1	return;
107		}
108
109		// Check if the second folder exists.
110
111	25	if (! is_dir($dir2)) {
112	12	return;
113		}
114
115		// Now, compare the folders. Note we will skip dots items.
116
117	24	$avoids = array_merge($ignores, ['.', '..']);
118
119	24	while (($item = readdir($dirHandler)) !== false) {
120	24	$s = $dir1.DIRECTORY_SEPARATOR.$item;
121	24	$t = $dir2.DIRECTORY_SEPARATOR.$item;
122
123		// Check if this item should be compared or ignored.
124
125	24	if (! self::shouldCompareItem($s, $recursive, $avoids)) {
126	23	continue;
127		}
128
129		// Finally, compare the files/folders. If the item to compare is a
130		// folder we proceed recursively.
131
132	24	$res = File::isDirectory($s)
133	20	? (bool) self::compareDirectories($s, $t, $recursive, $ignores)
134	23	: self::compareFiles($s, $t);
135
136	24	if (! $res) {
137	7	closedir($dirHandler);
138
139	7	return false;
140		}
141		}
142
143	22	closedir($dirHandler);
144
145	22	return true;
146		}
147
148		/**
149		* Checks if two files are equals by comparing their hash values.
150		*
151		* @param string $file1 The path to the first file
152		* @param string $file2 The path to the second file
153		* @return bool
154		*/
155	23	public static function compareFiles($file1, $file2)
156		{
157	23	if (! File::isFile($file1) \|\| ! File::isFile($file2)) {
158	6	return false;
159		}
160
161	23	return File::hash($file1) === File::hash($file2);
162		}
163
164		/**
165		* Gets the fully qualified path to the specified package resource.
166		*
167		* @param string $path Relative path to the resource
168		* @return string
169		*/
170	24	public static function getPackagePath($path = null)
171		{
172	24	if (empty($path)) {
173	1	return self::$packagePath;
174		}
175
176	24	return self::$packagePath.DIRECTORY_SEPARATOR.$path;
177		}
178
179		/**
180		* Gets the fully qualified path to the specified package stub resource.
181		*
182		* @param string $path Relative path to the stub resource
183		* @return string
184		*/
185	24	public static function getStubPath($path = null)
186		{
187	24	if (empty($path)) {
188	1	return self::$stubsPath;
189		}
190
191	24	return self::$stubsPath.DIRECTORY_SEPARATOR.$path;
192		}
193
194		/**
195		* Gets the fully qualified path to the specified view resource, relative to
196		* the configured view path.
197		*
198		* @param string $path Relative path to some view resource
199		* @return string
200		*/
201	24	public static function getViewPath($path = null)
202		{
203	24	$basePath = config('view.paths')[0] ?? resource_path('views');
204
205	24	if (empty($path)) {
206	24	return $basePath;
207		}
208
209	24	return $basePath.DIRECTORY_SEPARATOR.$path;
210		}
211
212		/**
213		* Checks whether an item (file or folder) should be copied to the
214		* specified destination by analyzing the recursive and force flags, and a
215		* set of item name patterns to be ignored.
216		*
217		* @param string $s The source item path
218		* @param string $t The target destination path
219		* @param bool $fFlag The value of the force flag
220		* @param bool $rFlag The value of the recursive flag
221		* @param array $ignores An array of name patterns to be ignored
222		* @return bool
223		*/
224	26	protected static function shouldCopyItem($s, $t, $fFlag, $rFlag, $ignores)
225		{
226		// At first, we should copy the item when it's a directoy and the
227		// recursive flag is set, or when it's a file and the target path does
228		// not exists or the force flag is set.
229
230	26	$shouldCopy = File::isDirectory($s)
231	26	? $rFlag
232	26	: (! File::exists($t) \|\| $fFlag);
233
234		// Then we should also check the item name does not match any of the
235		// ignore patterns.
236
237	26	return $shouldCopy
238	26	&& ! self::isIgnoredItem(File::basename($s), $ignores);
239		}
240
241		/**
242		* Checks whether an item (file or folder) should be compared by analyzing
243		* the recursive flag, and a set of item name patterns to be ignored.
244		*
245		* @param string $s The source item path
246		* @param bool $rFlag The value of the recursive flag
247		* @param array $ignores An array of name patterns to be ignored
248		* @return bool
249		*/
250	24	protected static function shouldCompareItem($s, $rFlag, $ignores)
251		{
252		// At first, we should compare the item when it's a file or when it's
253		// a directory and the recursive flag is set.
254
255	24	$shouldCompare = File::isFile($s) \|\| $rFlag;
256
257		// Then we should also check that the item name does not match any of
258		// the ignore patterns.
259
260	24	return $shouldCompare
261	24	&& ! self::isIgnoredItem(File::basename($s), $ignores);
262		}
263
264		/**
265		* Checks if the name of a folder or file belongs to a set of specified
266		* patterns to be ignored.
267		*
268		* @param string $name The name of the folder or file to verify
269		* @param array $ignores An array of name patterns to be ignored
270		* @return bool
271		*/
272	31	protected static function isIgnoredItem($name, $ignores)
273		{
274	31	foreach ($ignores as $pattern) {
275	31	$match = Str::startsWith($pattern, 'regex:')
276	2	? preg_match(Str::substr($pattern, 6), $name)
277	31	: Str::is($pattern, $name);
278
279	31	if ($match) {
280	29	return true;
281		}
282		}
283
284	31	return false;
285		}
286		}
287

jeroennoten / Laravel-AdminLTE

Pull Request — master (#1283)

CommandHelper::getPackagePath() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like