LibFs::symlink() - Code Metrics - Inspection of "prepare 0.0.58 release" - ktomk/pipelines - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 72117a...c610db )

by Tom

created 2021-11-07 22:53 UTC

LibFs::symlink() A

↳ Parent: LibFs

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines;

use UnexpectedValueException;

/**
 * Class LibFs - Low level file-system utility functions
 *
 * @covers \Ktomk\Pipelines\LibFs
 */
class LibFs
{
    /**
     * @param string $path
     * @param string $mode [optional]
     *
     * @return bool
     */
    public static function canFopen($path, $mode = null)
    {
        if (null === $mode) {
            $mode = 'rb';
        }

        $handle = @fopen($path, $mode);
        if (false === $handle) {
            return false;
        }

        /** @scrutinizer ignore-unhandled */
        @fclose($handle);

        return true;
    }

    /**
     * locate (readable) file by basename upward all parent directories
     *
     * @param string $basename
     * @param string $directory [optional] directory to operate from, defaults
     *               to "." (relative path of present working directory)
     *
     * @return null|string
     */
    public static function fileLookUp($basename, $directory = null)
    {
        if ('' === $directory || null === $directory) {
            $directory = '.';
        }

        for (
            $dirName = $directory, $old = null;
            $old !== $dirName;
            $old = $dirName, $dirName = dirname($dirName)
        ) {
            $test = $dirName . '/' . $basename;
            if (self::isReadableFile($test)) {
                return $test;
            }
        }

        return null;
    }

    /**
     * see 2.2 Standards permit the exclusion of bad filenames / POSIX.1-2008
     *
     * @link https://dwheeler.com/essays/fixing-unix-linux-filenames.html
     *
     * @param string $filename
     *
     * @return bool
     */
    public static function isPortableFilename($filename)
    {
        # A-Z, a-z, 0-9, <period>, <underscore>, and <hyphen>
        return 1 === Preg::match('(^(?!-)[A-Za-z0-9._-]+$)', $filename);
    }

    /**
     * @param string $path
     *
     * @return bool
     */
    public static function isReadableFile($path)
    {
        if (!is_file($path)) {
            return false;
        }

        return is_readable($path) ?: self::canFopen($path, 'rb');
    }

    /**
     * create directory if not yet exists
     *
     * @param string $path
     * @param int $mode [optional]
     *
     * @return string
     */
    public static function mkDir($path, $mode = 0777)
    {
        if (!is_dir($path)) {
            /** @noinspection NestedPositiveIfStatementsInspection */
            if (!mkdir($path, $mode, true) && !is_dir($path)) {
                // @codeCoverageIgnoreStart
                throw new \RuntimeException(
                    sprintf('Directory "%s" was not created', $path)
                );
                // @codeCoverageIgnoreEnd
            }
        }

        return $path;
    }

    /**
     * create symbolic link to a directory with parents
     *
     * do not create if link pathname is already a
     * directory or targeting one (even if not the target).
     *
     * create parent directory/ies of link if necessary.
     *
     * @param string $target pathname of target directory
     * @param string $link pathname of link
     *
     * @return void
     */
    public static function symlinkWithParents($target, $link)
    {
        $linkDir = Libfs::mkDir(dirname($link));

        if (!is_dir($link)) {
            LibFs::symlink($target, $link);
            if (!is_link($link)) {
                // @codeCoverageIgnoreStart
                throw new \RuntimeException(
                    sprintf('Link "%s" was not created', $link)
                );
                // @codeCoverageIgnoreEnd
            }
        }
    }

    /**
     * rename a file
     *
     * @param string $old
     * @param string $new
     *
     * @return string new file-name
     */
    public static function rename($old, $new)
    {
        if (!@rename($old, $new)) {
            throw new \RuntimeException(sprintf('Failed to rename "%s" to "%s"', $old, $new));
        }

        return $new;
    }

    /**
     * @param string $file
     *
     * @return string
     */
    public static function rm($file)
    {
        if (self::isReadableFile($file)) {
            unlink($file);
        }

        return $file;
    }

