Path::detectPathNotChanging() - Code Metrics - Inspection of "Merge pull request #145 from vitalybaev/remote-col..." - sebastianfeldmann/phpbu - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a95984...72cf29 )

by Sebastian

created 2018-05-15 12:50 UTC

Path::detectPathNotChanging() C

↳ Parent: Path

Complexity

Conditions	7
Paths	8

Size

Total Lines	24
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	7

Importance

Changes

Metric	Value
dl	0
loc	24
ccs	14
cts	14
cp	1
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	13
nc	8
nop	1
crap	7

<?php
namespace phpbu\App\Backup;

use phpbu\App\Util;

/**
 * Path class.
 *
 * @package    phpbu
 * @subpackage Backup
 * @author     Sebastian Feldmann <[email protected]>
 * @author     Vitaly Baev <[email protected]>
 * @copyright  Sebastian Feldmann <[email protected]>
 * @license    https://opensource.org/licenses/MIT The MIT License (MIT)
 * @link       https://phpbu.de/
 * @since      Class available since Release 5.1.0
 */
class Path
{
    /**
     * Path
     *
     * @var string
     */
    private $path;

    /**
     * Raw path, that could contain placeholders
     *
     * @var string
     */
    private $pathRaw;

    /**
     * Part of path, that is permanent
     *
     * @var string
     */
    private $pathNotChanging;

    /**
     * Indicates if the path changes over time.
     *
     * @var bool
     */
    private $pathIsChanging = false;

    /**
     * List of all path elements.
     *
     * @var string[]
     */
    private $pathElements = [];

    /**
     * Time for replacing placeholders
     *
     * @var int
     */
    private $time;

    /**
     * Whether leading slash is needed or not
     *
     * @var bool
     */
    private $leadingSlash;

    /**
     * Whether trailing slash is needed or not
     *
     * @var bool
     */
    private $trailingSlash;

    /**
     * Path constructor.
     *
     * @param string    $path
     * @param int|null  $time
     * @param bool|null $leadingSlash
     * @param bool|null $trailingSlash
     */
    public function __construct(string $path, $time = null, $leadingSlash = null, $trailingSlash = null)
    {
        $this->leadingSlash  = $leadingSlash;
        $this->trailingSlash = $trailingSlash;
        $this->pathRaw       = $path;
        $this->time          = $time;

        $this->setUp();
    }

    /**
     * Updates path according to provided parameters.
     */
    private function setUp()
    {
        if (!is_null($this->leadingSlash)) {
            if ($this->leadingSlash) {
                $this->pathRaw = Util\Path::withLeadingSlash($this->pathRaw);
            } else {
                $this->pathRaw = Util\Path::withoutLeadingSlash($this->pathRaw);
            }
        }
        if (!is_null($this->trailingSlash) && !empty($this->pathRaw)) {
            if ($this->trailingSlash) {
                $this->pathRaw = Util\Path::withTrailingSlash($this->pathRaw);
            } else {
                $this->pathRaw = Util\Path::withoutTrailingSlash($this->pathRaw);
            }
        }

        $path = $this->pathRaw;
        if (Util\Path::isContainingPlaceholder($this->pathRaw)) {
            $this->pathIsChanging = true;
            $this->detectPathNotChanging($this->pathRaw);
            // replace potential date placeholder
            $path = Util\Path::replaceDatePlaceholders($this->pathRaw, $this->time);
        } else {
            $this->pathNotChanging = $path;
        }

        $this->path = $path;
    }

    /**
     * Find path elements that can't change because of placeholder usage.
     *
     * @param string $path
     */
    private function detectPathNotChanging(string $path)
    {
        $partsNotChanging = [];
        $foundChangingElement = false;

        foreach (Util\Path::getDirectoryListFromAbsolutePath($path) as $depth => $dir) {
            $this->pathElements[] = $dir;

            // already found placeholder or found one right now
            // path isn't static anymore so don't add directory to path not changing
            if ($foundChangingElement || Util\Path::isContainingPlaceholder($dir)) {
                $foundChangingElement = true;
                continue;
            }
            // do not add the / element leading slash will be re-added later
            if ($dir !== '/') {
                $partsNotChanging[] = $dir;
            }
        }
        $this->pathNotChanging = implode(DIRECTORY_SEPARATOR, $partsNotChanging);
        if (!is_null($this->leadingSlash) && $this->leadingSlash) {
            $this->pathNotChanging = DIRECTORY_SEPARATOR . $this->pathNotChanging;
        }
    }

    /**
     * Return path element at given index.
     *
     * @param  int $index
     * @return string
     */
    public function getPathElementAtIndex(int $index): string
    {
        return $this->pathElements[$index];
    }

    /**
     * Return the full target path depth.
     *
     * @return int
     */
    public function getPathDepth(): int
    {
        return count($this->pathElements);
    }

    /**
     * Return the path to the backup file.
     *
     * @return string
     */
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * Return the path to the backup file.
     *
     * @return string
     */
    public function getPathRaw(): string
    {
        return $this->pathRaw;
    }

    /**
     * Is dirname configured with any date placeholders.
     *
     * @return bool
     */
    public function hasChangingPath(): bool
    {
        return $this->pathIsChanging;
    }

    /**
     * Return the part of the path that is not changing.
     *
     * @return string
     */
    public function getPathThatIsNotChanging(): string
    {
        return $this->pathNotChanging;
    }

