From e8442a3bf87e595a3f50dc932e71dedd0831655e Mon Sep 17 00:00:00 2001 From: logmanoriginal Date: Wed, 14 Nov 2018 19:07:53 +0100 Subject: [PATCH] [Cache] Refactor class general - Use self:: instead of Cache:: or static:: - Rename $dirCache to $workingDir - Initialize $workingDir with null function setDir - Clear previous working directory before checking input parameters - Change wording for the exception messages - Store realpath instead of raw parameter - Add path separator This ensures the path always ends with the path separator, as assumed by Cache::create - Add check if the provided working directory is a valid directory function getDir - Use static parameter instead of function variable - Change wording for the exception message function create - Rename parameter $nameCache to $name - Rename $pathCache to $filePath - Change wording for the exception messages function isValidNameCache - Rename function to isCacheName - Rename parameter $nameCache to $name - Explain in the function documentation the meaning of a 'valid name' - Ensure Boolean return value (preg_match returns integer) - Check if $name is a string - Use slashes to enclose the regex --- lib/Cache.php | 89 +++++++++++++++++++++++++++------------------------ 1 file changed, 48 insertions(+), 41 deletions(-) diff --git a/lib/Cache.php b/lib/Cache.php index 3e3f5351..a70c991c 100644 --- a/lib/Cache.php +++ b/lib/Cache.php @@ -17,7 +17,7 @@ * directory. * * This class is capable of: - * - Locating cache classes in the specified working directory (see {@see Cache::$dirCache}) + * - Locating cache classes in the specified working directory (see {@see Cache::$workingDir}) * - Creating new cache instances based on the cache's name (see {@see Cache::create()}) * * The following example illustrates the intended use for this class. @@ -35,96 +35,103 @@ class Cache { /** - * Holds the working directory. + * Holds a path to the working directory. * * Do not access this property directly! * Use {@see Cache::setDir()} and {@see Cache::getDir()} instead. * - * @var string + * @var string|null */ - static protected $dirCache; + static protected $workingDir = null; /** * Throws an exception when trying to create a new instance of this class. - * Use {@see Cache::create()} to instanciate a new cache from the working + * Use {@see Cache::create()} to create a new cache object from the working * directory. * - * @throws LogicException if called. + * @throws \LogicException if called. */ public function __construct(){ - throw new \LogicException('Please use ' . __CLASS__ . '::create for new object.'); + throw new \LogicException('Use ' . __CLASS__ . '::create($name) to create cache objects!'); } /** * Creates a new cache object from the working directory. * - * @throws InvalidArgumentException if the provided name is invalid. - * @throws Exception if no cache with the given name exist in the working - * directory. - * @param string $nameCache Name of the cache object. - * @return object Instance of the cache. + * @throws \InvalidArgumentException if the requested cache name is invalid. + * @throws \Exception if the requested cache file doesn't exist in the + * working directory. + * @param string $name Name of the cache object. + * @return object The cache object. */ - public static function create($nameCache){ - if(!static::isValidNameCache($nameCache)) { - throw new \InvalidArgumentException('Name cache must be at least one - uppercase follow or not by alphanumeric or dash characters.'); + public static function create($name){ + if(!self::isCacheName($name)) { + throw new \InvalidArgumentException('Cache name invalid!'); } - $pathCache = self::getDir() . $nameCache . '.php'; + $filePath = self::getDir() . $name . '.php'; - if(!file_exists($pathCache)) { - throw new \Exception('The cache you are looking for does not exist.'); + if(!file_exists($filePath)) { + throw new \Exception('Cache file ' . $filePath . ' does not exist!'); } - require_once $pathCache; + require_once $filePath; - return new $nameCache(); + return new $name(); } /** * Sets the working directory. * - * @param string $dirCache Path to a directory containing cache classes - * @throws InvalidArgumentException if the provided path is not a valid string. - * @throws Exception if the provided path does not exist. + * @param string $workingDir Path to a directory containing cache classes + * @throws \InvalidArgumentException if $workingDir is not a string. + * @throws \Exception if the working directory doesn't exist. + * @throws \InvalidArgumentException if $workingDir is not a directory. * @return void */ - public static function setDir($dirCache){ - if(!is_string($dirCache)) { - throw new \InvalidArgumentException('Dir cache must be a string.'); + public static function setDir($workingDir){ + self::$workingDir = null; + + if(!is_string($workingDir)) { + throw new \InvalidArgumentException('Working directory is not a valid string!'); } - if(!file_exists($dirCache)) { - throw new \Exception('Dir cache does not exist.'); + if(!file_exists($workingDir)) { + throw new \Exception('Working directory does not exist!'); } - self::$dirCache = $dirCache; + if(!is_dir($workingDir)) { + throw new \InvalidArgumentException('Working directory is not a directory!'); + } + + self::$workingDir = realpath($workingDir) . '/'; } /** * Returns the current working directory. - * The working directory must be specified with {@see Cache::setDir()}! + * The working directory must be set with {@see Cache::setDir()}! * - * @throws LogicException if the working directory was not specified. + * @throws \LogicException if the working directory is not set. * @return string The current working directory. */ public static function getDir(){ - $dirCache = self::$dirCache; - - if(is_null($dirCache)) { - throw new \LogicException(__CLASS__ . ' class need to know cache path !'); + if(is_null(self::$workingDir)) { + throw new \LogicException('Working directory is not set!'); } - return $dirCache; + return self::$workingDir; } /** * Returns true if the provided name is a valid cache name. * - * @param string $nameCache The cache name. - * @return int 1 if the name is valid, 0 if not, false if an error occurred. + * A valid cache name starts with a capital letter ([A-Z]), followed by + * zero or more alphanumeric characters or hyphen ([A-Za-z0-9-]). + * + * @param string $name The cache name. + * @return bool true if the name is a valid cache name, false otherwise. */ - public static function isValidNameCache($nameCache){ - return preg_match('@^[A-Z][a-zA-Z0-9-]*$@', $nameCache); + public static function isCacheName($name){ + return is_string($name) && preg_match('/^[A-Z][a-zA-Z0-9-]*$/', $name) === 1; } }