lekoala / silverstripe-admini

src/Helpers/FileHelper.php

<?php

namespace LeKoala\Admini\Helpers;

use RecursiveIteratorIterator;
use RecursiveDirectoryIterator;

class FileHelper
{

    /**
     * Slightly modified version of http://www.geekality.net/2011/05/28/php-tail-tackling-large-files/
     * @author Torleif Berger, Lorenzo Stanco
     * @link http://stackoverflow.com/a/15025877/995958
     * @license http://creativecommons.org/licenses/by/3.0/
     */
    public static function tail($filepath, $lines = 1, $adaptive = true)
    {
        // Open file
        $f = @fopen($filepath, "rb");
        if ($f === false) {
            return false;
        }

        // Sets buffer size, according to the number of lines to retrieve.
        // This gives a performance boost when reading a few lines from the file.
        if (!$adaptive) {
            $buffer = 4096;
        } else {
            $buffer = ($lines < 2 ? 64 : ($lines < 10 ? 512 : 4096));
        }
        // Jump to last character
        fseek($f, -1, SEEK_END);
        // Read it and adjust line number if necessary
        // (Otherwise the result would be wrong if file doesn't end with a blank line)
        if (fread($f, 1) != "\n") {
            $lines -= 1;
        }

        // Start reading
        $output = '';
        $chunk = '';

The assignment to $chunk is dead and can be removed.

        // While we would like more
        while (ftell($f) > 0 && $lines >= 0) {
            // Figure out how far back we should jump
            $seek = min(ftell($f), $buffer);
            // Do the jump (backwards, relative to where we are)
            fseek($f, -$seek, SEEK_CUR);
            // Read a chunk and prepend it to our output
            $output = ($chunk = fread($f, $seek)) . $output;
            // Jump back to where we started reading
            fseek($f, -mb_strlen($chunk, '8bit'), SEEK_CUR);
            // Decrease our line counter
            $lines -= substr_count($chunk, "\n");
        }
        // While we have too many lines
        // (Because of buffer size we might have read too many)
        while ($lines++ < 0) {
            // Find first newline and remove all text before that
            $output = substr($output, strpos($output, "\n") + 1);
        }
        // Close file and return
        fclose($f);
        return trim($output);
    }

    /**
     * Recursively remove a dir
     *
     * @param string $dir
     * @return bool
     */
    public static function rmDir($dir)
    {
        if (!is_dir($dir)) {
            return false;
        }
        $it = new RecursiveDirectoryIterator($dir, RecursiveDirectoryIterator::SKIP_DOTS);
        $files = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);
        foreach ($files as $file) {
            if ($file->isDir()) {
                rmdir($file->getRealPath());
            } else {
                unlink($file->getRealPath());
            }
        }
        return rmdir($dir);
    }

    /**
     * Check if a directory contains children
     *
     * @link https://stackoverflow.com/questions/6786014/php-fastest-way-to-find-if-directory-has-children
     * @param string $dir
     * @return bool
     */
    public static function dirContainsChildren($dir)
    {
        $result = false;
        if ($dh = opendir($dir)) {
            while (!$result && ($file = readdir($dh)) !== false) {
                $result = $file !== "." && $file !== "..";
            }
            closedir($dh);
        }
        return $result;
    }

    /**
     * @link https://www.digitalocean.com/community/questions/proper-permissions-for-web-server-s-directory
     * @param string $dir
     * @return bool
     */
    public static function ensureDir($dir)
    {
        if (!is_dir($dir)) {
            return mkdir($dir, 0755, true);
        }
        return true;
    }

    /**
     * @param int $bytes
     * @param integer $decimals
     * @return string
     */
    public static function humanFilesize($bytes, $decimals = 2)
    {
        if ($bytes < 1024) {
            return $bytes . ' B';
        }
        $factor = floor(log($bytes, 1024));
        return sprintf("%.{$decimals}f ", $bytes / pow(1024, $factor)) . ['B', 'KB', 'MB', 'GB', 'TB', 'PB'][$factor];
    }

    public static function convertToByte($val)
    {
        $val  = trim($val);

        if (is_numeric($val)) {
            return $val;
        }

        $last = strtolower($val[strlen($val) - 1]);
        $val  = substr($val, 0, -1);

        switch ($last) {
            case 'g':
                $val *= 1024;
                // keep processing
            case 'm':
                $val *= 1024;
                // keep processing
            case 'k':
                $val *= 1024;
                // keep processing
        }

        return $val;
    }

    public static function memoryLimit()
    {
        return self::convertToByte(ini_get("memory_limit"));
    }
}