FileStore::set() - Code Metrics - Inspection of "Separate composer autoload-dev for Test" - ankitpokhrel/tus-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#59)

by Jitendra

created 2018-06-24 14:11 UTC

FileStore::set() A

↳ Parent: FileStore

Complexity

Conditions	5
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	5

Importance

Changes

Metric	Value
cc	5
nc	4
nop	2
dl	0
loc	18
ccs	10
cts	10
cp	1
crap	5
rs	9.3554
c	0
b	0
f	0

<?php

namespace TusPhp\Cache;

use Carbon\Carbon;

class FileStore extends AbstractCache
{
    /** @const string */
    const DEFAULT_CACHE_FILE = 'tus_php.cache';

    /** @var string */
    protected $cacheDir;

    /** @var string */
    protected $cacheFile;

    /**
     * FileStore constructor.
     *
     * @param string|null $cacheDir
     * @param string      $cacheFile
     */
    public function __construct(string $cacheDir = null, string $cacheFile = self::DEFAULT_CACHE_FILE)
    {
        $cacheDir = $cacheDir ?? dirname(__DIR__, 2) . DIRECTORY_SEPARATOR . '.cache' . DIRECTORY_SEPARATOR;

        $this->setCacheDir($cacheDir);
        $this->setCacheFile($cacheFile);
    }

    /**
     * Set cache dir.
     *
     * @param string $path
     *
     * @return self
     */
    public function setCacheDir(string $path) : self
    {
        $this->cacheDir = $path;

        return $this;
    }

    /**
     * Get cache dir.
     *
     * @return string
     */
    public function getCacheDir() : string
    {
        return $this->cacheDir;
    }

    /**
     * Set cache file.
     *
     * @param string $file
     *
     * @return self
     */
    public function setCacheFile(string $file) : self
    {
        $this->cacheFile = $file;

        return $this;
    }

    /**
     * Get cache file.
     *
     * @return string
     */
    public function getCacheFile() : string
    {
        return $this->cacheDir . $this->cacheFile;
    }

    /**
     * Create cache dir if not exists.
     *
     * @return void
     */
    protected function createCacheDir()
    {
        if ( ! file_exists($this->cacheDir)) {
            mkdir($this->cacheDir);
        }
    }

