Sanitize - Code Metrics - webino/WebinoI18nSanitizeLib - Measure and Improve Code Quality continuously with Scrutinizer

Sanitize B
last analyzed 2017-12-01 13:12 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	366
Duplicated Lines	24.04 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	47
lcom	1
cbo	4
dl	88
loc	366
rs	8.439
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	filter()	0	18	1
A	getTransliteration()	0	7	2
A	setTransliteration()	0	5	1
A	getStringTrim()	0	7	2
A	setStringTrim()	0	5	1
A	getStringToLower()	0	8	2
A	setStringToLower()	0	5	1
A	addNotReplacedChars()	18	18	4
A	getNotReplacedChars()	0	4	1
C	removeNotReplacedChar()	26	26	7
A	getDelimiterReplacement()	0	4	1
A	setDelimiterReplacement()	0	5	1
A	getWordDelimiters()	0	4	1
A	addWordDelimiter()	18	18	4
C	removeWordDelimiter()	26	26	7
A	replaceDelimiters()	0	17	4
A	trimSpecialsChars()	0	9	2
A	replaceDoubleDelimiterReplacementWithSingle()	0	8	2
A	trimStartAndEndSpaceReplacement()	0	4	1

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 Sanitize 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 Sanitize, and based on these observations, apply Extract Interface, too.

<?php
/**
 * Webino (http://webino.sk)
 *
 * @link        https://github.com/webino/WebinoI18nSanitizeLib for the canonical source repository
 * @copyright   Copyright (c) 2017 Webino, s. r. o. (http://webino.sk)
 * @author      Peter Bačinský <[email protected]>
 * @license     BSD-3-Clause
 */

namespace WebinoI18nSanitizeLib;

use Zend\Filter;
use Zend\Filter\Exception;

/**
 * Class Sanitize
 *
 * @author Martin Hujer [email protected]
 */
class Sanitize implements Filter\FilterInterface
{
    /**
     * Character(s) used to replace delimiters
     *
     * @var string
     */
    protected $delimiterReplacement;

    /**
     * Word delimiters which are replaced by spaceReplacement string
     *
     * @var array
     */
    protected $wordDelimiters = [' ', '.', '\\', '/', '-', '_'];

    /**
     * Which characters are not replaced
     *
     * @var array
     */
    protected $notReplacedChars = [];

    /**
     * @var Transliteration
     */
    protected $transliteration;

    /**
     * @var Filter\StringTrim
     */
    protected $stringTrim;

    /**
     * @var Filter\StringToLower
     */
    protected $stringToLower;

    /**
     *
     * @param string $delimiterReplacement
     * @param string|array $wordDelimiters
     */
    public function __construct($delimiterReplacement = '-', $wordDelimiters = null)
    {
        $this->setDelimiterReplacement($delimiterReplacement);
        if (null !== $wordDelimiters) {
            $this->addWordDelimiter($wordDelimiters);
        }
    }

    /**
     * Returns $value filtered to valid URL
     *
     * @param string $s
     * @return string
     */
    public function filter($s)
    {
        // convert to ascii -> translate strange chars
        $s = $this->getTransliteration()->filter($s);
        // trim spaces
        $s = $this->getStringTrim()->filter($s);
        // replace delimiters with another character
        $s = $this->replaceDelimiters($s);
        // lower chars
        $s = $this->getStringToLower()->filter($s);
        // delete chars except a-z0-9
        $s = $this->trimSpecialsChars($s);
        // replace double dashes with single one
        $s = $this->replaceDoubleDelimiterReplacementWithSingle($s);
        // trim dashes on beginning/end of the string
        $s = $this->trimStartAndEndSpaceReplacement($s);
        return $s;
    }

    /**
     * @return Transliteration
     */
    public function getTransliteration()
    {
        if (null === $this->transliteration) {
            $this->transliteration = new Transliteration;
        }
        return $this->transliteration;
    }

    /**
     * @param Transliteration $transliteration
     * @return $this
     */
    public function setTransliteration(Transliteration $transliteration)
    {
        $this->transliteration = $transliteration;
        return $this;
    }

    /**
     * @return Filter\StringTrim
     */
    public function getStringTrim()
    {
        if (null === $this->stringTrim) {
            $this->stringTrim = new Filter\StringTrim;
        }
        return $this->stringTrim;
    }

