Client::checkCleanParamRule() - Code Metrics - Inspection of "Initial commit" - VIPnytt/RobotsTxtParser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fda467...a7ec5f )

by Jan-Petter

created 2016-04-12 17:57 UTC

Client::checkCleanParamRule() B

↳ Parent: Client

Complexity

Conditions	6
Paths	4

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	17
rs	8.8571
cc	6
eloc	10
nc	4
nop	2

<?php
namespace vipnytt\RobotsTxtParser;

use vipnytt\UserAgentParser;

class Client implements RobotsTxtInterface
{
    use UrlToolbox;

    protected $rules = [];

    protected $url = '';
    protected $statusCode = 200;

    protected $userAgent = self::USER_AGENT;

    /**
     * Constructor
     *
     * @param string $content - file content
     * @param string|null $encoding - character encoding
     * @param integer|null $byteLimit - maximum of bytes to parse
     * @param integer|null $maxRuleLength - max length of each rule
     */
    public function __construct($content, $encoding = null, $byteLimit = self::BYTE_LIMIT, $maxRuleLength = self::MAX_LENGTH_RULE)
    {
        if ($encoding === null) {
            $encoding = mb_detect_encoding($content);
        }
        $read = new Parser($content, $encoding, $byteLimit, $maxRuleLength);
        $this->rules = $read->export();
    }

    public function setOrigin($url, $statusCode)
    {
        if (!($this->urlValidate(($url = $this->urlEncode($url))))) {
            throw new Exceptions\ClientException('Invalid URL');
        }
        $this->url = $url;
        $this->statusCode = $statusCode;
    }

    /**
     * Set UserAgent
     *
     * @param string|null $userAgent
     * @return void
     */
    public function setUserAgent($userAgent)
    {
        if (
            empty($userAgent) ||
            !isset($this->rules[self::DIRECTIVE_USER_AGENT])
        ) {
            $this->userAgent = self::USER_AGENT;
            return;
        }
        $parser = new UserAgentParser($userAgent);
        $this->userAgent = $parser->match(array_keys($this->rules[self::DIRECTIVE_USER_AGENT]));
    }

    /**
     *
     *
     * @param  string $url - url to check
     * @return bool
     */
    public function isAllowed($url)
    {
        return $this->checkRules(self::DIRECTIVE_ALLOW, $this->getPath($url));

    }

    /**
     * Check rules
     *
     * @param  string $type - rule to check
     * @param  string $path - path to check
     * @return bool
     */
    protected function checkRules($type, $path)
    {
        // Check each directive for rules, allowed by default
        $result = ($type === self::DIRECTIVE_ALLOW);
        foreach ([self::DIRECTIVE_DISALLOW, self::DIRECTIVE_ALLOW] as $directive) {
            if (!isset($this->rules[self::DIRECTIVE_USER_AGENT][$this->userAgent][$directive])) {
                continue;
            }
            foreach ($this->rules[self::DIRECTIVE_USER_AGENT][$this->userAgent][$directive] as $ruleType => $array) {
                // check rule
                if ($this->checkRuleSwitch($ruleType, $path, $array)) {
                    $result = ($type === $directive);
                }
            }
        }
        return $result;
    }