    /**
     * Return path when casted to string.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->path;
    }
}


1		<?php
2		namespace phpbu\App\Backup;
3
4		use phpbu\App\Util;
5
6		/**
7		* Path class.
8		*
9		* @package phpbu
10		* @subpackage Backup
11		* @author Sebastian Feldmann <[email protected]>
12		* @author Vitaly Baev <[email protected]>
13		* @copyright Sebastian Feldmann <[email protected]>
14		* @license https://opensource.org/licenses/MIT The MIT License (MIT)
15		* @link https://phpbu.de/
16		* @since Class available since Release 5.1.0
17		*/
18		class Path
19		{
20		/**
21		* Path
22		*
23		* @var string
24		*/
25		private $path;
26
27		/**
28		* Raw path, that could contain placeholders
29		*
30		* @var string
31		*/
32		private $pathRaw;
33
34		/**
35		* Part of path, that is permanent
36		*
37		* @var string
38		*/
39		private $pathNotChanging;
40
41		/**
42		* Indicates if the path changes over time.
43		*
44		* @var bool
45		*/
46		private $pathIsChanging = false;
47
48		/**
49		* List of all path elements.
50		*
51		* @var string[]
52		*/
53		private $pathElements = [];
54
55		/**
56		* Time for replacing placeholders
57		*
58		* @var int
59		*/
60		private $time;
61
62		/**
63		* Whether leading slash is needed or not
64		*
65		* @var bool
66		*/
67		private $leadingSlash;
68
69		/**
70		* Whether trailing slash is needed or not
71		*
72		* @var bool
73		*/
74		private $trailingSlash;
75
76		/**
77		* Path constructor.
78		*
79		* @param string $path
80		* @param int\|null $time
81		* @param bool\|null $leadingSlash
82		* @param bool\|null $trailingSlash
83		*/
84	53	public function __construct(string $path, $time = null, $leadingSlash = null, $trailingSlash = null)
85		{
86	53	$this->leadingSlash = $leadingSlash;
87	53	$this->trailingSlash = $trailingSlash;
88	53	$this->pathRaw = $path;
89	53	$this->time = $time;
90
91	53	$this->setUp();
92	53	}
93
94		/**
95		* Updates path according to provided parameters.
96		*/
97	53	private function setUp()
98		{
99	53	if (!is_null($this->leadingSlash)) {
100	50	if ($this->leadingSlash) {
101	49	$this->pathRaw = Util\Path::withLeadingSlash($this->pathRaw);
102		} else {
103	3	$this->pathRaw = Util\Path::withoutLeadingSlash($this->pathRaw);
104		}
105		}
106	53	if (!is_null($this->trailingSlash) && !empty($this->pathRaw)) {
107	46	if ($this->trailingSlash) {
108	1	$this->pathRaw = Util\Path::withTrailingSlash($this->pathRaw);
109		} else {
110	46	$this->pathRaw = Util\Path::withoutTrailingSlash($this->pathRaw);
111		}
112		}
113
114	53	$path = $this->pathRaw;
115	53	if (Util\Path::isContainingPlaceholder($this->pathRaw)) {
116	11	$this->pathIsChanging = true;
117	11	$this->detectPathNotChanging($this->pathRaw);
118		// replace potential date placeholder
119	11	$path = Util\Path::replaceDatePlaceholders($this->pathRaw, $this->time);
120		} else {
121	42	$this->pathNotChanging = $path;
122		}
123
124	53	$this->path = $path;
125	53	}
126
127		/**
128		* Find path elements that can't change because of placeholder usage.
129		*
130		* @param string $path
131		*/
132	11	private function detectPathNotChanging(string $path)
133		{
134	11	$partsNotChanging = [];
135	11	$foundChangingElement = false;
136
137	11	foreach (Util\Path::getDirectoryListFromAbsolutePath($path) as $depth => $dir) {
138	11	$this->pathElements[] = $dir;
139
140		// already found placeholder or found one right now
141		// path isn't static anymore so don't add directory to path not changing
142	11	if ($foundChangingElement \|\| Util\Path::isContainingPlaceholder($dir)) {
143	11	$foundChangingElement = true;
144	11	continue;
145		}
146		// do not add the / element leading slash will be re-added later
147	11	if ($dir !== '/') {
148	11	$partsNotChanging[] = $dir;
149		}
150		}
151	11	$this->pathNotChanging = implode(DIRECTORY_SEPARATOR, $partsNotChanging);
152	11	if (!is_null($this->leadingSlash) && $this->leadingSlash) {
153	11	$this->pathNotChanging = DIRECTORY_SEPARATOR . $this->pathNotChanging;
154		}
155	11	}
156
157		/**
158		* Return path element at given index.
159		*
160		* @param int $index
161		* @return string
162		*/
163	6	public function getPathElementAtIndex(int $index): string
164		{
165	6	return $this->pathElements[$index];
166		}
167
168		/**
169		* Return the full target path depth.
170		*
171		* @return int
172		*/
173	11	public function getPathDepth(): int
174		{
175	11	return count($this->pathElements);
176		}
177
178		/**
179		* Return the path to the backup file.
180		*
181		* @return string
182		*/
183	26	public function getPath(): string
184		{
185	26	return $this->path;
186		}
187
188		/**
189		* Return the path to the backup file.
190		*
191		* @return string
192		*/
193	4	public function getPathRaw(): string
194		{
195	4	return $this->pathRaw;
196		}
197
198		/**
199		* Is dirname configured with any date placeholders.
200		*
201		* @return bool
202		*/
203	3	public function hasChangingPath(): bool
204		{
205	3	return $this->pathIsChanging;
206		}
207
208		/**
209		* Return the part of the path that is not changing.
210		*
211		* @return string
212		*/
213	13	public function getPathThatIsNotChanging(): string
214		{
215	13	return $this->pathNotChanging;
216		}
217
218		/**
219		* Return path when casted to string.
220		*
221		* @return string
222		*/
223	2	public function __toString()
224		{
225	2	return $this->path;
226		}
227		}
228

sebastianfeldmann / phpbu

Push — master ( a95984...72cf29 )

Path::detectPathNotChanging() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like