HTMLPurifier_DefinitionCache_Serializer - Code Metrics - Inspection of "Merge pull request #575 from mambax7/feature/HTML_..." - XOOPS/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 398493...46f448 )

by Richard

created 2018-05-06 16:42 UTC

HTMLPurifier_DefinitionCache_Serializer B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	307
Duplicated Lines	16.94 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

Metric	Value
dl	52
loc	307
rs	7.0642
c	0
b	0
f	0
wmc	54
lcom	1
cbo	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	add()	14	14	4
A	set()	0	11	3
A	replace()	14	14	4
A	get()	0	8	2
A	remove()	0	8	2
B	flush()	0	25	6
C	cleanup()	0	26	7
A	generateFilePath()	0	5	1
A	generateDirectoryPath()	0	5	1
A	generateBaseDirectoryPath()	0	6	2
A	_write()	0	12	3
C	_prepareDir()	24	41	11
C	_testPermissions()	0	45	8

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like HTMLPurifier_DefinitionCache_Serializer often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use HTMLPurifier_DefinitionCache_Serializer, and based on these observations, apply Extract Interface, too.

<?php

class HTMLPurifier_DefinitionCache_Serializer extends HTMLPurifier_DefinitionCache
{

    /**
     * @param HTMLPurifier_Definition $def
     * @param HTMLPurifier_Config $config
     * @return int|bool
     */
    public function add($def, $config)
    {
        if (!$this->checkDefType($def)) {
            return null;
        }
        $file = $this->generateFilePath($config);
        if (file_exists($file)) {
            return false;
        }
        if (!$this->_prepareDir($config)) {
            return false;
        }
        return $this->_write($file, serialize($def), $config);
    }

    /**
     * @param HTMLPurifier_Definition $def
     * @param HTMLPurifier_Config $config
     * @return int|bool
     */
    public function set($def, $config)
    {
        if (!$this->checkDefType($def)) {
            return null;
        }
        $file = $this->generateFilePath($config);
        if (!$this->_prepareDir($config)) {
            return false;
        }
        return $this->_write($file, serialize($def), $config);
    }

    /**
     * @param HTMLPurifier_Definition $def
     * @param HTMLPurifier_Config $config
     * @return int|bool
     */
    public function replace($def, $config)
    {
        if (!$this->checkDefType($def)) {
            return;
        }
        $file = $this->generateFilePath($config);
        if (!file_exists($file)) {
            return false;
        }
        if (!$this->_prepareDir($config)) {
            return false;
        }
        return $this->_write($file, serialize($def), $config);
    }

    /**
     * @param HTMLPurifier_Config $config
     * @return bool|HTMLPurifier_Config
     */
    public function get($config)
    {
        $file = $this->generateFilePath($config);
        if (!file_exists($file)) {
            return false;
        }
        return unserialize(file_get_contents($file));
    }

    /**
     * @param HTMLPurifier_Config $config
     * @return bool
     */
    public function remove($config)
    {
        $file = $this->generateFilePath($config);
        if (!file_exists($file)) {
            return false;
        }
        return unlink($file);
    }

    /**
     * @param HTMLPurifier_Config $config
     * @return bool
     */
    public function flush($config)
    {
        if (!$this->_prepareDir($config)) {
            return false;
        }
        $dir = $this->generateDirectoryPath($config);
        $dh = opendir($dir);
        // Apparently, on some versions of PHP, readdir will return
        // an empty string if you pass an invalid argument to readdir.
        // So you need this test.  See #49.
        if (false === $dh) {
            return false;
        }
        while (false !== ($filename = readdir($dh))) {
            if (empty($filename)) {
                continue;
            }
            if ($filename[0] === '.') {
                continue;
            }
            unlink($dir . '/' . $filename);
        }
        closedir($dh);
        return true;
    }

    /**
     * @param HTMLPurifier_Config $config
     * @return bool
     */
    public function cleanup($config)
    {
        if (!$this->_prepareDir($config)) {
            return false;
        }
        $dir = $this->generateDirectoryPath($config);
        $dh = opendir($dir);
        // See #49 (and above).
        if (false === $dh) {
            return false;
        }
        while (false !== ($filename = readdir($dh))) {
            if (empty($filename)) {
                continue;
            }
            if ($filename[0] === '.') {
                continue;
            }
            $key = substr($filename, 0, strlen($filename) - 4);
            if ($this->isOld($key, $config)) {
                unlink($dir . '/' . $filename);
            }
        }
        closedir($dh);
        return true;
    }

