TraderInteractive\Util\File

Complexity

Total Complexity

19

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	deleteDirectoryContents()	0	21	6
A	delete()	0	15	5
A	deletePathIfEmpty()	0	26	6
A	throwIfFalse()	0	4	2

<?php
/**
 * Defines the \TraderInteractive\Util\File class.
 */

namespace TraderInteractive\Util;

/**
 * Class of static file utility functions.
 */
final class File
{
    /**
     * Recursively deletes directory contents
     *
     * @param string $directoryPath absolute path of directory
     *
     * @return void
     *
     * @throws \Exception if file cannot be deleted
     * @throws \Exception if directory cannot be deleted
     * @throws \Exception if $directoryPath cannot be listed
     */
    public static function deleteDirectoryContents(string $directoryPath)
    {
        $paths = scandir($directoryPath);
        if ($paths === false) {
            throw new \Exception("cannot list directory '{$directoryPath}'");
        }

        foreach ($paths as $path) {
            if ($path === '.' || $path === '..') {
                continue;
            }

            $fullPath = "{$directoryPath}/{$path}";

            if (is_dir($fullPath)) {
                self::deleteDirectoryContents($fullPath);//RECURSIVE CALL
                self::throwIfFalse(rmdir($fullPath), "cannot delete '{$fullPath}'", 1);
                continue;
            }

            self::throwIfFalse(unlink($fullPath), "cannot delete '{$fullPath}'", 2);
        }
    }

    /**
     * Deletes the given file specified by $path
     *
     * @param string $path path to the file to be deleted
     *
     * @return void
     *
     * @throws \InvalidArgumentException if $path is whitespace
     * @throws \Exception if unlink returns false
     */
    public static function delete(string $path)
    {
        if (trim($path) === '') {
            throw new \InvalidArgumentException('$path is not a string or is whitespace');
        }

        if (!file_exists($path)) {
            return;
        }

        try {
            self::throwIfFalse(unlink($path), "unlink returned false for '{$path}'");
        } catch (\Exception $e) {
            if (file_exists($path)) {
                throw $e;
            }
        }
    }

    /**
     * Recursively deletes the given directory path until a non-empty directory is found or the $stopAtPath is reached.
     *
     * @param string $deletePath The empty directory path to delete.
     * @param string $stopAtPath The point at which the deletion should stop. Defaults to /.
     *
     * @return void
     */
    public static function deletePathIfEmpty(string $deletePath, string $stopAtPath = '/')
    {
        if (!file_exists($deletePath)) {
            return;
        }

        if (realpath($deletePath) === realpath($stopAtPath)) {
            return;
        }

        $handle = dir($deletePath);
        for ($entry = $handle->read(); $entry !== false; $entry = $handle->read()) {
            if ($entry == '.' || $entry == '..') {
                continue;
            }

            //dir not empty
            $handle->close();
            return;
        }

        rmdir($deletePath);
        $handle->close();

        //RECURSION!!!
        self::deletePathIfEmpty(dirname($deletePath), $stopAtPath);
    }

    private static function throwIfFalse($condition, string $message, int $code = 0)
    {
        if ($condition === false) {
            throw new \Exception($message, $code);
        }
    }
}