Sanitise::disinfect() - Code Metrics - Inspection of "Updated to start using models" - devtoolboxuk/soteria - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d15e2a...9605ab )

by Rob

created 2019-05-25 15:34 UTC

Sanitise::disinfect() C

↳ Parent: Sanitise

Complexity

Conditions	14
Paths	22

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	82.5328

Importance

Changes

Metric	Value
dl	0
loc	62
ccs	13
cts	44
cp	0.2955
rs	6.2666
c	0
b	0
f	0
cc	14
nc	22
nop	3
crap	82.5328

How to fix Long Method Complexity

<?php

namespace devtoolboxuk\soteria\handlers;


use devtoolboxuk\soteria\classes\Filters;
use devtoolboxuk\soteria\models\SoteriaModel;

class Sanitise

{

    private $is_valid = null;
    private $_sanitised = null;
    private $filters;
    private $input;
    private $output;

    private $urlRegEx = '/\b((https?|ftp|file):\/\/|www\.)[-A-Z0-9+&@#\/%?=~_|$!:,.;]*[A-Z0-9+&@#\/%=~_|$]/i';

    function __construct()

    {
        $this->filters = new Filters();
    }

    /**
     *
     * Removes URLs from strings
     *
     * @param array|string $data
     * @return array|string|string[]|null
     */
    public function removeUrl($data)
    {
        $this->_sanitised = null;

        if (is_array($data)) {
            foreach ($data as $key => $value) {
                $data[$key] = $this->removeUrl($value);
            }
            return $data;
        }

        $this->input = $data;

        $data = $this->cleanString($data);
        $data = preg_replace($this->urlRegEx, ' ', $data);

        if ($this->input != $data) {
            $this->_sanitised = true;
        }
        $this->is_valid = true;

        $this->output = $data;
        return $data;

    }

    /**
     * @param $data
     * @return string
     */
    private function cleanString($data)
    {
        $data = implode("", explode("\\", $data));
        return strip_tags(trim(stripslashes($data)));
    }

    /**
     * @param $data
     * @return array|false|string|string[]|null
     */
    public function cleanse($data)
    {

        if (is_array($data)) {
            foreach ($data as $key => $value) {
                $data[$key] = $this->cleanse($value);
            }
            return $data;
        }

        $this->input = $data;
        $data = $this->cleanString($data);
        $data = mb_convert_encoding($data, "utf-8", "auto");
        $data = htmlspecialchars_decode($data);
        $data = $this->cleanString($data);
        if ($this->input != $data) {
            $this->_sanitised = true;
        }
        $this->output = $data;
        return $data;
    }

    /**
     * @param $string
     * @param string $delimiter
     * @return string
     */
    public function cleanseCsv($string, $delimiter = "|")
    {
        return trim(str_replace([$delimiter, "\n", "\r", "\t"], " ", $string));
    }

    /**
     * @param $data
     * @param string $type
     * @param int $stringLength
     * @return mixed|string
     */
    public function disinfect($data, $type = 'special_chars', $stringLength = -1)

    {

        $this->_sanitised = null;

        if (is_array($data)) {
            foreach ($data as $key => $value) {
                $data[$key] = $this->disinfect($value, $type, $stringLength);
            }
            return $data;
        }

        $this->input = $data;

        $data = $this->cleanString($data);
        $data = $this->stringLength($data, $stringLength);

        switch ($type) {
            case "email":
                $filterResult = $this->filters->filterEmail($data);
                break;

            case "encoded":
                $filterResult = $this->filters->filterEncoded($data);
                break;

            case "number_float":
            case "float":
                $filterResult = $this->filters->filterFloat($data);
                break;

            case "number_int":
            case "int":
                $filterResult = $this->filters->filtetInt($data);

                break;

            case "full_special_chars":
                $filterResult = $this->filters->filterFullSpecialChar($data);
                break;

            case "url":
                $filterResult = $this->filters->filterUrl($data);
                break;

            case "string":
                $filterResult = $this->filters->filterString($data);
                break;

            default:
            case "special_chars":
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
                $filterResult = $this->filters->filterSpecial($data);
                break;
        }

        if ($this->input != $filterResult->getResult()) {
            $this->_sanitised = true;
        }

        $this->is_valid = $filterResult->isValid();
        $this->output = $filterResult->getResult();
        return $this->output;
    }

