PublicSuffixList::parsePSL() - Code Metrics - Inspection of "Add public suffix list support" - XOOPS/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#325)

by Richard

created 2017-02-07 21:14 UTC

PublicSuffixList::parsePSL() A

↳ Parent: PublicSuffixList

Complexity

Conditions	4
Paths	3

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	7
nc	3
nop	1
dl	0
loc	15
rs	9.2
c	0
b	0
f	0

<?php
namespace Geekwright\RegDom;

/**
 * Manage the Public Suffix List (PSL) data. This includes, downloading, converting to an array tree
 * structure for access in PHP, and caching the results.
 *
 * @package   Geekwright\RegDom
 * @author    Florian Sager, 06.08.2008, <[email protected]>
 * @author    Marcus Bointon (https://github.com/Synchro/regdom-php)
 * @author    Richard Griffith <[email protected]>
 * @license   Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
 */
class PublicSuffixList
{
    protected $sourceURL = 'https://publicsuffix.org/list/public_suffix_list.dat';
    protected $localPSL = 'public_suffix_list.dat';
    protected $cachedPrefix = 'cached_';

    protected $tree;
    protected $url;
    protected $dataDir = '/../data/'; // relative to __DIR__

    /**
     * PublicSuffixList constructor.
     * @param string|null $url URL for the PSL or null to use default
     */
    public function __construct($url = null)
    {
        $this->setURL($url);
    }

    /**
     * Set the URL, and clear any existing tree
     *
     * @param string|null $url URL for the PSL or null to use default
     *
     * @return void
     */
    public function setURL($url)
    {
        $this->url = $url;
        $this->tree = null;
    }

    /**
     * Set a fallback (default) for the URL. If we have a locally saved version, prefer it, but use a
     * remote URL if there is no local source.
     *
     * @return void
     */
    protected function setFallbackURL()
    {
        $this->setLocalPSLName($this->url);
        if (null === $this->url) {
            $this->url = file_exists(__DIR__ . $this->localPSL) ? $this->localPSL : $this->sourceURL;
        }
    }

    /**
     * load the PSL tree, automatically handling caches
     *
     * @return void (results in $this->tree)
     *
     * @throws \RuntimeException
     */
    protected function loadTree()
    {
        $this->setFallbackURL();

        $this->tree = $this->readCachedPSL($this->url);
        if (false !== $this->tree) {
            return;
        }

        $this->tree = array();
        $list = $this->readPSL();

        if (false===$list) {
            $e = new \RuntimeException('Cannot read ' . $this->url);
            throw $e;
        }

        $this->parsePSL($list);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $this->cachePSL($this->url);
    }

    /**
     * Parse the PSL data
     *
     * @param string $fileData the PSL data
     *
     * @return void (results in $this->tree)
     */
    protected function parsePSL($fileData)
    {
        $lines = explode("\n", $fileData);

        foreach ($lines as $line) {
            if ($this->startsWith($line, "//") || $line == '') {
                continue;
            }

            // this line should be a TLD
            $tldParts = explode('.', $line);

            $this->buildSubDomain($this->tree, $tldParts);
        }
    }

    /**
     * Does $search start with $startString?
     *
     * @param string $search      the string to test
     * @param string $startString the starting string to match
     *
     * @return bool
     */
    protected function startsWith($search, $startString)
    {
        return (substr($search, 0, strlen($startString)) == $startString);
    }

    /**
     * Add domains to tree
     *
     * @param array    $node     tree array by reference
     * @param string[] $tldParts array of domain parts
     *
     * @return void - changes made to $node by reference
     */
    protected function buildSubDomain(&$node, $tldParts)
    {
        $dom = trim(array_pop($tldParts));

        $isNotDomain = false;
        if ($this->startsWith($dom, "!")) {
            $dom = substr($dom, 1);
            $isNotDomain = true;
        }

        if (!array_key_exists($dom, $node)) {
            if ($isNotDomain) {
                $node[$dom] = array("!" => "");
            } else {
                $node[$dom] = array();
            }
        }

        if (!$isNotDomain && count($tldParts) > 0) {
            $this->buildSubDomain($node[$dom], $tldParts);
        }
    }

    /**
     * Return the current tree, loading it if needed
     *
     * @return array the PSL tree

     */
    public function getTree()
    {
        if (null===$this->tree) {
            $this->loadTree();
        }
        return $this->tree;
    }