    /**
     * Generates the file path to the serial file corresponding to
     * the configuration and definition name
     * @param HTMLPurifier_Config $config
     * @return string
     * @todo Make protected
     */
    public function generateFilePath($config)
    {
        $key = $this->generateKey($config);
        return $this->generateDirectoryPath($config) . '/' . $key . '.ser';
    }

    /**
     * Generates the path to the directory contain this cache's serial files
     * @param HTMLPurifier_Config $config
     * @return string
     * @note No trailing slash
     * @todo Make protected
     */
    public function generateDirectoryPath($config)
    {
        $base = $this->generateBaseDirectoryPath($config);
        return $base . '/' . $this->type;
    }

    /**
     * Generates path to base directory that contains all definition type
     * serials
     * @param HTMLPurifier_Config $config
     * @return mixed|string
     * @todo Make protected
     */
    public function generateBaseDirectoryPath($config)
    {
        $base = $config->get('Cache.SerializerPath');
        $base = is_null($base) ? HTMLPURIFIER_PREFIX . '/HTMLPurifier/DefinitionCache/Serializer' : $base;
        return $base;
    }

    /**
     * Convenience wrapper function for file_put_contents
     * @param string $file File name to write to
     * @param string $data Data to write into file
     * @param HTMLPurifier_Config $config
     * @return int|bool Number of bytes written if success, or false if failure.
     */
    private function _write($file, $data, $config)
    {
        $result = file_put_contents($file, $data);
        if ($result !== false) {
            // set permissions of the new file (no execute)
            $chmod = $config->get('Cache.SerializerPermissions');
            if ($chmod !== null) {
                chmod($file, $chmod & 0666);
        }
        }
        return $result;
    }

    /**
     * Prepares the directory that this type stores the serials in
     * @param HTMLPurifier_Config $config
     * @return bool True if successful
     */
    private function _prepareDir($config)
    {
        $directory = $this->generateDirectoryPath($config);
        $chmod = $config->get('Cache.SerializerPermissions');
        if ($chmod === null) {
            if (!@mkdir($directory) && !is_dir($directory)) {
                trigger_error(
                    'Could not create directory ' . $directory . '',
                    E_USER_WARNING
                );
                return false;
            }
            return true;
        }
        if (!is_dir($directory)) {
            $base = $this->generateBaseDirectoryPath($config);
            if (!is_dir($base)) {
                trigger_error(
                    'Base directory ' . $base . ' does not exist,
                    please create or change using %Cache.SerializerPath',
                    E_USER_WARNING
                );
                return false;
            } elseif (!$this->_testPermissions($base, $chmod)) {
                return false;
            }
            if (!@mkdir($directory, $chmod) && !is_dir($directory)) {
                trigger_error(
                    'Could not create directory ' . $directory . '',
                    E_USER_WARNING
                );
                return false;
            }
            if (!$this->_testPermissions($directory, $chmod)) {
                return false;
            }
        } elseif (!$this->_testPermissions($directory, $chmod)) {
            return false;
        }
        return true;
    }

    /**
     * Tests permissions on a directory and throws out friendly
     * error messages and attempts to chmod it itself if possible
     * @param string $dir Directory path
     * @param int $chmod Permissions
     * @return bool True if directory is writable
     */
    private function _testPermissions($dir, $chmod)
    {
        // early abort, if it is writable, everything is hunky-dory
        if (is_writable($dir)) {
            return true;
        }
        if (!is_dir($dir)) {
            // generally, you'll want to handle this beforehand
            // so a more specific error message can be given
            trigger_error(
                'Directory ' . $dir . ' does not exist',
                E_USER_WARNING
            );
            return false;
        }
        if (function_exists('posix_getuid') && $chmod !== null) {
            // POSIX system, we can give more specific advice
            if (fileowner($dir) === posix_getuid()) {
                // we can chmod it ourselves
                $chmod = $chmod | 0700;
                if (chmod($dir, $chmod)) {
                    return true;
                }
            } elseif (filegroup($dir) === posix_getgid()) {
                $chmod = $chmod | 0070;
            } else {
                // PHP's probably running as nobody, so we'll
                // need to give global permissions
                $chmod = $chmod | 0777;
            }
            trigger_error(
                'Directory ' . $dir . ' not writable, ' .
                'please chmod to ' . decoct($chmod),
                E_USER_WARNING
            );
        } else {
            // generic error message
            trigger_error(
                'Directory ' . $dir . ' not writable, ' .
                'please alter file permissions',
                E_USER_WARNING
            );
        }
        return false;
    }
}