    /**
     * Create cache file and add required meta.
     *
     * @return void
     */
    protected function createCacheFile()
    {
        $this->createCacheDir();

        $cacheFilePath = $this->getCacheFile();

        if ( ! file_exists($cacheFilePath)) {
            touch($cacheFilePath);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function get(string $key, bool $withExpired = false)
    {
        $key      = $this->getActualCacheKey($key);
        $contents = $this->getCacheContents();

        if (empty($contents[$key])) {
            return null;
        }

        if ($withExpired) {
            return $contents[$key];
        }

        return $this->isValid($key) ? $contents[$key] : null;
    }

    /**
     * {@inheritDoc}
     */
    public function set(string $key, $value)
    {
        $key       = $this->getActualCacheKey($key);
        $cacheFile = $this->getCacheFile();

        if ( ! file_exists($cacheFile) || ! $this->isValid($key)) {
            $this->createCacheFile();
        }

        $contents = json_decode(file_get_contents($cacheFile), true) ?? [];

        if ( ! empty($contents[$key]) && is_array($value)) {
            $contents[$key] = $value + $contents[$key];
        } else {
            $contents[$key] = $value;
        }

        return file_put_contents($cacheFile, json_encode($contents));
    }

    /**
     * {@inheritDoc}
     */
    public function delete(string $key) : bool
    {
        $key      = $this->getActualCacheKey($key);
        $contents = $this->getCacheContents();

        if (isset($contents[$key])) {
            unset($contents[$key]);

            return false !== file_put_contents($this->getCacheFile(), json_encode($contents));
        }

        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function keys() : array
    {
        $contents = $this->getCacheContents();

        if (is_array($contents)) {
            return array_keys($this->getCacheContents());
        }

        return [];
    }

    /**
     * Check if cache is still valid.
     *
     * @param string $key
     *
     * @return bool
     */
    public function isValid(string $key) : bool
    {
        $key  = $this->getActualCacheKey($key);
        $meta = $this->getCacheContents()[$key] ?? [];

        if (empty($meta['expires_at'])) {
            return false;
        }

        return Carbon::now() < Carbon::createFromFormat(self::RFC_7231, $meta['expires_at']);
    }

    /**
     * Get cache contents.
     *
     * @return array|bool
     */
    public function getCacheContents()
    {
        $cacheFile = $this->getCacheFile();

        if ( ! file_exists($cacheFile)) {
            return false;
        }

        return json_decode(file_get_contents($cacheFile), true) ?? [];
    }

    /**
     * Get actual cache key with prefix.
     *
     * @param string $key
     *
     * @return string
     */
    public function getActualCacheKey(string $key) : string
    {
        $prefix = $this->getPrefix();

        if (false === strpos($key, $prefix)) {
            $key = $prefix . $key;
        }

        return $key;
    }
}


1		<?php
2
3		namespace TusPhp\Cache;
4
5		use Carbon\Carbon;
6
7		class FileStore extends AbstractCache
8		{
9		/** @const string */
10		const DEFAULT_CACHE_FILE = 'tus_php.cache';
11
12		/** @var string */
13		protected $cacheDir;
14
15		/** @var string */
16		protected $cacheFile;
17
18		/**
19		* FileStore constructor.
20		*
21		* @param string\|null $cacheDir
22		* @param string $cacheFile
23		*/
24	2	public function __construct(string $cacheDir = null, string $cacheFile = self::DEFAULT_CACHE_FILE)
25		{
26	2	$cacheDir = $cacheDir ?? dirname(__DIR__, 2) . DIRECTORY_SEPARATOR . '.cache' . DIRECTORY_SEPARATOR;
27
28	2	$this->setCacheDir($cacheDir);
29	2	$this->setCacheFile($cacheFile);
30	2	}
31
32		/**
33		* Set cache dir.
34		*
35		* @param string $path
36		*
37		* @return self
38		*/
39	1	public function setCacheDir(string $path) : self
40		{
41	1	$this->cacheDir = $path;
42
43	1	return $this;
44		}
45
46		/**
47		* Get cache dir.
48		*
49		* @return string
50		*/
51	1	public function getCacheDir() : string
52		{
53	1	return $this->cacheDir;
54		}
55
56		/**
57		* Set cache file.
58		*
59		* @param string $file
60		*
61		* @return self
62		*/
63	1	public function setCacheFile(string $file) : self
64		{
65	1	$this->cacheFile = $file;
66
67	1	return $this;
68		}
69
70		/**
71		* Get cache file.
72		*
73		* @return string
74		*/
75	5	public function getCacheFile() : string
76		{
77	5	return $this->cacheDir . $this->cacheFile;
78		}
79
80		/**
81		* Create cache dir if not exists.
82		*
83		* @return void
84		*/
85	2	protected function createCacheDir()
86		{
87	2	if ( ! file_exists($this->cacheDir)) {
88	2	mkdir($this->cacheDir);
89		}
90	2	}
91
92		/**
93		* Create cache file and add required meta.
94		*
95		* @return void
96		*/
97	2	protected function createCacheFile()
98		{
99	2	$this->createCacheDir();
100
101	2	$cacheFilePath = $this->getCacheFile();
102
103	2	if ( ! file_exists($cacheFilePath)) {
104	2	touch($cacheFilePath);
105		}
106	2	}
107
108		/**
109		* {@inheritDoc}
110		*/
111	8	public function get(string $key, bool $withExpired = false)
112		{
113	8	$key = $this->getActualCacheKey($key);
114	8	$contents = $this->getCacheContents();
115
116	8	if (empty($contents[$key])) {
117	3	return null;
118		}
119
120	5	if ($withExpired) {
121	1	return $contents[$key];
122		}
123
124	5	return $this->isValid($key) ? $contents[$key] : null;
125		}
126
127		/**
128		* {@inheritDoc}
129		*/
130	8	public function set(string $key, $value)
131		{
132	8	$key = $this->getActualCacheKey($key);
133	8	$cacheFile = $this->getCacheFile();
134
135	8	if ( ! file_exists($cacheFile) \|\| ! $this->isValid($key)) {
136	8	$this->createCacheFile();
137		}
138
139	8	$contents = json_decode(file_get_contents($cacheFile), true) ?? [];
140
141	8	if ( ! empty($contents[$key]) && is_array($value)) {
142	3	$contents[$key] = $value + $contents[$key];
143		} else {
144	8	$contents[$key] = $value;
145		}
146
147	8	return file_put_contents($cacheFile, json_encode($contents));
148		}
149
150		/**
151		* {@inheritDoc}
152		*/
153	1	public function delete(string $key) : bool
154		{
155	1	$key = $this->getActualCacheKey($key);
156	1	$contents = $this->getCacheContents();
157
158	1	if (isset($contents[$key])) {
159	1	unset($contents[$key]);
160
161	1	return false !== file_put_contents($this->getCacheFile(), json_encode($contents));
162		}
163
164	1	return false;
165		}
166
167		/**
168		* {@inheritDoc}
169		*/
170	2	public function keys() : array
171		{
172	2	$contents = $this->getCacheContents();
173
174	2	if (is_array($contents)) {
175	1	return array_keys($this->getCacheContents());
176		}
177
178	1	return [];
179		}
180
181		/**
182		* Check if cache is still valid.
183		*
184		* @param string $key
185		*
186		* @return bool
187		*/
188	3	public function isValid(string $key) : bool
189		{
190	3	$key = $this->getActualCacheKey($key);
191	3	$meta = $this->getCacheContents()[$key] ?? [];
192
193	3	if (empty($meta['expires_at'])) {
194	1	return false;
195		}
196
197	2	return Carbon::now() < Carbon::createFromFormat(self::RFC_7231, $meta['expires_at']);
198		}
199
200		/**
201		* Get cache contents.
202		*
203		* @return array\|bool
204		*/
205	3	public function getCacheContents()
206		{
207	3	$cacheFile = $this->getCacheFile();
208
209	3	if ( ! file_exists($cacheFile)) {
210	1	return false;
211		}
212
213	2	return json_decode(file_get_contents($cacheFile), true) ?? [];
214		}
215
216		/**
217		* Get actual cache key with prefix.
218		*
219		* @param string $key
220		*
221		* @return string
222		*/
223	1	public function getActualCacheKey(string $key) : string
224		{
225	1	$prefix = $this->getPrefix();
226
227	1	if (false === strpos($key, $prefix)) {
228	1	$key = $prefix . $key;
229		}
230
231	1	return $key;
232		}
233		}
234

ankitpokhrel / tus-php

Pull Request — master (#59)

FileStore::set() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like