yf_dir class

    public function chmod($start_dir, $new_mode = 0755, $pattern_include = '', $pattern_exclude = '')
    {
        return $this->chmod_dir($start_dir, $new_mode, $pattern_include, $pattern_exclude);
    }

    public function chmod_dir($start_dir, $new_mode = 0755, $pattern_include = '', $pattern_exclude = '')
    {
        if ( ! $start_dir || ! file_exists($start_dir) || empty($new_mode)) {
            return false;
        }
        $func = __FUNCTION__;
        $start_dir = rtrim($start_dir, '/');

        $dh = opendir($start_dir);
        while (false !== ($f = readdir($dh))) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $item = $start_dir . '/' . $f;
            $_is_dir = is_dir($item);
            // Check patterns
            if ($this->_skip_by_pattern($item, $_is_dir, $pattern_include, $pattern_exclude)) {
                continue;
            }
            chmod($item, $new_mode);
            if ($_is_dir) {
                $this->$func($item, $new_mode);
            }
        }
    }

    public function copy($path1, $path2, $pattern_include = '', $pattern_exclude = '', $level = null)
    {
        return $this->copy_dir($path1, $path2, $pattern_include, $pattern_exclude, $level);
    }

    public function copy_dir($path1, $path2, $pattern_include = '', $pattern_exclude = '', $level = null)
    {
        if ( ! $path1 || ! file_exists($path1)) {
            return false;
        }
        $func = __FUNCTION__;
        $path1 = rtrim(str_replace('\\', '/', realpath($path1)), '/');
        $path2 = rtrim(str_replace('\\', '/', realpath($path2)), '/');

        $dh = opendir($path1);
        $old_mask = umask(0);
        if ( ! file_exists($path2)) {
            $this->mkdir_m($path2);
        }
        while (false !== ($f = readdir($dh))) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $item_1 = $path1 . '/' . $f;
            $item_2 = $path2 . '/' . $f;
            $_is_dir = is_dir($item_1);
            // Check patterns
            if ($this->_skip_by_pattern($item_1, $_is_dir, $pattern_include, $pattern_exclude)) {
                continue;
            }
            if ($_is_dir) {
                if ( ! file_exists($item_2)) {
                    $this->mkdir_m($item_2);
                }
                if ($level === null || $level > 0) {
                    $this->$func($item_1, $item_2, $pattern_include, $pattern_exclude, $level === null ? $level : $level - 1);
                }
            } else {
                $this->_copy_file($item_1, $item_2);
            }
        }
        umask($old_mask);
    }

    public function count_files($start_dir, $pattern_include = '', $pattern_exclude = '')
    {
        if ( ! $start_dir || ! file_exists($start_dir)) {
            return false;
        }
        $start_dir = rtrim($start_dir, '/');

        $dh = opendir($start_dir);
        $num_files = 0;
        while (($f = readdir($dh)) !== false) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $path = $start_dir . '/' . $f;
            $_is_dir = is_dir($path);
            // Check patterns
            if ($this->_skip_by_pattern($path, $_is_dir, $pattern_include, $pattern_exclude)) {
                continue;
            }
            if ($_is_dir) {
                $num_files += $this->count_files($path . '/', $pattern_include, $pattern_exclude);
            } elseif (is_file($path)) {
                $num_files++;
            }
        }
        closedir($dh);
        return $num_files;
    }

    public function delete($start_dir, $delete_start_dir = false)
    {
        return $this->delete_dir($start_dir, $delete_start_dir);
    }

    public function delete_dir($start_dir, $delete_start_dir = false)
    {
        if ( ! $start_dir || ! file_exists($start_dir)) {
            return false;
        }
        $func = __FUNCTION__;
        $start_dir = rtrim($start_dir, '/');
        $sub_dirs_list = [];
        // Process folder contents
        $sub_dirs_list = [];
        $dh = opendir($start_dir);
        while (false !== ($f = readdir($dh))) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $item = str_replace('//', '/', $start_dir . '/' . $f);
            chmod($item, 0777);
            // Delete files immediatelly
            if (is_file($item)) {
                unlink($item);
                // Store folders to delete in stack and try to delete sub items
            } elseif (is_dir($item)) {
                $this->$func($item);
                $sub_dirs_list[] = $item;
            }
        }
        closedir($dh);
        // Now try to delete sub folders
        foreach ((array) $sub_dirs_list as $dir_name) {
            rmdir($dir_name);
        }
        // Do delete start dir if needed
        if ($delete_start_dir) {
            rmdir($start_dir);
        }
    }

    public function delete_files($start_dir, $pattern_include = '', $pattern_exclude = '')
    {
        foreach ((array) $this->scan_dir($start_dir, 1, $pattern_include, $pattern_exclude) as $file_path) {
            unlink($file_path);
        }
    }

    public function dirsize($start_dir, $pattern_include = '', $pattern_exclude = '')
    {
        if ( ! $start_dir || ! file_exists($start_dir)) {
            return false;
        }
        $start_dir = rtrim($start_dir, '/');

        $dh = opendir($start_dir);
        $size = 0;
        while (($f = readdir($dh)) !== false) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $path = $start_dir . '/' . $f;
            $_is_dir = is_dir($path);
            // Check patterns
            if ($this->_skip_by_pattern($path, $_is_dir, $pattern_include, $pattern_exclude)) {
                continue;
            }
            if ($_is_dir) {
                $size += $this->dirsize($path . '/', $pattern_include, $pattern_exclude);
            } elseif (is_file($path)) {
                $size += filesize($path);
            }
        }
        closedir($dh);
        return $size;
    }

    public function find($folder, $pattern = '*')
    {
        return explode("\n", trim(shell_exec('find -L ' . escapeshellarg($folder) . ' -iname ' . escapeshellarg($pattern))));
    }

    public function grep($pattern_find, $start_dirs, $pattern_path = '*', $extra = [])
    {
        if ( ! $pattern_find) {
            return false;
        }
        if ( ! $start_dirs) {
            $start_dirs = APP_PATH;
        }
        if ( ! is_array($start_dirs)) {
            $start_dirs = [$start_dirs];
        }
        if ( ! is_array($pattern_find)) {
            $pattern_find = [$pattern_find];
        }
        $files = [];
        foreach ((array) $start_dirs as $start_dir) {
            $start_dir = rtrim($start_dir, '/');
            foreach ((array) $this->rglob($start_dir, $pattern_path) as $path) {
                $files[] = $path;
            }
        }
        $matched = [];
        foreach ((array) $files as $_id => $path) {
            if (isset($extra['exclude_paths']) && wildcard_compare($extra['exclude_paths'], $path)) {
                continue;
            }
            $contents = file_get_contents($path);
            foreach ((array) $pattern_find as $p_find) {
                if (preg_match_all($p_find, $contents, $m)) {
                    $matched[$files[$_id]] = $extra['return_match'] && isset($m[$extra['return_match']]) ? $m[$extra['return_match']] : $m[0];
                    continue;
                }
            }
        }
        return $matched;
    }

    public function mkdir($dir_name, $dir_mode = 0755, $create_index_htmls = 0, $start_folder = '')
    {
        return $this->mkdir_m($dir_name, $dir_mode, $create_index_htmls, $start_folder);
    }

    public function mkdir_m($dir_name, $dir_mode = 0755, $create_index_htmls = 0, $start_folder = '')
    {
        if ( ! $dir_name || ! strlen($dir_name)) {
            return 0;
        }
        $dir_name = rtrim(str_replace(['\\', '//'], '/', $dir_name), '/');
        // Default dir mode
        if (empty($dir_mode)) {
            $dir_mode = 0777;
        }
        // Use native recursive function if applicable
        if ( ! $create_index_htmls) {
            if (file_exists($dir_name)) {
                return true;
            }
            return mkdir($dir_name, $dir_mode, true);
        }
        $old_mask = umask(0);
        // Default start folder to look at
        if ( ! strlen($start_folder)) {
            $start_folder = INCLUDE_PATH;
        }
        $start_folder = str_replace(['\\', '//'], '/', realpath($start_folder) . '/');
        // Process given file name
        if ( ! file_exists($dir_name)) {
            $base_path = OS_WINDOWS ? '' : '/';
            preg_match_all('/([^\/]+)\/?/i', $dir_name, $atmp);
            foreach ((array) $atmp[0] as $val) {
                $base_path = $base_path . $val;
                // Skip paths while we are out of base_folder
                if ( ! empty($start_folder) && false === strpos($base_path, $start_folder)) {
                    continue;
                }
                // Skip if already exists
                if (file_exists($base_path)) {
                    continue;
                } elseif ($this->CHECK_IF_WRITABLE && ! is_writable(dirname($base_path))) {
                    trigger_error('DIR: directory: ' . dirname($base_path) . ' is not writable', E_USER_WARNING);
                }
                // Try to create sub dir
                if ( ! mkdir($base_path, $dir_mode)) {
                    trigger_error('DIR: Cannot create: ' . $base_path, E_USER_WARNING);
                    return -1;
                }
                chmod($base_path, $dir_mode);
            }
        } elseif ( ! is_dir($dir_name)) {
            trigger_error('DIR: ' . $dir_name . ' exists and is not a directory', E_USER_WARNING);
            return -2;
        }
        // Create empty index.html in new folder if needed
        if ($create_index_htmls) {
            $index_file_path = $dir_name . '/index.html';
            if ( ! file_exists($index_file_path)) {
                file_put_contents($index_file_path, '');
            }
        }
        umask($old_mask);
        return 0;
    }

    public function mklink($target, $link)
    {
        // Required fixes for trailink slash
        $target = rtrim(str_replace('\\', '/', $target), '/');
        $link = rtrim(str_replace('\\', '/', $link), '/');
        // Check required stuff
        if ( ! strlen($target) || ! strlen($link) || ! file_exists($target)) {
            return false;
        }
        if (function_exists('symlink')) {
            return symlink($target, $link);
        }
        return false;
    }

    public function move($path1, $path2, $pattern_include = '', $pattern_exclude = '')
    {
        return $this->move_dir($path1, $path2, $pattern_include, $pattern_exclude);
    }

    public function move_dir($path1, $path2, $pattern_include = '', $pattern_exclude = '')
    {
        if ( ! $path1 || ! file_exists($path1)) {
            return false;
        }
        $func = __FUNCTION__;
        $path1 = rtrim($path1, '/');
        $path2 = rtrim($path2, '/');

        $dh = opendir($path1);
        if ( ! file_exists($path2)) {
            mkdir($path2, 0777);
        }
        while (false !== ($f = readdir($dh))) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $item_1 = $path1 . '/' . $f;
            $item_2 = $path2 . '/' . $f;
            $_is_dir = is_dir($item_1);
            // Check patterns
            if ($this->_skip_by_pattern($item_1, $_is_dir, $pattern_include, $pattern_exclude)) {
                continue;
            }
            if ($_is_dir) {
                if ( ! file_exists($item_2)) {
                    mkdir($item_2, 0777);
                }
                $this->$func($item_1, $item_2, $pattern_include, $pattern_exclude);
            } else {
                $this->_copy_file($item_1, $item_2);
                unlink($item_1);
            }
        }
        rmdir($path1);
    }

    public function replace($start_dirs, $pattern_include = '', $pattern_exclude = '', $pattern_find = '', $pattern_replace = '')
    {
        $files = [];
        if ( ! is_array($start_dirs)) {
            $start_dirs = [$start_dirs];
        }
        if ( ! $pattern_find || ! isset($pattern_replace)) {
            return false;
        }
        if ( ! is_array($pattern_find)) {
            $pattern_find = [$pattern_find => $pattern_replace];
        }
        foreach ((array) $start_dirs as $_dir_name) {
            foreach ((array) $this->scan_dir($_dir_name, 1, $pattern_include, $pattern_exclude) as $_file_path) {
                $files[] = $_file_path;
            }
        }
        foreach ((array) $files as $_id => $_file_path) {
            $contents = file_get_contents($_file_path);
            $what = [];
            foreach ((array) $pattern_find as $p_find => $p_replace) {
                if (preg_match($p_find, $contents)) {
                    $what[$p_find] = $p_replace;
                }
            }
            // This needed to not log/touch/override files that have no matches
            if ( ! $what) {
                unset($files[$_id]);
                continue;
            }
            $contents_new = preg_replace(array_keys($what), array_values($what), $contents);
            if ($contents_new !== $contents) {
                file_put_contents($_file_path, $contents_new);
            }
        }
        return $files;
    }

    public function rglob($folder, $pattern = '*')
    {
        $folder = rtrim($folder, '/');
        if (false === strpos($pattern, '[')) {
            $pattern = $this->_pattern_regcase($pattern);
        }

        $files = (array) glob($folder . '/' . $pattern, GLOB_NOSORT);
        $dirs = array_merge(
            (array) glob($folder . '/*', GLOB_ONLYDIR | GLOB_NOSORT),
            array_filter((array) glob($folder . '/.*', GLOB_ONLYDIR | GLOB_NOSORT), function ($path) {
                $d = basename($path);
                return $d !== '.' && $d !== '..' && $d !== '.git' && $d !== '.svn';
            })
        );

        foreach ($dirs as $dir) {
            $files = array_merge($files, $this->rglob($dir, $pattern));
        }

        return $files;
    }

    public function riterate($folder, $pattern = '~.+~')
    {
        $out = [];
        $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::FOLLOW_SYMLINKS;
        foreach (new RegexIterator(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($folder, $flags)), $pattern, RegexIterator::GET_MATCH) as $path => $f) {
            $out[] = $path;
        }
        return $out;
    }

    public function scan($start_dir, $_tmp = true, $pattern_include = '', $pattern_exclude = '')
    {
        return $this->scan_dir($start_dir, $_tmp, $pattern_include, $pattern_exclude);
    }

    public function scan_dir($start_dir, $_tmp = 1, $pattern_include = '', $pattern_exclude = '')
    {
        $func = __FUNCTION__;
        // Here we accept several start folders, result will be merged
        if (is_array($start_dir)) {
            $_files = null;
            foreach ((array) $start_dir as $_dir_name) {
                foreach ((array) $this->$func($_dir_name, 1, $pattern_include, $pattern_exclude) as $_file_path) {
                    $_files[] = $_file_path;
                }
            }
            return $_files;
        }
        if ( ! $start_dir || ! file_exists($start_dir)) {
            return false;
        }
        $start_dir = rtrim($start_dir, '/');
        $files = [];
        $dh = opendir($start_dir);
        while (false !== ($f = readdir($dh))) {
            if ($f == '.' || $f == '..') {
                continue;
            }
            $item = $start_dir . '/' . $f;
            $_is_dir = is_dir($item);
            if ($this->_skip_by_pattern($item, $_is_dir, $pattern_include, $pattern_exclude)) {
                continue;
            }
            if ($_is_dir) {
                $files = array_merge($files, $this->$func($item, 1, $pattern_include, $pattern_exclude));
            } elseif (is_file($item)) {
                $files[] = $item;
            }
        }
        closedir($dh);
        return $files;
    }

    public function scan_fast($start_dir, $pattern = '~.+~')
    {
        $files = [];
        $dh = @opendir($start_dir);
        if ( ! $dh) {
            return $files;
        }
        $func = __FUNCTION__;
        while (false !== ($f = readdir($dh))) {
            if ($f === '.' || $f === '..') {
                continue;
            }
            $item = $start_dir . '/' . $f;
            if (is_dir($item)) {
                $files = array_merge($files, $this->$func($item, $pattern));
            } elseif (is_file($item) && ( ! $pattern || preg_match($pattern, $item))) {
                $files[] = $item;
            }
        }
        closedir($dh);
        return $files;
    }

    public function search($start_dirs, $pattern_include = '', $pattern_exclude = '', $pattern_find = '')
    {
        if ( ! is_array($start_dirs)) {
            $start_dirs = [$start_dirs];
        }
        if ( ! $pattern_find) {
            return false;
        }
        if ( ! is_array($pattern_find)) {
            $pattern_find = [$pattern_find];
        }
        $files = [];
        foreach ((array) $start_dirs as $_dir_name) {
            foreach ((array) $this->scan_dir($_dir_name, 1, $pattern_include, $pattern_exclude) as $_file_path) {
                $files[] = $_file_path;
            }
        }
        $files_matched = [];
        foreach ((array) $files as $_id => $_file_path) {
            $contents = file_get_contents($_file_path);
            foreach ((array) $pattern_find as $p_find) {
                if (preg_match($p_find, $contents)) {
                    $files_matched[$_id] = $files[$_id];
                    continue;
                }
            }
        }
        return $files_matched;
    }

    public function size($start_dir, $pattern_include = '', $pattern_exclude = '')
    {
        return $this->dirsize($start_dir, $pattern_include, $pattern_exclude);
    }

    public function tail($file, $lines = 10)
    {
        if ( ! $file || ! file_exists($file)) {
            return false;
        }
        $handle = fopen($file, 'r');
        $linecounter = $lines;
        $pos = -2;
        $beginning = false;
        $text = [];
        while ($linecounter > 0) {
            $t = ' ';
            while ($t != "\n") {
                if (fseek($handle, $pos, SEEK_END) == -1) {
                    $beginning = true;
                    break;
                }
                $t = fgetc($handle);
                $pos--;
            }
            $linecounter--;
            if ($beginning) {
                rewind($handle);
            }
            $text[$lines - $linecounter - 1] = fgets($handle);
            if ($beginning) {
                break;
            }
        }
        fclose($handle);
        return array_reverse($text);
    }

    public function __call($name, $args)
    {
        return main()->extend_call($this, $name, $args);
    }

    public function _copy_file($path_from = '', $path_to = '')
    {
        if ( ! $path_from || ! $path_to) {
            return false;
        }
        $result = false;
        if ( ! file_exists($path_from)) {
            return false;
        }
        // Quick way
        $result = copy($path_from, $path_to);
        if ( ! $result) {
            $result = (bool) file_put_contents($path_to, file_get_contents($path_from));
        }
        return $result;
    }

    public function _gen_dir_path($id, $path = '', $make = false, $dir_mode = 0755, $create_index_htmls = 1)
    {
        // Make 3-level dir path
        $dirs = sprintf('%09s', $id);
        $dir3 = substr($dirs, -3, 3);
        $dir2 = substr($dirs, -6, 3);
        $dir1 = substr($dirs, 0, -6);
        // 3-level path
        $mpath = $dir1 . '/' . $dir2 . '/' . $dir3 . '/';
        // Add path prefix to string
        if (strlen($path) > 0) {
            // if last char in $path not '\' or '/' add '/'
            if ((substr($path, -1, 1) !== '/') && (substr($path, -1, 1) !== '\\')) {
                $path .= '/';
            }
            $mpath = $path . $mpath;
        }
        // Do create subdirs (if needed)
        if ($make) {
            $this->mkdir_m($mpath, $dir_mode, $create_index_htmls);
        }
        return $mpath;
    }

    public function _pattern_regcase($str)
    {
        $res = '';
        $chars = str_split($str);
        foreach ($chars as $char) {
            if (preg_match('/[A-Za-z]/', $char)) {
                $res .= '[' . mb_strtoupper($char, 'UTF-8') . mb_strtolower($char, 'UTF-8') . ']';
            } else {
                $res .= $char;
            }
        }
        return $res;
    }

    public function _skip_by_pattern($path = '', $_is_dir = false, $pattern_include = '', $pattern_exclude = '')
    {
        if ( ! $path) {
            return false;
        }
        if ( ! $pattern_include && ! $pattern_exclude) {
            return false;
        }
        $_path_clean = trim(str_replace('//', '/', str_replace('\\', '/', $path)));
        // Include files only if they match the mask
        $_index = $_is_dir ? 0 : 1;
        if ($_is_dir) {
            $_path_clean = rtrim($_path_clean, '/');
        }
        if (is_array($pattern_include)) {
            $pattern_include = $pattern_include[$_index];
        }
        if (is_array($pattern_exclude)) {
            $pattern_exclude = $pattern_exclude[$_index];
        }
        $modifier = '';
        $MATCHED = false;
        if ( ! empty($pattern_include) && is_string($pattern_include)) {
            // Examples: "-f /\.(jpg|png)$/", -d /some_dir/
            $try_modifier = substr($pattern_include, 0, 3);
            if (in_array($try_modifier, ['-f ', '-d '])) {
                $pattern_include = substr($pattern_include, 3);
                $modifier = $try_modifier;
            }
            if (strlen($pattern_include) == 2 && $pattern_include[0] == '-') {
                if ($pattern_include == '-d' && ! $_is_dir) {
                    $MATCHED = true;
                } elseif ($pattern_include == '-f' && $_is_dir) {
                    $MATCHED = true;
                }
            } else {
                $need_match = true;
                if ($modifier == '-f ' && $_is_dir) {
                    $need_match = false;
                } elseif ($modifier == '-d ' && ! $_is_dir) {
                    $need_match = false;
                }
                if ($need_match && ! preg_match($pattern_include . 'ims', $_path_clean)) {
                    $MATCHED = true;
                }
            }
        }
        // Exclude files from list by mask
        if ( ! empty($pattern_exclude) && is_string($pattern_exclude)) {
            // Examples: "-f /\.(jpg|png)$/", -d /some_dir/
            $try_modifier = substr($pattern_include, 0, 3);
            if (in_array($try_modifier, ['-f ', '-d '])) {
                $pattern_include = substr($pattern_include, 3);
                $modifier = $try_modifier;
            }
            if (strlen($pattern_exclude) == 2 && $pattern_exclude[0] == '-') {
                if ($pattern_exclude == '-d' && $_is_dir) {
                    $MATCHED = true;
                } elseif ($pattern_exclude == '-f' && ! $_is_dir) {
                    $MATCHED = true;
                }
            } else {
                $need_match = true;
                if ($modifier == '-f ' && $_is_dir) {
                    $need_match = false;
                } elseif ($modifier == '-d ' && ! $_is_dir) {
                    $need_match = false;
                }
                if ($need_match && preg_match($pattern_exclude . 'ims', $_path_clean)) {
                    $MATCHED = true;
                }
            }
        }
        return $MATCHED;
    }