Filesystem::mkdir() - Code Metrics - Inspection of "V2.0.0" - degagne/filesystem - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#5)

by Deric
created 2018-01-25 05:19 UTC
Filesystem::mkdir() B

↳ Parent: Filesystem
Complexity

Conditions	5
Paths	12
Size

Total Lines	14
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	5
eloc	8
nc	12
nop	4
dl	0
loc	14
rs	8.8571
c	0
b	0
f	0
<?php
namespace Filesystem;

use Filesystem\Exceptions\FileModeException;
use Filesystem\Exceptions\FileCopyException;
use Filesystem\Exceptions\FileDeleteException;
use Filesystem\Exceptions\DirectoryCreateException;
use Filesystem\Exceptions\DirectoryDeleteException;
use Filesystem\Exceptions\FileMoveException;
use Filesystem\Exceptions\FileExistException;

/**
 * Filesystem class.
 *
 * @package Filesystem
 */
class Filesystem
{

    /**
     * FileModeException code.
     *
     * @var int
     */
    const FILEMODE = 10;

    /**
     * FileCopyException code.
     *
     * @var int
     */
    const FILECOPY = 11;

    /**
     * FileDeleteException code.
     *
     * @var int
     */
    const FILEDELETE = 12;

    /**
     * DirectoryCreateException code.
     *
     * @var int
     */
    const DIRECTORYCREATE = 13;

    /**
     * DirectoryDeleteException code.
     *
     * @var int
     */
    const DIRECTORYDELETE = 14;

    /**
     * FileMoveException code.
     *
     * @var int
     */
    const FILEMOVE = 15;

    /**
     * FileExistException code.
     *
     * @var int
     */
    const FILEEXISTS = 16;

    /**
     * Changes file mode.
     *
     * @param  string $filename  path to the file
     * @param  int 	  $mode 	 file mode
     * @param  bool   $recursive recursive file mode change
     * @return mixed  true on success exception or error message on failure
     */
    final public static function chmod($filename, $mode, $recursive = false, $strict = true)
    {
        $recursive = ($recursive) ? "-R" : "";
        $mode = (int) $mode;
        $retval = shell_exec("chmod {$recursive} {$mode} {$filename}; echo $?");
        if ($retval != 0)
        {
            $code = self::FILEMODE;
            $message = "Failed to set file mode for {$filename}";
            return self::get_error_message($code, $message, $strict);
        }
        return true;
    }

    /**
     * Changes group of file.
     *
     * @param  string $filename  path to the file
     * @param  int 	  $group 	 file group
     * @param  bool   $recursive recursive file mode change
     * @return mixed  true on success exception or error message on failure
     */
    final public static function chgrp($filename, $group, $recursive = false, $strict = true)
    {
        $recursive = ($recursive) ? "-R " : "";
        $retval = shell_exec("chgrp {$recursive} {$group} {$filename}; echo $?");
        if ($retval != 0)
        {
            $code = self::FILEMODE;
            $message = "Failed to set file group for {$filename} to {$group}";
            return self::get_error_message($code, $message, $strict);
        }
    }

    /**
     * Copies file.
     *
     * @param  string $srcfile  path to the source file
     * @param  string $destfile path to the destination file
     * @return mixed  true on success exception or error message on failure
     */
    final public static function copy($srcfile, $destfile)
    {
        if (is_file($srcfile) === false)
        {
            $code = self::FILEEXISTS;
            $message = "Original (source) file does not exist {$srcfile}";
            return self::get_error_message($code, $message, true);
        }

        if (@copy($srcfile, $destfile) === false)
        {
            $code = self::FILECOPY;
            $message = "Failed to create copy of {$srcfile} to {$destfile}";
            return self::get_error_message($code, $message, true);
        }
        return true;
    }

    /**
     * Removes files.
     *
     * @param  mixed $files  one or more files to delete
     * @param  bool  $strict strict error checking
     * @return bool
     */
    final public static function delete($files, $strict = true)
    {
        $files = !is_array($files) ? [$files] : $files;
        foreach ($files as $file)
        {
            if (is_file($file))
            {
                if (@unlink($file) === false)
                {
                    $code = self::FILEDELETE;
                    $message = "Failed to delete {$file}";
                    return self::get_error_message($code, $message, $strict);

                }
                continue;
            }
        }
        return true;
    }

    /**
     * Returns pathnames matching a pattern (for files only & hidden files).
     *
     * @param  string $directory directory
     * @param  mixed  $pattern   pattern (does not support tilde expansion)
     * @return mixed  matched files or false for non-existent directory
     */
    final public static function glob($directory, $pattern = null)
    {
        if (is_dir($directory) === false)
        {
            return false;
        }

        $pattern = is_array(($pattern)) ? '{'.implode(',', $pattern).'}' : $pattern;
        if ($pattern === null)
        {
            return array_diff(glob($directory.'/*'), ['.', '..']);
        }
        return glob($directory.'/{,.}*'.$pattern.'*', GLOB_BRACE);
    }

    /**
     * Tells whether the filename is a regular file.
     *
     * @param string $filename path to the file
     * @param boolean
     */
    final public static function lsdir($directory)
    {
        if (is_dir($directory) === false)
        {
            return false;
        }

        $directories = [];
        $directory = rtrim($directory, '/');
        foreach (self::readdir($directory) as $directory)
        {
            if (is_dir($directory))
            {
                $directories[] = $directory;
            }
        }
        return $directories;
    }

