Directory::createIfNotExists() - Code Metrics - Inspection of "Can now create directories and not throw exception..." - ntentan/utils - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 385789...5662c6 )

by James Ekow Abaka

created 2019-12-22 12:05 UTC

Directory::createIfNotExists() A

↳ Parent: Directory

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	0
cts	4
cp	0
rs	9.9666
c	0
b	0
f	0
cc	2
nc	2
nop	2
crap	6

<?php

namespace ntentan\utils\filesystem;

use ntentan\utils\exceptions\FileAlreadyExistsException;
use ntentan\utils\exceptions\FileNotFoundException;
use ntentan\utils\exceptions\FileNotReadableException;
use ntentan\utils\exceptions\FileNotWriteableException;
use ntentan\utils\Filesystem;
use ntentan\utils\exceptions\FilesystemException;

/**
 * Represents a directory from the filesystem.
 *
 * @package ntentan\utils\filesystem
 * 
 */
class Directory implements FileInterface
{

    /**
     * Full path to the directory.
     *
     * @var string
     */
    private $path;

    /**
     * Create a new instance with a path.
     *
     * @param string $path Optional path pointed to by new instance. Path does not have to exist.
     */
    public function __construct(string $path = null)
    {
        $this->path = $path;
    }

    /**
     * Used to perform copies and moves.
     *
     * @param string $operation
     * @param string $destination
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws FileAlreadyExistsException
     * @throws FileNotReadableException
     * @throws FileNotWriteableException
     */
    private function directoryOperation(string $operation, string $destination):void
    {
        foreach ($this->getFiles(true) as $file) {
            $fileTarget = $destination . DIRECTORY_SEPARATOR . substr($file, strlen($this->path));
            if(is_dir($file)) {
                continue;
            }
            try{
                Filesystem::checkExists(dirname($fileTarget));
            } catch (FileNotFoundException $exception) {
                Filesystem::directory(dirname($fileTarget))->create(true);
            }

            $file->$operation($fileTarget);
        }
    }

    /**
     * Recursively copies directory and its contents to destination.
     *
     * @param string $destination
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws FileAlreadyExistsException
     * @throws FileNotReadableException
     * @throws FileNotWriteableException
     */
    public function copyTo(string $destination): void
    {
        $this->directoryOperation('copyTo', $destination);
    }

    /**
     * Recursively get the size of all contents in the directory.
     *
     * @return integer
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws FileNotReadableException
     */
    public function getSize() : int
    {
        return $this->getFiles()->getSize();
    }

    /**
     * Recursively move a directory and its contents to another location.
     *
     * @param string $destination
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws FileAlreadyExistsException
     * @throws FileNotReadableException
     * @throws FileNotWriteableException
     */
    public function moveTo(string $destination) : void
    {
        $this->directoryOperation('moveTo', $destination);
        $this->delete();
        $this->path = $destination;
    }

    /**
     * Create the directory pointed to by path.
     *
     * @param int $permissions
     * @throws FileAlreadyExistsException
     * @throws FileNotWriteableException
     */
    public function create($recursive=false, $permissions = 0755)
    {
        Filesystem::checkNotExists($this->path);
        $parent = $this->path;
        if($recursive) {
            $segments = explode(DIRECTORY_SEPARATOR, $this->path);
            $parent = "";
            foreach($segments as $segment) {
                $parent .= $segment . DIRECTORY_SEPARATOR;
                if(!is_dir($parent)) {
                    break;
                }
            }
        }
        $parent = dirname($parent);
        Filesystem::checkWritable($parent == "" ? '.' : $parent);
        mkdir($this->path, $permissions, true);

        return $this;
    }

    public function createIfNotExists($recursive=false, $permissions = 0755)
    {
        try {
            $this->create($recursive, $permissions);
        } catch (FileAlreadyExistsException $exception) {
            // Do nothing
        }
        return $this;
    }

    /**
     * Recursively delete the directory and all its contents.
     *
     * @throws FileNotFoundException
     * @throws FilesystemException
     * @throws FileNotReadableException
     */
    public function delete() : void
    {
        $this->getFiles()->delete();
        rmdir($this->path);
    }

    /**
     * Get the path of the directory.
     *
     * @return string
     */
    public function getPath() : string
    {
        return $this->path;
    }

    /**
     * Get the files in the directory.
     *
     * @throws FilesystemException
     * @throws FileNotFoundException
     * @throws FileNotReadableException
     * @return FileCollection | array<string>
     */
    public function getFiles($recursive=false, $returnStrings=false)
    {
        Filesystem::checkExists($this->path);
        Filesystem::checkReadable($this->path);
        $contents = [];

        $files = scandir($this->path);
        foreach ($files as $file) {
            if($file == '.' || $file == '..') continue;
            $path = "$this->path/$file";
            if(is_dir($path) && $recursive) {
                $contents = array_merge($contents, Filesystem::directory($path)->getFiles(true, true));
            }
            $contents[] = $path;
        }
        return $returnStrings ? $contents : new FileCollection($contents);
    }

    public function __toString()
    {
        return $this->path;
    }
}


