FileSystem.inc

<?php
class FileSystem
{

    const HASH_DIR_FILE_COUNT = 10000;

    const FILE_SIZE_BYTE     = 'B';
    const FILE_SIZE_KILOBYTE = 'kB';
    const FILE_SIZE_MEGABYTE = 'MB';
    const FILE_SIZE_GIGABYTE = 'GB';


    public static function clearDirectory($path, $deleteRoot=FALSE, array $omitFiles=array())
    {
        if (file_exists($path) === FALSE) {
            return FALSE;
        }

        $dir = new DirectoryIterator($path);
        while ($dir->valid() === TRUE) {
            if ($dir->isDot() === TRUE) {
                // This is '.' or '..'. Not interested.
                $dir->next();
                continue;
            }

            if ($dir->isDir() === TRUE) {
                // If $deleteRoot is FALSE, then we don't want to delete
                // .svn entries, as with directories like the oven directory,
                // this will break updates on parent directories.
                if ($deleteRoot === FALSE) {
                    if ($dir->getFileName() === '.svn') {
                        $dir->next();
                        continue;
                    }
                }

                // Recursively call this method to clear nested directories.
                if (self::clearDirectory($dir->getPathName(), FALSE) === FALSE) {
                    return FALSE;
                }

                // Directory is now clear, so we can remove the directory.
                if (rmdir($dir->getPathName()) === FALSE) {
                    // Unable to delete the directory. Throw Exception, as the
                    // operation will ultimately fail.
                    $error = 'Unable to delete directory: '.$dir->getPathName;
                    throw new RuntimeException($error);
                }

                $dir->next();
                continue;
            }//end if $dir->isDir()

            // We have a file or symbolic link, we need to unlink it.
            if (in_array($dir->getFileName(), $omitFiles) === FALSE) {
                if (unlink($dir->getPathName()) === FALSE) {
                    // Problem deleting the file, throw exception.
                    $error = 'Unable to delete file: '.$dir->getPathName;
                    throw new RuntimeException($error);
                }
            }

            $dir->next();
        }//end while

        if ($deleteRoot === TRUE) {
            if (file_exists($path) === TRUE) {
                if (rmdir($path) === FALSE) {
                    $error = 'Unable to delete directory: '.$dir->getPathName;
                    throw new RuntimeException($error);
                }
            }
        }

        return TRUE;

    }//end clearDirectory()


    public static function listDirectory($path, array $extensions=array(), $nested=TRUE, $fullPath=TRUE)
    {
        $files = array();
        if (file_exists($path) === FALSE) {
            return $files;
        }

        $dir = new DirectoryIterator($path);
        while ($dir->valid() === TRUE) {
            if ($dir->isDot() === TRUE) {
                // This is '.' or '..'. Not interested.
                $dir->next();
                continue;
            }

            if ($dir->isDir() === TRUE && $nested === TRUE) {
                if ($dir->getFileName() === '.svn') {
                    $dir->next();
                    continue;
                }

                // Recursively call this method to list nested directories.
                $nestedDirectory = self::listDirectory($dir->getPathName(), $extensions, $nested, $fullPath);
                // Merge the files from the subdirectory with ours.
                $files = array_merge($files, $nestedDirectory);
                $dir->next();
                continue;
            }

            // We have a file, so we need to determine if it fits the specified
            // criteria.
            if ($dir->isFile() === TRUE) {

                $addFile  = FALSE;
                $filename = $dir->getFilename();

                // Skip hidden files.
                if ($filename{0} !== '.') {

                    if (empty($extensions) === TRUE) {
                        // No extensions, every file should be added.
                        $addFile = TRUE;
                    } else {
                        // Determine if the file has the right extension.
                        $fileName = $dir->getFileName();
                        $dotPos   = strrpos($fileName, '.');
                        $fileExt  = substr($fileName, $dotPos);
                        if (in_array($fileExt, $extensions) === TRUE) {
                            // Correct extension. Set our flag so it's added below.
                            $addFile = TRUE;
                        }
                    }

                    if ($addFile === TRUE) {
                        // File fits our criteria, now we only need to work out
                        // which details to add to our array.
                        if ($fullPath === TRUE) {
                            $files[] = $dir->getPathName();
                        } else {
                            $files[] = $dir->getFileName();
                        }
                    }
                }//end if

            }//end if isFile()

            $dir->next();
        }//end while valid()

        return $files;

    }//end listDirectory()


    public static function findDirectories($path, $name)
    {
        $dir = new RecursiveDirectoryIterator($path);

        $paths = array();
        foreach ($dir as $file) {
            if ($file->isDir() === TRUE) {
                if ($file->getFilename() === $name) {
                    $paths[] = $file->getPathname();
                } else {
                    $paths = array_merge($paths, self::findDirectories($file->getPathName(), $name));
                }
            }
        }

        return $paths;

    }//end findDirectories()


    public static function getHashDir($id)
    {
        $id = (int) $id;
        if ($id <= 0) {
            throw new InvalidArgumentException('$id must be positive');
        }

        $endId   = (ceil(($id / self::HASH_DIR_FILE_COUNT)) * self::HASH_DIR_FILE_COUNT);
        $startId = ($endId - self::HASH_DIR_FILE_COUNT + 1);

        return $startId.'-'.$endId;

    }//end getHashDir()


    public static function readableSize($path, $unit=NULL)
    {
        $size = @filesize($path);
        if ($size === FALSE) {
            return FALSE;
        }

        $units = array(
                  self::FILE_SIZE_BYTE,
                  self::FILE_SIZE_KILOBYTE,
                  self::FILE_SIZE_MEGABYTE,
                  self::FILE_SIZE_GIGABYTE,
                 );
        $maxUnit = (count($units) - 1);

        // Accept units as a parameter, maybe...
        $unit = array_search($unit, $units);
        if ($unit === NULL || $unit === FALSE) {
            $unit = $maxUnit;
        }

        $factor = 0;
        while ($unit !== $factor && $size >= 1000 && $factor < $maxUnit) {
            $size = ($size / 1000);
            $factor++;
        }

        return sprintf('%01.2f%s', $size, $units[$factor]);

    }//end readableSize()


    public static function getBaseName($path)
    {
        $fileName = preg_replace( '/^.+[\\\\\\/]/', '', $path);
        return $fileName;

    }//end getBaseName()


}//end class

?>