    /**
     * Read PSL from the URL or file specified in $this->url.
     * If we process a remote URL, save a local copy.
     *
     * @return bool|string PSL file contents or false on error
     */
    protected function readPSL()
    {
        $parts = parse_url($this->url);
        $remote = isset($parts['scheme']) || isset($parts['host']);
        // try to read with file_get_contents
        $newPSL = file_get_contents(($remote ? '' : __DIR__) . $this->url);
        if (false !== $newPSL) {
            if ($remote) {
                $this->saveLocalPSL($newPSL);
            }
            return $newPSL;
        }

        // try again with curl if file_get_contents failed
        if (function_exists('curl_init') && false !== ($curlHandle  = curl_init())) {
            curl_setopt($curlHandle, CURLOPT_URL, $this->url);
            curl_setopt($curlHandle, CURLOPT_FAILONERROR, true);
            curl_setopt($curlHandle, CURLOPT_RETURNTRANSFER, 1);
            curl_setopt($curlHandle, CURLOPT_CONNECTTIMEOUT, 5);
            $curlReturn = curl_exec($curlHandle);
            curl_close($curlHandle);
            if (false !== $curlReturn) {
                if ($remote) {
                    $this->saveLocalPSL($curlReturn);
                }
                return $curlReturn;
            }
        }
        return false;
    }

    /**
     * Determine cache file name for a specified source
     *
     * @param string $url URL/filename of source PSL
     *
     * @return string cache file name for given resource
     */
    protected function getCacheFileName($url)
    {
        return __DIR__ . $this->dataDir . $this->cachedPrefix . md5($url);
    }

    /**
     * Attempt to load a cached Public Suffix List tree for a given source
     *
     * @param string $url URL/filename of source PSL
     *
     * @return bool|string[] PSL tree
     */
    protected function readCachedPSL($url)
    {
        $cacheFile = $this->getCacheFileName($url);
        if (file_exists($cacheFile)) {
            $cachedTree = file_get_contents($cacheFile);
            return unserialize($cachedTree);
        }
        return false;
    }

    /**
     * Cache the current Public Suffix List tree and associate with the specified source
     *
     * @param string $url URL/filename of source PSL
     *
     * @return bool|int the number of bytes that were written to the file, or false on failure
     */
    protected function cachePSL($url)
    {
        return file_put_contents($this->getCacheFileName($url), serialize($this->tree));
    }

    /**
     * Save a local copy of a retrieved Public Suffix List
     *
     * @param string $fileContents URL/filename of source PSL
     *
     * @return bool|int the number of bytes that were written to the file, or false on failure
     */
    protected function saveLocalPSL($fileContents)
    {
        return file_put_contents(__DIR__ . $this->localPSL, $fileContents);
    }

    /**
     * Set localPSL name based on URL
     *
     * @param null|string $url the URL for the PSL
     *
     * @return void (sets $this->localPSL)
     */
    protected function setLocalPSLName($url)
    {
        if (null === $url) {
            $url = $this->sourceURL;
        }
        $parts = parse_url($url);
        $fileName = basename($parts['path']);
        $this->localPSL = $this->dataDir . $fileName;
    }

    /**
     * Delete files in the data directory
     *
     * @param bool $cacheOnly true to limit clearing to cached serialized PSLs, false to clear all
     *
     * @return void
     */
    public function clearDataDirectory($cacheOnly = false)
    {
        $dir = $this->dataDir;
        if (is_dir($dir)) {
            if ($dirHandle = opendir($dir)) {
                while (($file = readdir($dirHandle)) !== false) {
                    if (filetype($dir . $file) === 'file'
                        && (false === $cacheOnly || $this->startsWith($file, $this->cachedPrefix)))
                    {
                        unlink($dir . $file);
                    }
                }
                closedir($dirHandle);
            }
        }
    }
}