    /**
     * Check rule switch
     *
     * @param  string $type - directive or part of an url
     * @param  string $path
     * @param  array $array
     * @return bool
     */
    private function checkRuleSwitch($type, $path, $array)
    {
        switch ($type) {
            case self::DIRECTIVE_CLEAN_PARAM:
                return $this->checkCleanParamRule($path, $array);
            case self::DIRECTIVE_HOST;
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B": //right
        doSomething();
        break;
}
                return $this->checkHostRule($array);
        }
        return $this->checkRulePaths($path, $array);
    }

    /**
     * Check Clean-Param rule
     *
     * @param  string $path
     * @param  array $array
     * @return bool
     */
    protected function checkCleanParamRule($path, $array)
    {
        foreach ($array as $param => $paths) {
            if (
                mb_strpos($path, "?$param=") ||
                mb_strpos($path, "&$param=")
            ) {
                if (
                    empty($paths) ||
                    $this->checkRulePaths($path, $paths)
                ) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Check basic rule
     *
     * @param  string $path
     * @param  array $array
     * @return bool
     */
    protected function checkRulePaths($path, $array)
    {
        foreach ($array as $robotPath) {
            if (preg_match('#' . $robotPath . '#', $path)) {
                if (mb_strpos($robotPath, '$') !== false) {
                    if (mb_strlen($robotPath) - 1 == mb_strlen($path)) {
                        return true;
                    }
                } else {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Check Host rule
     *
     * @param  array $array
     * @return bool
     */
    protected function checkHostRule($array)
    {
        if (!isset($this->url)) {
            return false;
        }
        $host = mb_strtolower($this->urlEncode($array[0]));
        $url = [
            'scheme' => parse_url($this->url, PHP_URL_SCHEME),
            'host' => parse_url($this->url, PHP_URL_HOST),
        ];
        $url['port'] = is_int($port = parse_url($this->url, PHP_URL_PORT)) ? $port : getservbyname($url['scheme'], 'tcp');
        $cases = [
            $url['host'],
            $url['host'] . ':' . $url['port'],
            $url['scheme'] . '://' . $url['host'],
            $url['scheme'] . '://' . $url['host'] . ':' . $url['port']
        ];
        if (in_array($host, $cases)) {
            return true;
        }
        return false;
    }

    /**
     * Get path
     *
     * @param string $url
     * @return string
     * @throws Exceptions\ClientException
     */
    protected function getPath($url)
    {
        $url = $this->urlEncode($url);
        if (mb_stripos($url, '/') === 0) {
            // URL already is a path
            return $url;
        }
        if (!$this->urlValidate($url)) {
            throw new Exceptions\ClientException('Invalid URL');
        }
        return parse_url($url, PHP_URL_PATH);
    }

    /**
     *
     *
     * @param  string $url - url to check
     * @return bool
     */
    public function isDisallowed($url)
    {
        return $this->checkRules(self::DIRECTIVE_DISALLOW, $this->getPath($url));

    }

    /**
     * Get sitemaps
     *
     * @return array
     */
    public function getSitemaps()
    {
        if (empty($sitemaps = $this->rules[self::DIRECTIVE_SITEMAP])) {
            return [];
        }
        return $sitemaps;
    }

    /**
     * Get host
     *
     * @return string|null
     */
    public function getHost()
    {
        if (empty($host = $this->rules[self::DIRECTIVE_HOST][0])) {
            return null;
        }
        return $host;
    }

    /**
     * Get Clean-param
     *
     * @return array
     */
    public function getCleanParam()
    {
        if (empty($cleanParam = $this->rules[self::DIRECTIVE_CLEAN_PARAM])) {
            return [];
        }
        return $cleanParam;
    }

    /**
     * Get CacheDelay
     *
     * @param bool $fallback return Crawl-delay if not found
     * @return int|float|null
     */
    public function getCacheDelay($fallback = true)
    {
        if (empty($cacheDelay = $this->rules[self::DIRECTIVE_CACHE_DELAY])) {
            return ($fallback) ? $this->getCrawlDelay() : null;
        }
        return $cacheDelay;
    }

    /**
     * Get CrawlDelay
     *
     * @return int|float
     */
    public function getCrawlDelay()
    {
        if (empty($crawlDelay = $this->rules[self::DIRECTIVE_CRAWL_DELAY])) {
            return 0;
        }
        return $crawlDelay;
    }
}


1			<?php
2			namespace vipnytt\RobotsTxtParser;
3
4			use vipnytt\UserAgentParser;
5
6			class Client implements RobotsTxtInterface
7			{
8			use UrlToolbox;
9
10			protected $rules = [];
11
12			protected $url = '';
13			protected $statusCode = 200;
14
15			protected $userAgent = self::USER_AGENT;
16
17			/**
18			* Constructor
19			*
20			* @param string $content - file content
21			* @param string\|null $encoding - character encoding
22			* @param integer\|null $byteLimit - maximum of bytes to parse
23			* @param integer\|null $maxRuleLength - max length of each rule
24			*/
25			public function __construct($content, $encoding = null, $byteLimit = self::BYTE_LIMIT, $maxRuleLength = self::MAX_LENGTH_RULE)
26			{
27			if ($encoding === null) {
28			$encoding = mb_detect_encoding($content);
29			}
30			$read = new Parser($content, $encoding, $byteLimit, $maxRuleLength);
31			$this->rules = $read->export();
32			}
33
34			public function setOrigin($url, $statusCode)
35			{
36			if (!($this->urlValidate(($url = $this->urlEncode($url))))) {
37			throw new Exceptions\ClientException('Invalid URL');
38			}
39			$this->url = $url;
40			$this->statusCode = $statusCode;
41			}
42
43			/**
44			* Set UserAgent
45			*
46			* @param string\|null $userAgent
47			* @return void
48			*/
49			public function setUserAgent($userAgent)
50			{
51			if (
52			empty($userAgent) \|\|
53			!isset($this->rules[self::DIRECTIVE_USER_AGENT])
54			) {
55			$this->userAgent = self::USER_AGENT;
56			return;
57			}
58			$parser = new UserAgentParser($userAgent);
59			$this->userAgent = $parser->match(array_keys($this->rules[self::DIRECTIVE_USER_AGENT]));
60			}
61
62			/**
63			*
64			*
65			* @param string $url - url to check
66			* @return bool
67			*/
68			public function isAllowed($url)
69			{
70			return $this->checkRules(self::DIRECTIVE_ALLOW, $this->getPath($url));
			0 ignored issues – show Security Bug introduced 2016-04-12 17:59 UTC by Report Bug Copy Issue Report It seems like `$this->getPath($url)` targeting `vipnytt\RobotsTxtParser\Client::getPath()` can also be of type `false`; however, `vipnytt\RobotsTxtParser\Client::checkRules()` does only seem to accept `string`, did you maybe forget to handle an error condition? Loading history...
71			}
72
73			/**
74			* Check rules
75			*
76			* @param string $type - rule to check
77			* @param string $path - path to check
78			* @return bool
79			*/
80			protected function checkRules($type, $path)
81			{
82			// Check each directive for rules, allowed by default
83			$result = ($type === self::DIRECTIVE_ALLOW);
84			foreach ([self::DIRECTIVE_DISALLOW, self::DIRECTIVE_ALLOW] as $directive) {
85			if (!isset($this->rules[self::DIRECTIVE_USER_AGENT][$this->userAgent][$directive])) {
86			continue;
87			}
88			foreach ($this->rules[self::DIRECTIVE_USER_AGENT][$this->userAgent][$directive] as $ruleType => $array) {
89			// check rule
90			if ($this->checkRuleSwitch($ruleType, $path, $array)) {
91			$result = ($type === $directive);
92			}
93			}
94			}
95			return $result;
96			}
97
98			/**
99			* Check rule switch
100			*
101			* @param string $type - directive or part of an url
102			* @param string $path
103			* @param array $array
104			* @return bool
105			*/
106			private function checkRuleSwitch($type, $path, $array)
107			{
108			switch ($type) {
109			case self::DIRECTIVE_CLEAN_PARAM:
110			return $this->checkCleanParamRule($path, $array);
111			case self::DIRECTIVE_HOST;
			0 ignored issues – show Coding Style introduced 2016-04-12 17:59 UTC by Report Bug Copy Issue Report CASE statements must be defined using a colon As per the PSR-2 coding standard, case statements should not be wrapped in curly braces. There is no need for braces, since each case is terminated by the next `break`. switch ($expr) { case "A": { //wrong doSomething(); break; } case "B": //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
112			return $this->checkHostRule($array);
113			}
114			return $this->checkRulePaths($path, $array);
115			}
116
117			/**
118			* Check Clean-Param rule
119			*
120			* @param string $path
121			* @param array $array
122			* @return bool
123			*/
124			protected function checkCleanParamRule($path, $array)
125			{
126			foreach ($array as $param => $paths) {
127			if (
128			mb_strpos($path, "?$param=") \|\|
129			mb_strpos($path, "&$param=")
130			) {
131			if (
132			empty($paths) \|\|
133			$this->checkRulePaths($path, $paths)
134			) {
135			return true;
136			}
137			}
138			}
139			return false;
140			}
141
142			/**
143			* Check basic rule
144			*
145			* @param string $path
146			* @param array $array
147			* @return bool
148			*/
149			protected function checkRulePaths($path, $array)
150			{
151			foreach ($array as $robotPath) {
152			if (preg_match('#' . $robotPath . '#', $path)) {
153			if (mb_strpos($robotPath, '$') !== false) {
154			if (mb_strlen($robotPath) - 1 == mb_strlen($path)) {
155			return true;
156			}
157			} else {
158			return true;
159			}
160			}
161			}
162			return false;
163			}
164
165			/**
166			* Check Host rule
167			*
168			* @param array $array
169			* @return bool
170			*/
171			protected function checkHostRule($array)
172			{
173			if (!isset($this->url)) {
174			return false;
175			}
176			$host = mb_strtolower($this->urlEncode($array[0]));
177			$url = [
178			'scheme' => parse_url($this->url, PHP_URL_SCHEME),
179			'host' => parse_url($this->url, PHP_URL_HOST),
180			];
181			$url['port'] = is_int($port = parse_url($this->url, PHP_URL_PORT)) ? $port : getservbyname($url['scheme'], 'tcp');
182			$cases = [
183			$url['host'],
184			$url['host'] . ':' . $url['port'],
185			$url['scheme'] . '://' . $url['host'],
186			$url['scheme'] . '://' . $url['host'] . ':' . $url['port']
187			];
188			if (in_array($host, $cases)) {
189			return true;
190			}
191			return false;
192			}
193
194			/**
195			* Get path
196			*
197			* @param string $url
198			* @return string
199			* @throws Exceptions\ClientException
200			*/
201			protected function getPath($url)
202			{
203			$url = $this->urlEncode($url);
204			if (mb_stripos($url, '/') === 0) {
205			// URL already is a path
206			return $url;
207			}
208			if (!$this->urlValidate($url)) {
209			throw new Exceptions\ClientException('Invalid URL');
210			}
211			return parse_url($url, PHP_URL_PATH);
212			}
213
214			/**
215			*
216			*
217			* @param string $url - url to check
218			* @return bool
219			*/
220			public function isDisallowed($url)
221			{
222			return $this->checkRules(self::DIRECTIVE_DISALLOW, $this->getPath($url));
			0 ignored issues – show Security Bug introduced 2016-04-12 17:59 UTC by Report Bug Copy Issue Report It seems like `$this->getPath($url)` targeting `vipnytt\RobotsTxtParser\Client::getPath()` can also be of type `false`; however, `vipnytt\RobotsTxtParser\Client::checkRules()` does only seem to accept `string`, did you maybe forget to handle an error condition? Loading history...
223			}
224
225			/**
226			* Get sitemaps
227			*
228			* @return array
229			*/
230			public function getSitemaps()
231			{
232			if (empty($sitemaps = $this->rules[self::DIRECTIVE_SITEMAP])) {
233			return [];
234			}
235			return $sitemaps;
236			}
237
238			/**
239			* Get host
240			*
241			* @return string\|null
242			*/
243			public function getHost()
244			{
245			if (empty($host = $this->rules[self::DIRECTIVE_HOST][0])) {
246			return null;
247			}
248			return $host;
249			}
250
251			/**
252			* Get Clean-param
253			*
254			* @return array
255			*/
256			public function getCleanParam()
257			{
258			if (empty($cleanParam = $this->rules[self::DIRECTIVE_CLEAN_PARAM])) {
259			return [];
260			}
261			return $cleanParam;
262			}
263
264			/**
265			* Get CacheDelay
266			*
267			* @param bool $fallback return Crawl-delay if not found
268			* @return int\|float\|null
269			*/
270			public function getCacheDelay($fallback = true)
271			{
272			if (empty($cacheDelay = $this->rules[self::DIRECTIVE_CACHE_DELAY])) {
273			return ($fallback) ? $this->getCrawlDelay() : null;
274			}
275			return $cacheDelay;
276			}
277
278			/**
279			* Get CrawlDelay
280			*
281			* @return int\|float
282			*/
283			public function getCrawlDelay()
284			{
285			if (empty($crawlDelay = $this->rules[self::DIRECTIVE_CRAWL_DELAY])) {
286			return 0;
287			}
288			return $crawlDelay;
289			}
290			}
291

VIPnytt / RobotsTxtParser

Push — master ( fda467...a7ec5f )

Client::checkCleanParamRule() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like