    /**
     * @param Filter\StringTrim $stringTrim
     * @return $this
     */
    public function setStringTrim(Filter\StringTrim $stringTrim)
    {
        $this->stringTrim = $stringTrim;
        return $this;
    }

    /**
     * @return Filter\StringToLower
     */
    public function getStringToLower()
    {
        if (null === $this->stringToLower) {
            $this->stringToLower = new Filter\StringToLower;
            $this->stringToLower->setEncoding('utf-8');
        }
        return $this->stringToLower;
    }

    /**
     * @param Filter\StringToLower $stringToLower
     * @return $this
     */
    public function setStringToLower(Filter\StringToLower $stringToLower)
    {
        $this->stringToLower = $stringToLower;
        return $this;
    }

    /**
     * @param string|array $notReplaced
     * @return $this
     * @throws Exception\RuntimeException
     */
    public function addNotReplacedChars($notReplaced)

    {
        if (in_array($notReplaced, $this->getNotReplacedChars())) {
            throw new Exception\RuntimeException("Not replaced characterr '$notReplaced' is already there.");
        }

        if (empty($notReplaced)) {
            throw new Exception\RuntimeException('Not replaced character cannot be null.');
        }

        if (is_array($notReplaced)) {
            $this->notReplacedChars = array_merge($this->getNotReplacedChars(), $notReplaced);
        } else {
            $this->notReplacedChars[] = $notReplaced;
        }

        return $this;
    }

    /**
     * Returns chars which are not replaced
     *
     * @return array
     */
    public function getNotReplacedChars()
    {
        return $this->notReplacedChars;
    }

    /**
     * Remove not replaced character
     *
     * @param string|array $notReplaced
     * @return $this
     * @throws Exception\RuntimeException
     */
    public function removeNotReplacedChar($notReplaced)

    {
        if (empty($notReplaced)) {
            throw new Exception\RuntimeException('Not replaced character cannot be null.');
        }

        if (is_array($notReplaced)) {
            foreach ($notReplaced as $n) {
                $this->removeNotReplacedChar($n);
            }
        } else {
            if (!in_array($notReplaced, $this->getNotReplacedChars())) {
                throw new Exception\RuntimeException("Not replaced character '$notReplaced' is not in array.");
            }

            $notReplacedChars = [];
            foreach ($this->notReplacedChars as $n) {
                if ($n != $notReplaced) {
                    $notReplacedChars[] = $n;
                }
                $this->notReplacedChars = $notReplacedChars;
            }
        }

        return $this;
    }

    /**
     * Returns the delimiterReplacement option
     *
     * @return string
     */
    public function getDelimiterReplacement()
    {
        return $this->delimiterReplacement;
    }

    /**
     * Sets the delimiterReplacement option
     *
     * @param string $delimiterReplacement
     * @return $this
     */
    public function setDelimiterReplacement($delimiterReplacement)
    {
        $this->delimiterReplacement = $delimiterReplacement;
        return $this;
    }

    /**
     * Returns word delimiters array
     *
     * @return array
     */
    public function getWordDelimiters()
    {
        return $this->wordDelimiters;
    }

    /**
     * Add word delimiter
     *
     * @param string|array $delimiter
     * @return $this
     * @throws Exception\RuntimeException
     */
    public function addWordDelimiter($delimiter)

    {
        if (in_array($delimiter, $this->getWordDelimiters())) {
            throw new Exception\RuntimeException("Word delimiter '$delimiter' is already there.");
        }

        if (empty($delimiter)) {
            throw new Exception\RuntimeException('Word delimiter cannot be null.');
        }

        if (is_array($delimiter)) {
            $this->wordDelimiters = array_merge($this->getWordDelimiters(), $delimiter);
        } else {
            $this->wordDelimiters[] = $delimiter;
        }

        return $this;
    }

    /**
     * Remove word delimiter
     *
     * @param string|array $delimiters
     * @return $this
     * @throws Exception\RuntimeException
     */
    public function removeWordDelimiter($delimiters)

    {
        if (empty($delimiters)) {
            throw new Exception\RuntimeException('Word delimiter cannot be null.');
        }

        if (is_array($delimiters)) {
            foreach ($delimiters as $delimiter) {
                $this->removeWordDelimiter($delimiter);
            }
        } else {
            if (!in_array($delimiters, $this->getWordDelimiters())) {
                throw new Exception\RuntimeException("Word delimiter '$delimiters' is not in delimiters array.");
            }

            $wordDelimiters = [];
            foreach ($this->wordDelimiters as $delimiter) {
                if ($delimiter != $delimiters) {
                    $wordDelimiters[] = $delimiter;
                }
                $this->wordDelimiters = $wordDelimiters;
            }
        }

        return $this;
    }