    /**
     * @param string $dir
     *
     * @throws UnexpectedValueException
     *
     * @return void
     */
    public static function rmDir($dir)
    {
        $result = @lstat($dir);
        if (false === $result) {
            return;
        }

        $stack = array();
        $stack[] = $dir;

        for ($i = 0; isset($stack[$i]); $i++) {
            $current = $stack[$i];
            $result = @scandir($current);
            if (false === $result) {
                throw new UnexpectedValueException(sprintf('Failed to open directory: %s', $current));
            }
            $files = array_diff($result, array('.', '..'));
            foreach ($files as $file) {
                $path = "${current}/${file}";
                if (is_link($path)) {
                    self::unlink($path);
                } elseif (is_dir($path)) {
                    $stack[] = $path;
                } elseif (is_file($path)) {
                    self::rm($path);
                }
            }
        }

        for ($i = count($stack); isset($stack[--$i]);) {
            /* @scrutinizer ignore-unhandled */
            @rmdir($stack[$i]);
        }
    }

    /**
     * create symbolic link, recreate if it exists
     *
     * @param string $target
     * @param string $link
     *
     * @return void
     */
    public static function symlink($target, $link)
    {
        self::unlink($link);
        symlink($target, $link);
    }

    /**
     * @param string $link
     *
     * @return void
     */
    public static function unlink($link)
    {
        if (is_link($link)) {
            unlink($link);
        }
    }
}