// vim: et sw=4 sts=4


1		<?php
2
3		class HTMLPurifier_DefinitionCache_Serializer extends HTMLPurifier_DefinitionCache
4		{
5
6		/**
7		* @param HTMLPurifier_Definition $def
8		* @param HTMLPurifier_Config $config
9		* @return int\|bool
10		*/
11	View Code Duplication	public function add($def, $config)
12		{
13		if (!$this->checkDefType($def)) {
14		return null;
15		}
16		$file = $this->generateFilePath($config);
17		if (file_exists($file)) {
18		return false;
19		}
20		if (!$this->_prepareDir($config)) {
21		return false;
22		}
23		return $this->_write($file, serialize($def), $config);
24		}
25
26		/**
27		* @param HTMLPurifier_Definition $def
28		* @param HTMLPurifier_Config $config
29		* @return int\|bool
30		*/
31		public function set($def, $config)
32		{
33		if (!$this->checkDefType($def)) {
34		return null;
35		}
36		$file = $this->generateFilePath($config);
37		if (!$this->_prepareDir($config)) {
38		return false;
39		}
40		return $this->_write($file, serialize($def), $config);
41		}
42
43		/**
44		* @param HTMLPurifier_Definition $def
45		* @param HTMLPurifier_Config $config
46		* @return int\|bool
47		*/
48	View Code Duplication	public function replace($def, $config)
49		{
50		if (!$this->checkDefType($def)) {
51		return;
52		}
53		$file = $this->generateFilePath($config);
54		if (!file_exists($file)) {
55		return false;
56		}
57		if (!$this->_prepareDir($config)) {
58		return false;
59		}
60		return $this->_write($file, serialize($def), $config);
61		}
62
63		/**
64		* @param HTMLPurifier_Config $config
65		* @return bool\|HTMLPurifier_Config
66		*/
67		public function get($config)
68		{
69		$file = $this->generateFilePath($config);
70		if (!file_exists($file)) {
71		return false;
72		}
73		return unserialize(file_get_contents($file));
74		}
75
76		/**
77		* @param HTMLPurifier_Config $config
78		* @return bool
79		*/
80		public function remove($config)
81		{
82		$file = $this->generateFilePath($config);
83		if (!file_exists($file)) {
84		return false;
85		}
86		return unlink($file);
87		}
88
89		/**
90		* @param HTMLPurifier_Config $config
91		* @return bool
92		*/
93		public function flush($config)
94		{
95		if (!$this->_prepareDir($config)) {
96		return false;
97		}
98		$dir = $this->generateDirectoryPath($config);
99		$dh = opendir($dir);
100		// Apparently, on some versions of PHP, readdir will return
101		// an empty string if you pass an invalid argument to readdir.
102		// So you need this test. See #49.
103		if (false === $dh) {
104		return false;
105		}
106		while (false !== ($filename = readdir($dh))) {
107		if (empty($filename)) {
108		continue;
109		}
110		if ($filename[0] === '.') {
111		continue;
112		}
113		unlink($dir . '/' . $filename);
114		}
115		closedir($dh);
116		return true;
117		}
118
119		/**
120		* @param HTMLPurifier_Config $config
121		* @return bool
122		*/
123		public function cleanup($config)
124		{
125		if (!$this->_prepareDir($config)) {
126		return false;
127		}
128		$dir = $this->generateDirectoryPath($config);
129		$dh = opendir($dir);
130		// See #49 (and above).
131		if (false === $dh) {
132		return false;
133		}
134		while (false !== ($filename = readdir($dh))) {
135		if (empty($filename)) {
136		continue;
137		}
138		if ($filename[0] === '.') {
139		continue;
140		}
141		$key = substr($filename, 0, strlen($filename) - 4);
142		if ($this->isOld($key, $config)) {
143		unlink($dir . '/' . $filename);
144		}
145		}
146		closedir($dh);
147		return true;
148		}
149
150		/**
151		* Generates the file path to the serial file corresponding to
152		* the configuration and definition name
153		* @param HTMLPurifier_Config $config
154		* @return string
155		* @todo Make protected
156		*/
157		public function generateFilePath($config)
158		{
159		$key = $this->generateKey($config);
160		return $this->generateDirectoryPath($config) . '/' . $key . '.ser';
161		}
162
163		/**
164		* Generates the path to the directory contain this cache's serial files
165		* @param HTMLPurifier_Config $config
166		* @return string
167		* @note No trailing slash
168		* @todo Make protected
169		*/
170		public function generateDirectoryPath($config)
171		{
172		$base = $this->generateBaseDirectoryPath($config);
173		return $base . '/' . $this->type;
174		}
175
176		/**
177		* Generates path to base directory that contains all definition type
178		* serials
179		* @param HTMLPurifier_Config $config
180		* @return mixed\|string
181		* @todo Make protected
182		*/
183		public function generateBaseDirectoryPath($config)
184		{
185		$base = $config->get('Cache.SerializerPath');
186		$base = is_null($base) ? HTMLPURIFIER_PREFIX . '/HTMLPurifier/DefinitionCache/Serializer' : $base;
187		return $base;
188		}
189
190		/**
191		* Convenience wrapper function for file_put_contents
192		* @param string $file File name to write to
193		* @param string $data Data to write into file
194		* @param HTMLPurifier_Config $config
195		* @return int\|bool Number of bytes written if success, or false if failure.
196		*/
197		private function _write($file, $data, $config)
198		{
199		$result = file_put_contents($file, $data);
200		if ($result !== false) {
201		// set permissions of the new file (no execute)
202		$chmod = $config->get('Cache.SerializerPermissions');
203		if ($chmod !== null) {
204		chmod($file, $chmod & 0666);
205		}
206		}
207		return $result;
208		}
209
210		/**
211		* Prepares the directory that this type stores the serials in
212		* @param HTMLPurifier_Config $config
213		* @return bool True if successful
214		*/
215		private function _prepareDir($config)
216		{
217		$directory = $this->generateDirectoryPath($config);
218		$chmod = $config->get('Cache.SerializerPermissions');
219		if ($chmod === null) {
220	View Code Duplication	if (!@mkdir($directory) && !is_dir($directory)) {
221		trigger_error(
222		'Could not create directory ' . $directory . '',
223		E_USER_WARNING
224		);
225		return false;
226		}
227		return true;
228		}
229		if (!is_dir($directory)) {
230		$base = $this->generateBaseDirectoryPath($config);
231	View Code Duplication	if (!is_dir($base)) {
232		trigger_error(
233		'Base directory ' . $base . ' does not exist,
234		please create or change using %Cache.SerializerPath',
235		E_USER_WARNING
236		);
237		return false;
238		} elseif (!$this->_testPermissions($base, $chmod)) {
239		return false;
240		}
241	View Code Duplication	if (!@mkdir($directory, $chmod) && !is_dir($directory)) {
242		trigger_error(
243		'Could not create directory ' . $directory . '',
244		E_USER_WARNING
245		);
246		return false;
247		}
248		if (!$this->_testPermissions($directory, $chmod)) {
249		return false;
250		}
251		} elseif (!$this->_testPermissions($directory, $chmod)) {
252		return false;
253		}
254		return true;
255		}
256
257		/**
258		* Tests permissions on a directory and throws out friendly
259		* error messages and attempts to chmod it itself if possible
260		* @param string $dir Directory path
261		* @param int $chmod Permissions
262		* @return bool True if directory is writable
263		*/
264		private function _testPermissions($dir, $chmod)
265		{
266		// early abort, if it is writable, everything is hunky-dory
267		if (is_writable($dir)) {
268		return true;
269		}
270		if (!is_dir($dir)) {
271		// generally, you'll want to handle this beforehand
272		// so a more specific error message can be given
273		trigger_error(
274		'Directory ' . $dir . ' does not exist',
275		E_USER_WARNING
276		);
277		return false;
278		}
279		if (function_exists('posix_getuid') && $chmod !== null) {
280		// POSIX system, we can give more specific advice
281		if (fileowner($dir) === posix_getuid()) {
282		// we can chmod it ourselves
283		$chmod = $chmod \| 0700;
284		if (chmod($dir, $chmod)) {
285		return true;
286		}
287		} elseif (filegroup($dir) === posix_getgid()) {
288		$chmod = $chmod \| 0070;
289		} else {
290		// PHP's probably running as nobody, so we'll
291		// need to give global permissions
292		$chmod = $chmod \| 0777;
293		}
294		trigger_error(
295		'Directory ' . $dir . ' not writable, ' .
296		'please chmod to ' . decoct($chmod),
297		E_USER_WARNING
298		);
299		} else {
300		// generic error message
301		trigger_error(
302		'Directory ' . $dir . ' not writable, ' .
303		'please alter file permissions',
304		E_USER_WARNING
305		);
306		}
307		return false;
308		}
309		}
310
311		// vim: et sw=4 sts=4
312

XOOPS / XoopsCore25