1		<?php
2
3		namespace ntentan\utils\filesystem;
4
5		use ntentan\utils\exceptions\FileAlreadyExistsException;
6		use ntentan\utils\exceptions\FileNotFoundException;
7		use ntentan\utils\exceptions\FileNotReadableException;
8		use ntentan\utils\exceptions\FileNotWriteableException;
9		use ntentan\utils\Filesystem;
10		use ntentan\utils\exceptions\FilesystemException;
11
12		/**
13		* Represents a directory from the filesystem.
14		*
15		* @package ntentan\utils\filesystem
16		*
17		*/
18		class Directory implements FileInterface
19		{
20
21		/**
22		* Full path to the directory.
23		*
24		* @var string
25		*/
26		private $path;
27
28		/**
29		* Create a new instance with a path.
30		*
31		* @param string $path Optional path pointed to by new instance. Path does not have to exist.
32		*/
33	6	public function __construct(string $path = null)
34		{
35	6	$this->path = $path;
36	6	}
37
38		/**
39		* Used to perform copies and moves.
40		*
41		* @param string $operation
42		* @param string $destination
43		* @throws FileNotFoundException
44		* @throws FilesystemException
45		* @throws FileAlreadyExistsException
46		* @throws FileNotReadableException
47		* @throws FileNotWriteableException
48		*/
49	2	private function directoryOperation(string $operation, string $destination):void
50		{
51	2	foreach ($this->getFiles(true) as $file) {
52	2	$fileTarget = $destination . DIRECTORY_SEPARATOR . substr($file, strlen($this->path));
53	2	if(is_dir($file)) {
54	2	continue;
55		}
56		try{
57	2	Filesystem::checkExists(dirname($fileTarget));
58	2	} catch (FileNotFoundException $exception) {
59	2	Filesystem::directory(dirname($fileTarget))->create(true);
60		}
61
62	2	$file->$operation($fileTarget);
63		}
64	2	}
65
66		/**
67		* Recursively copies directory and its contents to destination.
68		*
69		* @param string $destination
70		* @throws FileNotFoundException
71		* @throws FilesystemException
72		* @throws FileAlreadyExistsException
73		* @throws FileNotReadableException
74		* @throws FileNotWriteableException
75		*/
76	1	public function copyTo(string $destination): void
77		{
78	1	$this->directoryOperation('copyTo', $destination);
79	1	}
80
81		/**
82		* Recursively get the size of all contents in the directory.
83		*
84		* @return integer
85		* @throws FileNotFoundException
86		* @throws FilesystemException
87		* @throws FileNotReadableException
88		*/
89	1	public function getSize() : int
90		{
91	1	return $this->getFiles()->getSize();
92		}
93
94		/**
95		* Recursively move a directory and its contents to another location.
96		*
97		* @param string $destination
98		* @throws FileNotFoundException
99		* @throws FilesystemException
100		* @throws FileAlreadyExistsException
101		* @throws FileNotReadableException
102		* @throws FileNotWriteableException
103		*/
104	1	public function moveTo(string $destination) : void
105		{
106	1	$this->directoryOperation('moveTo', $destination);
107	1	$this->delete();
108	1	$this->path = $destination;
109	1	}
110
111		/**
112		* Create the directory pointed to by path.
113		*
114		* @param int $permissions
115		* @throws FileAlreadyExistsException
116		* @throws FileNotWriteableException
117		*/
118	2	public function create($recursive=false, $permissions = 0755)
119		{
120	2	Filesystem::checkNotExists($this->path);
121	2	$parent = $this->path;
122	2	if($recursive) {
123	2	$segments = explode(DIRECTORY_SEPARATOR, $this->path);
124	2	$parent = "";
125	2	foreach($segments as $segment) {
126	2	$parent .= $segment . DIRECTORY_SEPARATOR;
127	2	if(!is_dir($parent)) {
128	2	break;
129		}
130		}
131		}
132	2	$parent = dirname($parent);
133	2	Filesystem::checkWritable($parent == "" ? '.' : $parent);
134	2	mkdir($this->path, $permissions, true);
135
136	2	return $this;
137		}
138
139		public function createIfNotExists($recursive=false, $permissions = 0755)
140		{
141		try {
142		$this->create($recursive, $permissions);
143		} catch (FileAlreadyExistsException $exception) {
144		// Do nothing
145		}
146		return $this;
147		}
148
149		/**
150		* Recursively delete the directory and all its contents.
151		*
152		* @throws FileNotFoundException
153		* @throws FilesystemException
154		* @throws FileNotReadableException
155		*/
156	2	public function delete() : void
157		{
158	2	$this->getFiles()->delete();
159	2	rmdir($this->path);
160	2	}
161
162		/**
163		* Get the path of the directory.
164		*
165		* @return string
166		*/
167	1	public function getPath() : string
168		{
169	1	return $this->path;
170		}
171
172		/**
173		* Get the files in the directory.
174		*
175		* @throws FilesystemException
176		* @throws FileNotFoundException
177		* @throws FileNotReadableException
178		* @return FileCollection \| array<string>
179		*/
180	5	public function getFiles($recursive=false, $returnStrings=false)
181		{
182	5	Filesystem::checkExists($this->path);
183	5	Filesystem::checkReadable($this->path);
184	5	$contents = [];
185
186	5	$files = scandir($this->path);
187	5	foreach ($files as $file) {
188	5	if($file == '.' \|\| $file == '..') continue;
189	5	$path = "$this->path/$file";
190	5	if(is_dir($path) && $recursive) {
191	2	$contents = array_merge($contents, Filesystem::directory($path)->getFiles(true, true));
192		}
193	5	$contents[] = $path;
194		}
195	5	return $returnStrings ? $contents : new FileCollection($contents);
196		}
197
198	3	public function __toString()
199		{
200	3	return $this->path;
201		}
202		}
203

ntentan / utils

Push — dev ( 385789...5662c6 )

Directory::createIfNotExists() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like