As3\Modlr\Metadata\Cache\FileCache

Complexity

Total Complexity

13

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
A	loadMetadataFromCache()	0	8	2
A	readFile()	0	4	1
A	putMetadataInCache()	0	5	1
A	writeFile()	0	8	1
A	evictMetadataFromCache()	0	8	2
A	getCacheFile()	0	4	1
A	renameFile()	0	6	2

<?php

namespace As3\Modlr\Metadata\Cache;

use As3\Modlr\Metadata\EntityMetadata;
use As3\Modlr\Exception\RuntimeException;
use As3\Modlr\Exception\InvalidArgumentException;

/**
 * Caches and retrieves EntityMetadata objects from the file system.
 *
 * @author Jacob Bare <jacob.baregmail.com>
 */
class FileCache implements CacheInterface
{
    /**
     * The cache directory.
     *
     * @var string
     */
    protected $dir;

    /**
     * The cache type file prefix.
     *
     * @var string
     */
    protected $cachePrefix = 'FileCache';

    /**
     * The file extension.
     *
     * @var string
     */
    protected $extension = 'php';

    /**
     * Constructor.
     *
     * @param   string          $dir
     */
    public function __construct($dir)
    {
        if (!is_dir($dir)) {
            throw new InvalidArgumentException(sprintf('The cache directory "%s" does not exist.', $dir));
        }
        if (!is_writable($dir)) {
            throw new InvalidArgumentException(sprintf('The cache directory "%s" is not writable.', $dir));
        }
        $this->dir = rtrim($dir, '\\/');
    }

    /**
     * {@inheritDoc}
     */
    public function loadMetadataFromCache($type)
    {
        $file = $this->getCacheFile($type);
        if (!file_exists($file)) {
            return null;
        }
        return $this->readFile($file);
    }

    /**
     * Reads the cache file and returns as an EntityMetadata object.
     *
     * @param   string  $file
     * @return  EntityMetadata
     */
    protected function readFile($file)
    {
        return include $file;
    }

    /**
     * {@inheritDoc}
     */
    public function putMetadataInCache(EntityMetadata $metadata)
    {
        $this->writeFile($metadata, '<?php return unserialize('.var_export(serialize($metadata), true).');');
        return $this;
    }

    /**
     * Writes the cache file.
     *
     * @param   EntityMetadata  $metadata
     * @param   string          $contents
     */
    protected function writeFile(EntityMetadata $metadata, $contents)
    {
        $file = $this->getCacheFile($metadata->type);
        $tmpFile = tempnam($this->dir, 'metadata-cache');
        file_put_contents($tmpFile, $contents);
        chmod($tmpFile, 0666 & ~umask());
        $this->renameFile($tmpFile, $file);
    }

    /**
     * {@inheritDoc}
     */
    public function evictMetadataFromCache(EntityMetadata $metadata)
    {
        $file = $this->getCacheFile($metadata->type);
        if (file_exists($file)) {
            return unlink($file);
        }
        return false;
    }

    /**
     * Gets the cache file from the entity type.
     *
     * @param   string  $type
     * @return  string
     */
    private function getCacheFile($type)
    {
        return $this->dir.'/ModlrData.'.$this->cachePrefix.'.'.$type.'.'.$this->extension;
    }

    /**
     * Renames a file
     *
     * @param  string $source
     * @param  string $target
     * @throws \RuntimeException
     */
    private function renameFile($source, $target)
    {
        if (false === @rename($source, $target)) {
            throw new RuntimeException(sprintf('Could not write new cache file to %s.', $target));
        }
    }
}