1			<?php
2			namespace Geekwright\RegDom;
3
4			/**
5			* Manage the Public Suffix List (PSL) data. This includes, downloading, converting to an array tree
6			* structure for access in PHP, and caching the results.
7			*
8			* @package Geekwright\RegDom
9			* @author Florian Sager, 06.08.2008, <[email protected]>
10			* @author Marcus Bointon (https://github.com/Synchro/regdom-php)
11			* @author Richard Griffith <[email protected]>
12			* @license Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
13			*/
14			class PublicSuffixList
15			{
16			protected $sourceURL = 'https://publicsuffix.org/list/public_suffix_list.dat';
17			protected $localPSL = 'public_suffix_list.dat';
18			protected $cachedPrefix = 'cached_';
19
20			protected $tree;
21			protected $url;
22			protected $dataDir = '/../data/'; // relative to __DIR__
23
24			/**
25			* PublicSuffixList constructor.
26			* @param string\|null $url URL for the PSL or null to use default
27			*/
28			public function __construct($url = null)
29			{
30			$this->setURL($url);
31			}
32
33			/**
34			* Set the URL, and clear any existing tree
35			*
36			* @param string\|null $url URL for the PSL or null to use default
37			*
38			* @return void
39			*/
40			public function setURL($url)
41			{
42			$this->url = $url;
43			$this->tree = null;
44			}
45
46			/**
47			* Set a fallback (default) for the URL. If we have a locally saved version, prefer it, but use a
48			* remote URL if there is no local source.
49			*
50			* @return void
51			*/
52			protected function setFallbackURL()
53			{
54			$this->setLocalPSLName($this->url);
55			if (null === $this->url) {
56			$this->url = file_exists(__DIR__ . $this->localPSL) ? $this->localPSL : $this->sourceURL;
57			}
58			}
59
60			/**
61			* load the PSL tree, automatically handling caches
62			*
63			* @return void (results in $this->tree)
64			*
65			* @throws \RuntimeException
66			*/
67			protected function loadTree()
68			{
69			$this->setFallbackURL();
70
71			$this->tree = $this->readCachedPSL($this->url);
72			if (false !== $this->tree) {
73			return;
74			}
75
76			$this->tree = array();
77			$list = $this->readPSL();
78
79			if (false===$list) {
80			$e = new \RuntimeException('Cannot read ' . $this->url);
81			throw $e;
82			}
83
84			$this->parsePSL($list);
			0 ignored issues – show Bug introduced 2017-02-07 21:22 UTC by Report Bug Copy Issue Report It seems like `$list` defined by `$this->readPSL()` on line `77` can also be of type `boolean`; however, `Geekwright\RegDom\PublicSuffixList::parsePSL()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
85			$this->cachePSL($this->url);
86			}
87
88			/**
89			* Parse the PSL data
90			*
91			* @param string $fileData the PSL data
92			*
93			* @return void (results in $this->tree)
94			*/
95			protected function parsePSL($fileData)
96			{
97			$lines = explode("\n", $fileData);
98
99			foreach ($lines as $line) {
100			if ($this->startsWith($line, "//") \|\| $line == '') {
101			continue;
102			}
103
104			// this line should be a TLD
105			$tldParts = explode('.', $line);
106
107			$this->buildSubDomain($this->tree, $tldParts);
108			}
109			}
110
111			/**
112			* Does $search start with $startString?
113			*
114			* @param string $search the string to test
115			* @param string $startString the starting string to match
116			*
117			* @return bool
118			*/
119			protected function startsWith($search, $startString)
120			{
121			return (substr($search, 0, strlen($startString)) == $startString);
122			}
123
124			/**
125			* Add domains to tree
126			*
127			* @param array $node tree array by reference
128			* @param string[] $tldParts array of domain parts
129			*
130			* @return void - changes made to $node by reference
131			*/
132			protected function buildSubDomain(&$node, $tldParts)
133			{
134			$dom = trim(array_pop($tldParts));
135
136			$isNotDomain = false;
137			if ($this->startsWith($dom, "!")) {
138			$dom = substr($dom, 1);
139			$isNotDomain = true;
140			}
141
142			if (!array_key_exists($dom, $node)) {
143			if ($isNotDomain) {
144			$node[$dom] = array("!" => "");
145			} else {
146			$node[$dom] = array();
147			}
148			}
149
150			if (!$isNotDomain && count($tldParts) > 0) {
151			$this->buildSubDomain($node[$dom], $tldParts);
152			}
153			}
154
155			/**
156			* Return the current tree, loading it if needed
157			*
158			* @return array the PSL tree
			0 ignored issues – show Documentation introduced 2017-02-07 21:22 UTC by Report Bug Copy Issue Report Should the return type not be `null\|array`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
159			*/
160			public function getTree()
161			{
162			if (null===$this->tree) {
163			$this->loadTree();
164			}
165			return $this->tree;
166			}
167
168			/**
169			* Read PSL from the URL or file specified in $this->url.
170			* If we process a remote URL, save a local copy.
171			*
172			* @return bool\|string PSL file contents or false on error
173			*/
174			protected function readPSL()
175			{
176			$parts = parse_url($this->url);
177			$remote = isset($parts['scheme']) \|\| isset($parts['host']);
178			// try to read with file_get_contents
179			$newPSL = file_get_contents(($remote ? '' : __DIR__) . $this->url);
180			if (false !== $newPSL) {
181			if ($remote) {
182			$this->saveLocalPSL($newPSL);
183			}
184			return $newPSL;
185			}
186
187			// try again with curl if file_get_contents failed
188			if (function_exists('curl_init') && false !== ($curlHandle = curl_init())) {
189			curl_setopt($curlHandle, CURLOPT_URL, $this->url);
190			curl_setopt($curlHandle, CURLOPT_FAILONERROR, true);
191			curl_setopt($curlHandle, CURLOPT_RETURNTRANSFER, 1);
192			curl_setopt($curlHandle, CURLOPT_CONNECTTIMEOUT, 5);
193			$curlReturn = curl_exec($curlHandle);
194			curl_close($curlHandle);
195			if (false !== $curlReturn) {
196			if ($remote) {
197			$this->saveLocalPSL($curlReturn);
198			}
199			return $curlReturn;
200			}
201			}
202			return false;
203			}
204
205			/**
206			* Determine cache file name for a specified source
207			*
208			* @param string $url URL/filename of source PSL
209			*
210			* @return string cache file name for given resource
211			*/
212			protected function getCacheFileName($url)
213			{
214			return __DIR__ . $this->dataDir . $this->cachedPrefix . md5($url);
215			}
216
217			/**
218			* Attempt to load a cached Public Suffix List tree for a given source
219			*
220			* @param string $url URL/filename of source PSL
221			*
222			* @return bool\|string[] PSL tree
223			*/
224			protected function readCachedPSL($url)
225			{
226			$cacheFile = $this->getCacheFileName($url);
227			if (file_exists($cacheFile)) {
228			$cachedTree = file_get_contents($cacheFile);
229			return unserialize($cachedTree);
230			}
231			return false;
232			}
233
234			/**
235			* Cache the current Public Suffix List tree and associate with the specified source
236			*
237			* @param string $url URL/filename of source PSL
238			*
239			* @return bool\|int the number of bytes that were written to the file, or false on failure
240			*/
241			protected function cachePSL($url)
242			{
243			return file_put_contents($this->getCacheFileName($url), serialize($this->tree));
244			}
245
246			/**
247			* Save a local copy of a retrieved Public Suffix List
248			*
249			* @param string $fileContents URL/filename of source PSL
250			*
251			* @return bool\|int the number of bytes that were written to the file, or false on failure
252			*/
253			protected function saveLocalPSL($fileContents)
254			{
255			return file_put_contents(__DIR__ . $this->localPSL, $fileContents);
256			}
257
258			/**
259			* Set localPSL name based on URL
260			*
261			* @param null\|string $url the URL for the PSL
262			*
263			* @return void (sets $this->localPSL)
264			*/
265			protected function setLocalPSLName($url)
266			{
267			if (null === $url) {
268			$url = $this->sourceURL;
269			}
270			$parts = parse_url($url);
271			$fileName = basename($parts['path']);
272			$this->localPSL = $this->dataDir . $fileName;
273			}
274
275			/**
276			* Delete files in the data directory
277			*
278			* @param bool $cacheOnly true to limit clearing to cached serialized PSLs, false to clear all
279			*
280			* @return void
281			*/
282			public function clearDataDirectory($cacheOnly = false)
283			{
284			$dir = $this->dataDir;
285			if (is_dir($dir)) {
286			if ($dirHandle = opendir($dir)) {
287			while (($file = readdir($dirHandle)) !== false) {
288			if (filetype($dir . $file) === 'file'
289			&& (false === $cacheOnly \|\| $this->startsWith($file, $this->cachedPrefix)))
290			{
291			unlink($dir . $file);
292			}
293			}
294			closedir($dirHandle);
295			}
296			}
297			}
298			}
299

XOOPS / XoopsCore25

Pull Request — master (#325)

PublicSuffixList::parsePSL() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like