Nip\Cache\Manager

Complexity

Total Complexity

25

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	8	2
A	valid()	0	11	4
A	isActive()	0	4	1
A	setActive()	0	6	1
A	exists()	0	4	1
A	filePath()	0	4	1
A	cachePath()	0	4	1
A	getData()	0	8	2
A	loadData()	0	17	3
A	reload()	0	3	1
A	set()	0	6	1
A	saveData()	0	7	1
B	save()	0	25	4
A	delete()	0	7	2

<?php

namespace Nip\Cache;

use Nip\Filesystem\Exception\IOException;
use Nip_File_System as FileSystem;

/**
 * Class Manager
 * @package Nip\Cache
 */
class Manager
{
    protected $active = false;

    protected $ttl = 180;

    protected $data;

    /**
     * @param $cacheId
     * @return mixed
     */
    public function get($cacheId)
    {
        if (!$this->valid($cacheId)) {
            return null;
        }

        return $this->getData($cacheId);
    }

    /**
     * @param $cacheId
     * @return bool
     */
    public function valid($cacheId)
    {
        if ($this->isActive() && $this->exists($cacheId)) {
            $fmtime = filemtime($this->filePath($cacheId));
            if (($fmtime + $this->ttl) > time()) {
                return true;
            }
        }

        return false;
    }

    /**
     * @return bool
     */
    public function isActive()
    {
        return $this->active;
    }

    /**
     * @param $active
     * @return $this
     */
    public function setActive($active)
    {
        $this->active = $active;

        return $this;
    }

    /**
     * @param $cacheId
     * @return bool
     */
    public function exists($cacheId)
    {
        return file_exists($this->filePath($cacheId));
    }

    /**
     * @param $cacheId
     * @return string
     */
    public function filePath($cacheId)
    {
        return $this->cachePath() . $cacheId . '.php';
    }

    /**
     * @return string
     */
    public function cachePath()
    {
        return app('path.storage') . DIRECTORY_SEPARATOR . 'cache';
    }

    /**
     * @param $cacheId
     * @return mixed
     */
    public function getData($cacheId)
    {
        if (!isset($this->data[$cacheId])) {
            $this->data[$cacheId] = $this->loadData($cacheId);
        }

        return $this->data[$cacheId];
    }

    /**
     * @param $cacheId
     * @param bool $retry
     * @return bool|mixed
     */
    public function loadData($cacheId, $retry = true)
    {
        $file = $this->filePath($cacheId);
        $content = file_get_contents($file);
        $data = unserialize($content);

        if (!$data) {
            if ($retry === false) {
                return false;
            }
            $this->reload($cacheId);

            return $this->loadData($cacheId, false);
        }

        return $data;
    }

    /**
     * @param $cacheId
     */
    public function reload($cacheId)
    {
    }

    /**
     * @param $cacheId
     * @param $data
     * @return $this
     */
    public function set($cacheId, $data)
    {
        $this->data[$cacheId] = $data;

        return $this;
    }

    /**
     * @param $cacheId
     * @param $data
     * @return bool
     */
    public function saveData($cacheId, $data)
    {
        $file = $this->filePath($cacheId);
        $content = serialize($data);

        return $this->save($file, $content);
    }

    /**
     * @param $file
     * @param $content
     * @return bool
     */
    public function save($file, $content)
    {
        $dir = dirname($file);
        $filesystem = FileSystem::instance();

        if (!is_dir($dir)) {
            $filesystem->createDirectory($dir, 0777);
        }

        if (file_put_contents($file, $content)) {
            try {
                $filesystem->chmod($file, 0777);
            } catch (IOException $e) {
                // discard chmod failure (some filesystem may not support it)
            }

            return true;
        } else {
            $message = "Cannot open cache file for writing: ";
//			if (!Nip_Staging::instance()->isPublic()) {

52% of this comment could be valid code. Did you maybe forget this after debugging?

//				$message .= " [ ".$this->cache_file." ] ";
//			}
            die($message);

The method save() contains an exit expression.

        }
    }

    /**
     * @param $cacheId
     */
    public function delete($cacheId)
    {
        $file = $this->filePath($cacheId);
        if (is_file($file)) {
            unlink($file);
        }
    }
}