    /**
     * @param $data
     * @param int $length
     * @return bool|string
     */
    private function stringLength($data, $length = -1)
    {
        if ($length > 0) {
            if (mb_strlen($data) > $length) {
                $data = substr($data, 0, $length);
            }
        }
        return $data;
    }


    /**
     * @return null
     */
    public function isSanitised()
    {
        return $this->_sanitised;
    }

    /**
     * Returns true if the data is valid
     * @return null
     */
    public function isValid()
    {
        return $this->is_valid;
    }

    function result()

    {
        $valid = false;
        if (!$this->_sanitised && $this->is_valid) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            $valid = true;
        }
        return new SoteriaModel($this->input, $this->output, $valid);
    }

}

1		<?php
2
3		namespace devtoolboxuk\soteria\handlers;
4
5
6		use devtoolboxuk\soteria\classes\Filters;
7		use devtoolboxuk\soteria\models\SoteriaModel;
8
9		class Sanitise
		0 ignored issues – show Coding Style introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report The property $is_valid is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report The property $_sanitised is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history...
10		{
11
12		private $is_valid = null;
13		private $_sanitised = null;
14		private $filters;
15		private $input;
16		private $output;
17
18		private $urlRegEx = '/\b((https?\|ftp\|file):\/\/\|www\.)[-A-Z0-9+&@#\/%?=~_\|$!:,.;]*[A-Z0-9+&@#\/%=~_\|$]/i';
19
20		function __construct()
		0 ignored issues – show Best Practice introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history... Comprehensibility Best Practice introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `__construct`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
21		{
22		$this->filters = new Filters();
23		}
24
25		/**
26		*
27		* Removes URLs from strings
28		*
29		* @param array\|string $data
30		* @return array\|string\|string[]\|null
31		*/
32		public function removeUrl($data)
33		{
34		$this->_sanitised = null;
35
36		if (is_array($data)) {
37		foreach ($data as $key => $value) {
38		$data[$key] = $this->removeUrl($value);
39		}
40		return $data;
41		}
42
43		$this->input = $data;
44
45		$data = $this->cleanString($data);
46		$data = preg_replace($this->urlRegEx, ' ', $data);
47
48		if ($this->input != $data) {
49		$this->_sanitised = true;
50		}
51		$this->is_valid = true;
52
53		$this->output = $data;
54		return $data;
55
56		}
57
58		/**
59		* @param $data
60		* @return string
61		*/
62	1	private function cleanString($data)
63		{
64	1	$data = implode("", explode("\\", $data));
65	1	return strip_tags(trim(stripslashes($data)));
66		}
67
68		/**
69		* @param $data
70		* @return array\|false\|string\|string[]\|null
71		*/
72		public function cleanse($data)
73		{
74
75		if (is_array($data)) {
76		foreach ($data as $key => $value) {
77		$data[$key] = $this->cleanse($value);
78		}
79		return $data;
80		}
81
82		$this->input = $data;
83		$data = $this->cleanString($data);
84		$data = mb_convert_encoding($data, "utf-8", "auto");
85		$data = htmlspecialchars_decode($data);
86		$data = $this->cleanString($data);
87		if ($this->input != $data) {
88		$this->_sanitised = true;
89		}
90		$this->output = $data;
91		return $data;
92		}
93
94		/**
95		* @param $string
96		* @param string $delimiter
97		* @return string
98		*/
99		public function cleanseCsv($string, $delimiter = "\|")
100		{
101		return trim(str_replace([$delimiter, "\n", "\r", "\t"], " ", $string));
102		}
103
104		/**
105		* @param $data
106		* @param string $type
107		* @param int $stringLength
108		* @return mixed\|string
109		*/
110	1	public function disinfect($data, $type = 'special_chars', $stringLength = -1)
		0 ignored issues – show Complexity introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report This operation has 66 execution paths which exceeds the configured maximum of 10. A high number of execution paths generally suggests many nested conditional statements and make the code less readible. This can usually be fixed by splitting the method into several smaller methods. You can also find more information in the “Code” section of your repository. Loading history...
111		{
112
113	1	$this->_sanitised = null;
114
115	1	if (is_array($data)) {
116		foreach ($data as $key => $value) {
117		$data[$key] = $this->disinfect($value, $type, $stringLength);
118		}
119		return $data;
120		}
121
122	1	$this->input = $data;
123
124	1	$data = $this->cleanString($data);
125	1	$data = $this->stringLength($data, $stringLength);
126
127		switch ($type) {
128	1	case "email":
129	1	$filterResult = $this->filters->filterEmail($data);
130	1	break;
131
132		case "encoded":
133		$filterResult = $this->filters->filterEncoded($data);
134		break;
135
136		case "number_float":
137		case "float":
138		$filterResult = $this->filters->filterFloat($data);
139		break;
140
141		case "number_int":
142		case "int":
143		$filterResult = $this->filters->filtetInt($data);
		0 ignored issues – show Bug introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report The method `filtetInt()` does not seem to exist on `object<devtoolboxuk\soteria\classes\Filters>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
144		break;
145
146		case "full_special_chars":
147		$filterResult = $this->filters->filterFullSpecialChar($data);
148		break;
149
150		case "url":
151		$filterResult = $this->filters->filterUrl($data);
152		break;
153
154		case "string":
155		$filterResult = $this->filters->filterString($data);
156		break;
157
158		default:
159		case "special_chars":
		0 ignored issues – show Unused Code introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report `case 'special_chars': ...cial($data); break;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
160		$filterResult = $this->filters->filterSpecial($data);
161		break;
162		}
163
164	1	if ($this->input != $filterResult->getResult()) {
165		$this->_sanitised = true;
166		}
167
168	1	$this->is_valid = $filterResult->isValid();
169	1	$this->output = $filterResult->getResult();
170	1	return $this->output;
171		}
172
173		/**
174		* @param $data
175		* @param int $length
176		* @return bool\|string
177		*/
178	1	private function stringLength($data, $length = -1)
179		{
180	1	if ($length > 0) {
181		if (mb_strlen($data) > $length) {
182		$data = substr($data, 0, $length);
183		}
184		}
185	1	return $data;
186		}
187
188
189		/**
190		* @return null
191		*/
192		public function isSanitised()
193		{
194		return $this->_sanitised;
195		}
196
197		/**
198		* Returns true if the data is valid
199		* @return null
200		*/
201		public function isValid()
202		{
203		return $this->is_valid;
204		}
205
206	1	function result()
		0 ignored issues – show Best Practice introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history... Comprehensibility Best Practice introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report It is recommend to declare an explicit visibility for `result`. Generally, we recommend to declare visibility for all methods in your source code. This has the advantage of clearly communication to other developers, and also yourself, how this method should be consumed. If you are not sure which visibility to choose, it is a good idea to start with the most restrictive visibility, and then raise visibility as needed, i.e. start with `private`, and only raise it to `protected` if a sub-class needs to have access, or `public` if an external class needs access. Loading history...
207		{
208	1	$valid = false;
209	1	if (!$this->_sanitised && $this->is_valid) {
		0 ignored issues – show Bug Best Practice introduced 2019-05-25 15:36 UTC by Report Bug Copy Issue Report The expression `$this->_sanitised` of type `null\|boolean` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
210	1	$valid = true;
211	1	}
212	1	return new SoteriaModel($this->input, $this->output, $valid);
213		}
214
215		}

devtoolboxuk / soteria

Push — master ( d15e2a...9605ab )

Sanitise::disinfect() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like