1		<?php
2
3		/* this file is part of pipelines */
4
5		namespace Ktomk\Pipelines;
6
7		use UnexpectedValueException;
8
9		/**
10		* Class LibFs - Low level file-system utility functions
11		*
12		* @covers \Ktomk\Pipelines\LibFs
13		*/
14		class LibFs
15		{
16		/**
17		* @param string $path
18		* @param string $mode [optional]
19		*
20		* @return bool
21		*/
22	2	public static function canFopen($path, $mode = null)
23		{
24	2	if (null === $mode) {
25	1	$mode = 'rb';
26		}
27
28	2	$handle = @fopen($path, $mode);
29	2	if (false === $handle) {
30	1	return false;
31		}
32
33		/** @scrutinizer ignore-unhandled */
34	1	@fclose($handle);
35
36	1	return true;
37		}
38
39		/**
40		* locate (readable) file by basename upward all parent directories
41		*
42		* @param string $basename
43		* @param string $directory [optional] directory to operate from, defaults
44		* to "." (relative path of present working directory)
45		*
46		* @return null\|string
47		*/
48	4	public static function fileLookUp($basename, $directory = null)
49		{
50	4	if ('' === $directory \|\| null === $directory) {
51	1	$directory = '.';
52		}
53
54		for (
55	4	$dirName = $directory, $old = null;
56	4	$old !== $dirName;
57	2	$old = $dirName, $dirName = dirname($dirName)
58		) {
59	4	$test = $dirName . '/' . $basename;
60	4	if (self::isReadableFile($test)) {
61	3	return $test;
62		}
63		}
64
65	1	return null;
66		}
67
68		/**
69		* see 2.2 Standards permit the exclusion of bad filenames / POSIX.1-2008
70		*
71		* @link https://dwheeler.com/essays/fixing-unix-linux-filenames.html
72		*
73		* @param string $filename
74		*
75		* @return bool
76		*/
77	11	public static function isPortableFilename($filename)
78		{
79		# A-Z, a-z, 0-9, <period>, <underscore>, and <hyphen>
80	11	return 1 === Preg::match('(^(?!-)[A-Za-z0-9._-]+$)', $filename);
81		}
82
83		/**
84		* @param string $path
85		*
86		* @return bool
87		*/
88	11	public static function isReadableFile($path)
89		{
90	11	if (!is_file($path)) {
91	4	return false;
92		}
93
94	9	return is_readable($path) ?: self::canFopen($path, 'rb');
95		}
96
97		/**
98		* create directory if not yet exists
99		*
100		* @param string $path
101		* @param int $mode [optional]
102		*
103		* @return string
104		*/
105	8	public static function mkDir($path, $mode = 0777)
106		{
107	8	if (!is_dir($path)) {
108		/** @noinspection NestedPositiveIfStatementsInspection */
109	7	if (!mkdir($path, $mode, true) && !is_dir($path)) {
110		// @codeCoverageIgnoreStart
111		throw new \RuntimeException(
112		sprintf('Directory "%s" was not created', $path)
113		);
114		// @codeCoverageIgnoreEnd
115		}
116		}
117
118	8	return $path;
119		}
120
121		/**
122		* create symbolic link to a directory with parents
123		*
124		* do not create if link pathname is already a
125		* directory or targeting one (even if not the target).
126		*
127		* create parent directory/ies of link if necessary.
128		*
129		* @param string $target pathname of target directory
130		* @param string $link pathname of link
131		*
132		* @return void
133		*/
134	1	public static function symlinkWithParents($target, $link)
135		{
136	1	$linkDir = Libfs::mkDir(dirname($link));
		0 ignored issues – show Unused Code introduced 2021-11-07 23:04 UTC by Report Bug Copy Issue Report The assignment to `$linkDir` is dead and can be removed. Loading history...
137	1	if (!is_dir($link)) {
138	1	LibFs::symlink($target, $link);
139	1	if (!is_link($link)) {
140		// @codeCoverageIgnoreStart
141		throw new \RuntimeException(
142		sprintf('Link "%s" was not created', $link)
143		);
144		// @codeCoverageIgnoreEnd
145		}
146		}
147	1	}
148
149		/**
150		* rename a file
151		*
152		* @param string $old
153		* @param string $new
154		*
155		* @return string new file-name
156		*/
157	1	public static function rename($old, $new)
158		{
159	1	if (!@rename($old, $new)) {
160	1	throw new \RuntimeException(sprintf('Failed to rename "%s" to "%s"', $old, $new));
161		}
162
163	1	return $new;
164		}
165
166		/**
167		* @param string $file
168		*
169		* @return string
170		*/
171	5	public static function rm($file)
172		{
173	5	if (self::isReadableFile($file)) {
174	5	unlink($file);
175		}
176
177	5	return $file;
178		}
179
180		/**
181		* @param string $dir
182		*
183		* @throws UnexpectedValueException
184		*
185		* @return void
186		*/
187	4	public static function rmDir($dir)
188		{
189	4	$result = @lstat($dir);
190	4	if (false === $result) {
191	1	return;
192		}
193
194	4	$stack = array();
195	4	$stack[] = $dir;
196
197	4	for ($i = 0; isset($stack[$i]); $i++) {
198	4	$current = $stack[$i];
199	4	$result = @scandir($current);
200	4	if (false === $result) {
201	1	throw new UnexpectedValueException(sprintf('Failed to open directory: %s', $current));
202		}
203	3	$files = array_diff($result, array('.', '..'));
204	3	foreach ($files as $file) {
205	2	$path = "${current}/${file}";
206	2	if (is_link($path)) {
207	1	self::unlink($path);
208	2	} elseif (is_dir($path)) {
209	2	$stack[] = $path;
210	1	} elseif (is_file($path)) {
211	1	self::rm($path);
212		}
213		}
214		}
215
216	3	for ($i = count($stack); isset($stack[--$i]);) {
217		/* @scrutinizer ignore-unhandled */
218	3	@rmdir($stack[$i]);
219		}
220	3	}
221
222		/**
223		* create symbolic link, recreate if it exists
224		*
225		* @param string $target
226		* @param string $link
227		*
228		* @return void
229		*/
230	2	public static function symlink($target, $link)
231		{
232	2	self::unlink($link);
233	2	symlink($target, $link);
234	2	}
235
236		/**
237		* @param string $link
238		*
239		* @return void
240		*/
241	2	public static function unlink($link)
242		{
243	2	if (is_link($link)) {
244	2	unlink($link);
245		}
246	2	}
247		}
248

ktomk / pipelines

Push — master ( 72117a...c610db )

LibFs::symlink() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like