    /**
     * Replace delimiters with another string
     *
     * @param string $s
     * @return string
     */
    private function replaceDelimiters($s)
    {
        foreach ($this->getWordDelimiters() as $delimiter) {

            if ($delimiter == $this->getDelimiterReplacement()) {
                continue;
            }

            if (in_array($delimiter, $this->getNotReplacedChars())) {
                continue;
            }

            $s = str_replace($delimiter, $this->getDelimiterReplacement(), $s);
        }

        return $s;
    }

    /**
     * To special chars
     *
     * @param string $s
     * @return string
     */
    private function trimSpecialsChars($s)
    {
        if (count($this->getNotReplacedChars()) == 0) {
            $reg = '~[^-a-z0-9_]+~';
        } else {
            $reg = '~[^-a-z0-9_' . implode('', $this->getNotReplacedChars()) . ']+~';
        }
        return preg_replace($reg, '', $s);
    }

    /**
     * Replace double delimiter with single one
     *
     * @param string $s
     * @return string
     */
    private function replaceDoubleDelimiterReplacementWithSingle($s)
    {
        $doubleDelimiterReplacement = $this->getDelimiterReplacement() . $this->getDelimiterReplacement();
        while (strpos($s, $doubleDelimiterReplacement) !== false) {
            $s = str_replace($doubleDelimiterReplacement, $this->getDelimiterReplacement(), $s);
        }
        return $s;
    }

    /**
     * Trim dashes on beginning/end of the string
     *
     * @param string $s
     * @return string
     */
    private function trimStartAndEndSpaceReplacement($s)
    {
        return trim($s, $this->getDelimiterReplacement());
    }
}


