1#@!#!123s

: / opt / psa / admin / plib / modules / catalog / vendor / tedivm / stash / src / Stash /
Filename : Utilities.php
back
<?php

/*
 * This file is part of the Stash package.
 *
 * (c) Robert Hafner <tedivm@tedivm.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PleskCatalog\Stash;

use PleskCatalog\Stash\Exception\RuntimeException;
use PleskCatalog\Stash\Exception\InvalidArgumentException;
use PleskCatalog\Stash\Interfaces\DriverInterface;
/**
 * StashUtilities contains static functions used throughout the Stash project, both by core classes and drivers.
 *
 * @package Stash
 * @author  Robert Hafner <tedivm@tedivm.com>
 */
class Utilities
{
    /**
     * Various drivers use this to define what kind of encoding to use on objects being cached. It needs to be revamped
     * a bit.
     */
    public static function encoding($data)
    {
        if (\is_scalar($data)) {
            if (\is_bool($data)) {
                return 'bool';
            }
            if (\is_string($data)) {
                return 'string';
            }
            if (\is_numeric($data)) {
                if (\is_numeric($data) && ($data >= 2147483648 || $data < -2147483648)) {
                    return 'serialize';
                } else {
                    return 'numeric';
                }
            }
        }
        return 'serialize';
    }
    /**
     * Uses the encoding function to define an encoding and uses it on the data. This system is going to be revamped.
     */
    public static function encode($data)
    {
        switch (self::encoding($data)) {
            case 'bool':
                return $data ? 'true' : 'false';
            case 'serialize':
                return \serialize($data);
            case 'string':
            case 'none':
            default:
        }
        return $data;
    }
    /**
     * Takes a piece of data encoded with the 'encode' function and returns it's actual value.
     *
     */
    public static function decode($data, $method)
    {
        switch ($method) {
            case 'bool':
                // note that true is a string, so this
                return $data == 'true' ? \true : \false;
            case 'serialize':
                return \unserialize($data);
            case 'string':
            case 'none':
            default:
        }
        return $data;
    }
    /**
     * Returns the default base directory for the system when one isn't provided by the developer. This is a directory
     * of last resort and can cause problems if one library is shared by multiple projects. The directory returned
     * resides in the system's temp folder and is specific to each Stash installation and driver.
     *
     * @param  DriverInterface $driver
     * @return string          Path for Stash files
     */
    public static function getBaseDirectory(?DriverInterface $driver = null)
    {
        $tmp = \rtrim(\sys_get_temp_dir(), '/\\') . '/';
        $baseDir = $tmp . 'stash/' . \md5(__DIR__) . '/';
        if (isset($driver)) {
            $baseDir .= \str_replace(array('/', '\\'), '_', \get_class($driver)) . '/';
        }
        if (!\is_dir($baseDir)) {
            \mkdir($baseDir, 0770, \true);
        }
        return $baseDir;
    }
    /**
     * Deletes a directory and all of its contents.
     *
     * @param  string $file Path to file or directory.
     * @param  bool $cleanParent Whether to prune empty parent directories or not.
     * @throws Exception\RuntimeException
     * @return bool                       Returns true on success, false otherwise.
     */
    public static function deleteRecursive($file, $cleanParent = \false)
    {
        if (!\preg_match('/^(?:\\/|\\\\|\\w:\\\\|\\w:\\/).*$/', $file)) {
            throw new RuntimeException('deleteRecursive function requires an absolute path.');
        }
        $badCalls = array('/', '/*', '/.', '/..');
        if (\in_array($file, $badCalls)) {
            throw new RuntimeException('deleteRecursive function does not like that call.');
        }
        $filePath = \rtrim($file, ' /');
        if (\is_dir($filePath)) {
            $currentPerms = \fileperms($filePath);
            $currentOwner = \fileowner($filePath);
            $parentPath = \dirname($filePath);
            $directoryIt = new \RecursiveDirectoryIterator($filePath);
            foreach (new \RecursiveIteratorIterator($directoryIt, \RecursiveIteratorIterator::CHILD_FIRST) as $file) {
                $filename = $file->getPathname();
                // Clear out children if this is a directory.
                if ($file->isDir()) {
                    $dirFiles = \scandir($file->getPathname());
                    if ($dirFiles && \count($dirFiles) == 2) {
                        $filename = \rtrim($filename, '/.');
                        if (\file_exists($filename)) {
                            \rmdir($filename);
                        }
                    }
                    unset($dirFiles);
                    continue;
                }
                if (\file_exists($filename)) {
                    \unlink($filename);
                }
            }
            unset($directoryIt);
            if (\is_dir($filePath)) {
                \rmdir($filePath);
            }
            if ($cleanParent && static::checkForEmptyDirectory($parentPath)) {
                $parentPerms = \fileperms($parentPath);
                $parentOwner = \fileowner($parentPath);
                if ($currentPerms == $parentPerms && $currentOwner == $parentOwner) {
                    $grandParentPath = \dirname($parentPath);
                    if ($parentOwner = \fileowner($grandParentPath)) {
                        if (\is_writable($grandParentPath) && $parentPerms == \fileperms($grandParentPath)) {
                            \rmdir($parentPath);
                        }
                    }
                }
            }
            return \true;
        } elseif (\is_file($filePath)) {
            return \unlink($file);
        }
        return \false;
    }
    public static function normalizeKeys($keys, $hash = 'md5')
    {
        $pKey = array();
        foreach ($keys as $keyPiece) {
            $prefix = \substr($keyPiece, 0, 1) == '@' ? '@' : '';
            $pKeyPiece = $prefix . $hash($keyPiece);
            $pKey[] = $pKeyPiece;
        }
        return $pKey;
    }
    /**
     * Checks to see whether the requisite permissions are available on the specified path.
     *
     * @throws Exception\RuntimeException
     * @throws Exception\InvalidArgumentException
     */
    public static function checkFileSystemPermissions($path, int $permissions)
    {
        if (!isset($path)) {
            throw new RuntimeException('Cache path was not set correctly.');
        }
        if (\file_exists($path) && !\is_dir($path)) {
            throw new InvalidArgumentException('Cache path is not a directory.');
        }
        if (!\is_dir($path) && !@\mkdir($path, $permissions, \true)) {
            throw new InvalidArgumentException('Failed to create cache path.');
        }
        if (!\is_writable($path)) {
            throw new InvalidArgumentException('Cache path is not writable.');
        }
    }
    /**
     * Checks to see if a directory is empty.
     *
     * @param  string $path
     * @return bool
     */
    public static function checkForEmptyDirectory($path)
    {
        $empty = \true;
        $dir = \opendir($path);
        while ($file = \readdir($dir)) {
            if ($file != '.' && $file != '..') {
                $empty = \false;
                break;
            }
        }
        \closedir($dir);
        return $empty;
    }
}