    /**
     * Tells whether the filename is a regular file.
     *
     * @param string $filename path to the file
     * @param boolean
     */
    final public static function lsfile($directory)
    {
        if (is_dir($directory) === false)
        {
            return false;
        }

        $files = [];
        $directory = rtrim($directory, '/');
        foreach (self::readdir($directory) as $file)
        {
            if (is_file($file))
            {
                $files[] = $file;
            }
        }
        return $files;
    }

    /**
     * Create new directory.
     *
     * @param  mixed  $directories path to the directory
     * @param  int    $mode        directory permission mode value (octal)
     * @param  bool   $recursive   create directories as needed
     * @param  bool   $strict      strict error checking
     * @return mixed
     */
    final public static function mkdir($directories, $mode = null, $recursive = false, $strict = true)
    {
        $directories = !is_array($directories) ? [$directories] : $directories;
        $mode = ($mode === null) ? (int) $mode : 0777;
        foreach ($directories as $directory)
        {
            if (@mkdir($directory, (int) $mode, $recursive) === false)
            {
                $code = self::DIRECTORYCREATE;
                $message = "Failed to create new directory {$directory}";
                return self::get_error_message($code, $message, $strict);
            }
        }
        return true;
    }

    /**
     * Reads a directory and returns all files/directories.
     *
     * @param string $directory directory path
     * @param mixed
     */
    final private static function readdir($directory)
    {
        $files = [];
        if ($handle = @opendir($directory))
        {
            while (($file = @readdir($handle)) !== false)
            {
                if ($file != '.' && $file != '..')
                {
                    $files[] = $directory.'/'.$file;
                }
            }
        }
        return $files;
    }

    /**
     * Removes directory.
     *
     * NOTES:
     *  -	directories that are not empty are emptied then deleted
     *	-	accepts one or more directories (recursive)
     *
     * @param  mixed   $directories directory or directories to remove
     * @param  bool    $strict strict error checking
     * @return mixed
     */
    final public static function rmdir($directories, $strict = true)
    {
        $directories = !is_array($directories) ? [$directories] : $directories;
        foreach ($directories as $directory)
        {
            if (is_dir($directory))
            {
                start:
                $files = @self::lsfile($directory);
                if (count($files) == 0)
                if (count(/** @scrutinizer ignore-type */ $files) == 0)
                {
                    if (@rmdir($directory) === false)
                    {
                        $code = self::DIRECTORYDELETE;
                        $message = "Failed to delete directory {$directory}";
                        return self::get_error_message($code, $message, $strict);
                    }
                    continue;
                }

                if (count($files) != 0)
                {
                    self::delete($files);
                    goto start;
                }
            }
        }
        return true;
    }

    /**
     * Moves file to different path (rename).
     *
     * @param  string $oldfile path to the old file
     * @param  string $newfile path to the new file
     * @return mixed
     */
    final public static function rename($oldfile, $newfile)
    {
        if (is_file($oldfile) === false)
        {
            $code = self::FILEEXISTS;
            $message = "Original (source) file does not exist {$srcfile}";

            return self::get_error_message($code, $message, true);
        }

        if (!@rename($oldfile, $newfile))
        {
            $code = self::FILEMOVE;
            $message = "Failed to move (rename) file from {$oldfile} to {$newfile}";
            return self::get_error_message($code, $message, true);

        }
        return true;
    }

    /**
     * Create temporary file.
     *
     * @param  string $template temporary filename template (default=tmp-XXXXXXXXXXXXXX)
     * @param  bool   $resource request file pointer into temporary file
     * @return mixed
     */
    final public static function tmpfile($template = null, $resource = false)
    {
        $template = ($template === null) ? " tmp-XXXXXXXXXXXXXX" : " {$template}-XXXXXXXXXXXXXX";
        $tempfile = shell_exec("mktemp -p /tmp {$template}");
        return ($resource == false) ? rtrim($tempfile) : fopen($tempfile, "w+");

    }

    /**
     * Create temporary directory.
     *
     * @param  string $template temporary directory template (default=tmpXXXXXXXXXXXXXX)
     * @return mixed
     */
    final public static function tmpdir($template = null)
    {
        $template = ($template === null) ? " tmpXXXXXXXXXXXXXX" : " {$template}XXXXXXXXXXXXXX";
        $tempdir = shell_exec("mktemp -p /tmp -d {$template}");
        return rtrim($tempdir);
    }

    /**
     * Returns error message or throws exception.
     *
     * @return string error message
     */
    final private static function get_error_message($code, $message, $strict)
    {
        if ($strict == false) { return $message; }

        switch ($code)
        {
            case '10':  throw new FileModeException($message);
            case '11':  throw new FileCopyException($message);
            case '12':  throw new FileDeleteException($message);
            case '13':  throw new DirectoryCreateException($message);
            case '14':  throw new DirectoryDeleteException($message);
            case '15':  throw new FileMoveException($message);
            case '16':  throw new FileExistException($message);
        }
    }
}

degagne / filesystem

Pull Request — master (#5)

Filesystem::mkdir() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