1		<?php
2		/**
3		* Webino (http://webino.sk)
4		*
5		* @link https://github.com/webino/WebinoI18nSanitizeLib for the canonical source repository
6		* @copyright Copyright (c) 2017 Webino, s. r. o. (http://webino.sk)
7		* @author Peter Bačinský <[email protected]>
8		* @license BSD-3-Clause
9		*/
10
11		namespace WebinoI18nSanitizeLib;
12
13		use Zend\Filter;
14		use Zend\Filter\Exception;
15
16		/**
17		* Class Sanitize
18		*
19		* @author Martin Hujer [email protected]
20		*/
21		class Sanitize implements Filter\FilterInterface
22		{
23		/**
24		* Character(s) used to replace delimiters
25		*
26		* @var string
27		*/
28		protected $delimiterReplacement;
29
30		/**
31		* Word delimiters which are replaced by spaceReplacement string
32		*
33		* @var array
34		*/
35		protected $wordDelimiters = [' ', '.', '\\', '/', '-', '_'];
36
37		/**
38		* Which characters are not replaced
39		*
40		* @var array
41		*/
42		protected $notReplacedChars = [];
43
44		/**
45		* @var Transliteration
46		*/
47		protected $transliteration;
48
49		/**
50		* @var Filter\StringTrim
51		*/
52		protected $stringTrim;
53
54		/**
55		* @var Filter\StringToLower
56		*/
57		protected $stringToLower;
58
59		/**
60		*
61		* @param string $delimiterReplacement
62		* @param string\|array $wordDelimiters
63		*/
64		public function __construct($delimiterReplacement = '-', $wordDelimiters = null)
65		{
66		$this->setDelimiterReplacement($delimiterReplacement);
67		if (null !== $wordDelimiters) {
68		$this->addWordDelimiter($wordDelimiters);
69		}
70		}
71
72		/**
73		* Returns $value filtered to valid URL
74		*
75		* @param string $s
76		* @return string
77		*/
78		public function filter($s)
79		{
80		// convert to ascii -> translate strange chars
81		$s = $this->getTransliteration()->filter($s);
82		// trim spaces
83		$s = $this->getStringTrim()->filter($s);
84		// replace delimiters with another character
85		$s = $this->replaceDelimiters($s);
86		// lower chars
87		$s = $this->getStringToLower()->filter($s);
88		// delete chars except a-z0-9
89		$s = $this->trimSpecialsChars($s);
90		// replace double dashes with single one
91		$s = $this->replaceDoubleDelimiterReplacementWithSingle($s);
92		// trim dashes on beginning/end of the string
93		$s = $this->trimStartAndEndSpaceReplacement($s);
94		return $s;
95		}
96
97		/**
98		* @return Transliteration
99		*/
100		public function getTransliteration()
101		{
102		if (null === $this->transliteration) {
103		$this->transliteration = new Transliteration;
104		}
105		return $this->transliteration;
106		}
107
108		/**
109		* @param Transliteration $transliteration
110		* @return $this
111		*/
112		public function setTransliteration(Transliteration $transliteration)
113		{
114		$this->transliteration = $transliteration;
115		return $this;
116		}
117
118		/**
119		* @return Filter\StringTrim
120		*/
121		public function getStringTrim()
122		{
123		if (null === $this->stringTrim) {
124		$this->stringTrim = new Filter\StringTrim;
125		}
126		return $this->stringTrim;
127		}
128
129		/**
130		* @param Filter\StringTrim $stringTrim
131		* @return $this
132		*/
133		public function setStringTrim(Filter\StringTrim $stringTrim)
134		{
135		$this->stringTrim = $stringTrim;
136		return $this;
137		}
138
139		/**
140		* @return Filter\StringToLower
141		*/
142		public function getStringToLower()
143		{
144		if (null === $this->stringToLower) {
145		$this->stringToLower = new Filter\StringToLower;
146		$this->stringToLower->setEncoding('utf-8');
147		}
148		return $this->stringToLower;
149		}
150
151		/**
152		* @param Filter\StringToLower $stringToLower
153		* @return $this
154		*/
155		public function setStringToLower(Filter\StringToLower $stringToLower)
156		{
157		$this->stringToLower = $stringToLower;
158		return $this;
159		}
160
161		/**
162		* @param string\|array $notReplaced
163		* @return $this
164		* @throws Exception\RuntimeException
165		*/
166	View Code Duplication	public function addNotReplacedChars($notReplaced)
		0 ignored issues – show Duplication introduced 2017-11-29 13:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
167		{
168		if (in_array($notReplaced, $this->getNotReplacedChars())) {
169		throw new Exception\RuntimeException("Not replaced characterr '$notReplaced' is already there.");
170		}
171
172		if (empty($notReplaced)) {
173		throw new Exception\RuntimeException('Not replaced character cannot be null.');
174		}
175
176		if (is_array($notReplaced)) {
177		$this->notReplacedChars = array_merge($this->getNotReplacedChars(), $notReplaced);
178		} else {
179		$this->notReplacedChars[] = $notReplaced;
180		}
181
182		return $this;
183		}
184
185		/**
186		* Returns chars which are not replaced
187		*
188		* @return array
189		*/
190		public function getNotReplacedChars()
191		{
192		return $this->notReplacedChars;
193		}
194
195		/**
196		* Remove not replaced character
197		*
198		* @param string\|array $notReplaced
199		* @return $this
200		* @throws Exception\RuntimeException
201		*/
202	View Code Duplication	public function removeNotReplacedChar($notReplaced)
		0 ignored issues – show Duplication introduced 2017-11-29 13:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
203		{
204		if (empty($notReplaced)) {
205		throw new Exception\RuntimeException('Not replaced character cannot be null.');
206		}
207
208		if (is_array($notReplaced)) {
209		foreach ($notReplaced as $n) {
210		$this->removeNotReplacedChar($n);
211		}
212		} else {
213		if (!in_array($notReplaced, $this->getNotReplacedChars())) {
214		throw new Exception\RuntimeException("Not replaced character '$notReplaced' is not in array.");
215		}
216
217		$notReplacedChars = [];
218		foreach ($this->notReplacedChars as $n) {
219		if ($n != $notReplaced) {
220		$notReplacedChars[] = $n;
221		}
222		$this->notReplacedChars = $notReplacedChars;
223		}
224		}
225
226		return $this;
227		}
228
229		/**
230		* Returns the delimiterReplacement option
231		*
232		* @return string
233		*/
234		public function getDelimiterReplacement()
235		{
236		return $this->delimiterReplacement;
237		}
238
239		/**
240		* Sets the delimiterReplacement option
241		*
242		* @param string $delimiterReplacement
243		* @return $this
244		*/
245		public function setDelimiterReplacement($delimiterReplacement)
246		{
247		$this->delimiterReplacement = $delimiterReplacement;
248		return $this;
249		}
250
251		/**
252		* Returns word delimiters array
253		*
254		* @return array
255		*/
256		public function getWordDelimiters()
257		{
258		return $this->wordDelimiters;
259		}
260
261		/**
262		* Add word delimiter
263		*
264		* @param string\|array $delimiter
265		* @return $this
266		* @throws Exception\RuntimeException
267		*/
268	View Code Duplication	public function addWordDelimiter($delimiter)
		0 ignored issues – show Duplication introduced 2017-11-29 13:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
269		{
270		if (in_array($delimiter, $this->getWordDelimiters())) {
271		throw new Exception\RuntimeException("Word delimiter '$delimiter' is already there.");
272		}
273
274		if (empty($delimiter)) {
275		throw new Exception\RuntimeException('Word delimiter cannot be null.');
276		}
277
278		if (is_array($delimiter)) {
279		$this->wordDelimiters = array_merge($this->getWordDelimiters(), $delimiter);
280		} else {
281		$this->wordDelimiters[] = $delimiter;
282		}
283
284		return $this;
285		}
286
287		/**
288		* Remove word delimiter
289		*
290		* @param string\|array $delimiters
291		* @return $this
292		* @throws Exception\RuntimeException
293		*/
294	View Code Duplication	public function removeWordDelimiter($delimiters)
		0 ignored issues – show Duplication introduced 2017-11-29 13:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
295		{
296		if (empty($delimiters)) {
297		throw new Exception\RuntimeException('Word delimiter cannot be null.');
298		}
299
300		if (is_array($delimiters)) {
301		foreach ($delimiters as $delimiter) {
302		$this->removeWordDelimiter($delimiter);
303		}
304		} else {
305		if (!in_array($delimiters, $this->getWordDelimiters())) {
306		throw new Exception\RuntimeException("Word delimiter '$delimiters' is not in delimiters array.");
307		}
308
309		$wordDelimiters = [];
310		foreach ($this->wordDelimiters as $delimiter) {
311		if ($delimiter != $delimiters) {
312		$wordDelimiters[] = $delimiter;
313		}
314		$this->wordDelimiters = $wordDelimiters;
315		}
316		}
317
318		return $this;
319		}
320
321		/**
322		* Replace delimiters with another string
323		*
324		* @param string $s
325		* @return string
326		*/
327		private function replaceDelimiters($s)
328		{
329		foreach ($this->getWordDelimiters() as $delimiter) {
330
331		if ($delimiter == $this->getDelimiterReplacement()) {
332		continue;
333		}
334
335		if (in_array($delimiter, $this->getNotReplacedChars())) {
336		continue;
337		}
338
339		$s = str_replace($delimiter, $this->getDelimiterReplacement(), $s);
340		}
341
342		return $s;
343		}
344
345		/**
346		* To special chars
347		*
348		* @param string $s
349		* @return string
350		*/
351		private function trimSpecialsChars($s)
352		{
353		if (count($this->getNotReplacedChars()) == 0) {
354		$reg = '~[^-a-z0-9_]+~';
355		} else {
356		$reg = '~[^-a-z0-9_' . implode('', $this->getNotReplacedChars()) . ']+~';
357		}
358		return preg_replace($reg, '', $s);
359		}
360
361		/**
362		* Replace double delimiter with single one
363		*
364		* @param string $s
365		* @return string
366		*/
367		private function replaceDoubleDelimiterReplacementWithSingle($s)
368		{
369		$doubleDelimiterReplacement = $this->getDelimiterReplacement() . $this->getDelimiterReplacement();
370		while (strpos($s, $doubleDelimiterReplacement) !== false) {
371		$s = str_replace($doubleDelimiterReplacement, $this->getDelimiterReplacement(), $s);
372		}
373		return $s;
374		}
375
376		/**
377		* Trim dashes on beginning/end of the string
378		*
379		* @param string $s
380		* @return string
381		*/
382		private function trimStartAndEndSpaceReplacement($s)
383		{
384		return trim($s, $this->getDelimiterReplacement());
385		}
386		}
387

webino / WebinoI18nSanitizeLib

Sanitize B last analyzed 2017-12-01 13:12 UTC