XMLWriter - Code Metrics - Inspection of "Some fixes for issues find in Scrutinizer" - wszetko/sitemap - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b82f61...793471 )

by Paweł

created 2019-09-09 19:39 UTC

XMLWriter B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	319
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	0
loc	319
ccs	0
cts	182
cp	0
rs	8.72
c	0
b	0
f	0
wmc	46
lcom	1
cbo	1

22 Methods

Rating	Name	Size	Complexity
A	__construct()	10	2
A	getDomain()	4	1
A	setDomain()	4	1
A	getCurrentSitemap()	4	1
A	setCurrentSitemap()	4	1
A	openSitemap()	15	2
A	getXMLWriter()	4	1
A	flushData()	4	1
A	getSitemapFileFullPath()	4	1
A	getWorkDir()	4	1
A	setWorkDir()	4	1
A	closeSitemap()	7	1
A	endFile()	26	4
A	getSitemapSize()	6	2
A	addUrl()	8	2
A	addElement()	12	4
A	addElementArray()	12	4
B	addElementArrayAssoc()	28	10
A	addElementArrayNonAssoc()	6	2
A	openSitemapIndex()	10	1
A	closeSitemapIndex()	7	1
A	addSitemap()	10	2

How to fix Complexity

<?php
declare(strict_types=1);

namespace Wszetko\Sitemap\Drivers\XML;

use Exception;
use Wszetko\Sitemap\Interfaces\XML;
use Wszetko\Sitemap\Sitemap;
use Wszetko\Sitemap\Traits\IsAssoc;

/**
 * Class XMLWriter
 *
 * @package Wszetko\Sitemap\Drivers\XML
 */
class XMLWriter implements XML
{
    use IsAssoc;

    /**
     * @var \XMLWriter
     */
    private $XMLWriter;

    /**
     * @var string
     */
    private $currentSitemap;

    /**
     * @var string
     */
    private $workDir;

    /**
     * @var string
     */
    private $domain;

    /**
     * XMLWriter constructor.
     *
     * @param array $config
     *
     * @throws \Exception
     */
    public function __construct(array $config)
    {
        $this->XMLWriter = new \XMLWriter();

        if (!isset($config['domain'])) {
            throw new Exception('Domain is not set.');
        }

        $this->setDomain($config['domain']);
    }

    /**
     * @return string
     */
    public function getDomain(): string
    {
        return $this->domain;
    }

    /**
     * @param string $domain
     */
    public function setDomain(string $domain): void
    {
        $this->domain = $domain;
    }

    /**
     * @return string
     */
    public function getCurrentSitemap(): string
    {
        return $this->currentSitemap;
    }

    /**
     * @param string $currentSitemap
     */
    public function setCurrentSitemap(string $currentSitemap): void
    {
        $this->currentSitemap = $currentSitemap;
    }

    /**
     * @param string $sitemap
     * @param array  $extensions
     */
    public function openSitemap(string $sitemap, array $extensions = []): void
    {
        $this->setCurrentSitemap($sitemap);
        $this->getXMLWriter()->openMemory();
        $this->getXMLWriter()->startDocument('1.0', 'UTF-8');
        $this->getXMLWriter()->setIndent(true);
        $this->getXMLWriter()->startElement('urlset');
        $this->getXMLWriter()->writeAttribute('xmlns', Sitemap::SCHEMA);

        foreach ($extensions as $extension => $urlset) {
            $this->getXMLWriter()->writeAttribute('xmlns:' . $extension, $urlset);
        }

        $this->flushData();
    }

    /**
     * @return \XMLWriter
     */
    private function getXMLWriter(): \XMLWriter
    {
        return $this->XMLWriter;
    }

    /**
     * Save from buffer to file
     *
     * @return void
     */
    private function flushData(): void
    {
        file_put_contents($this->getSitemapFileFullPath(), $this->getXMLWriter()->flush(true), FILE_APPEND);
    }

    /**
     * @return string
     */
    private function getSitemapFileFullPath(): string
    {
        return $this->getWorkDir() . DIRECTORY_SEPARATOR . $this->currentSitemap;
    }

    /**
     * @return string
     */
    public function getWorkDir(): string
    {
        return $this->workDir;
    }

    /**
     * @param string $dir
     */
    public function setWorkDir(string $dir): void
    {
        $this->workDir = $dir;
    }

    /**
     * @throws \Exception
     */
    public function closeSitemap(): void
    {
        $this->getXMLWriter()->endElement();
        $this->getXMLWriter()->endDocument();
        $this->flushData();
        $this->endFile();
    }

    /**
     * Remove whitespace chars from end of file (Google don't like them)
     *
     * @return void
     * @throws Exception
     */
    private function endFile(): void
    {
        $sitemapFile = fopen($this->getSitemapFileFullPath(), 'r+');

        if ($sitemapFile === false) {
            throw new Exception("Unable to open file.");
        }

        fseek($sitemapFile, -1, SEEK_END);
        $truncate = 0;
        $length = $this->getSitemapSize();
        $end = false;

        do {
            $s = fread($sitemapFile, 1);
            if (ctype_space($s)) {
                $truncate++;
                fseek($sitemapFile, -2, SEEK_CUR);
            } else {
                $end = true;
            }
        } while (!$end);

        ftruncate($sitemapFile, $length - $truncate);
        fclose($sitemapFile);
    }

    /**
     * @return int
     */
    public function getSitemapSize(): int
    {
        clearstatcache(true, $this->getSitemapFileFullPath());

        return file_exists($this->getSitemapFileFullPath()) ? filesize($this->getSitemapFileFullPath()) : 0;
    }

    /**
     * @param array $element
     */
    public function addUrl(array $element): void
    {
        foreach ($element as $el => $val) {
            $this->addElement($el, $val);
        }

        $this->flushData();
    }

    /**
     * @param string      $element
     * @param             $value
     * @param string|null $namespace
     */
    private function addElement(string $element, $value, ?string $namespace = null): void
    {
        if (!is_array($value)) {
            $this->getXMLWriter()->writeElement(($namespace ? $namespace . ':' : '') . $element, (string) $value);
        } else {
            if (isset($value['_namespace'])) {
                $this->addElement($value['_element'], $value[$value['_element']], $value['_namespace']);
            } else {
                $this->addElementArray($element, $value, $namespace);
            }
        }
    }

    /**
     * @param string      $element
     * @param             $value
     * @param string|null $namespace
     */
    private function addElementArray(string $element, $value, ?string $namespace = null): void
    {
        if (!$this->isAssoc($value)) {
            if (!empty($value)) {
                $this->addElementArrayNonAssoc($element, $value, $namespace);
            } else {
                $this->getXMLWriter()->writeElement(($namespace ? $namespace . ':' : '') . $element);
            }
        } else {
            $this->addElementArrayAssoc($element, $value, $namespace);
        }
    }

    private function addElementArrayAssoc(string $element, $value, ?string $namespace = null): void
    {
        $this->getXMLWriter()->startElement(($namespace ? $namespace . ':' : '') . $element);
        if (isset($value['_attributes'])) {
            foreach ($value['_attributes'] as $attribute => $val) {
                $this->getXMLWriter()->writeAttribute($attribute, $val);
            }

            if (isset($value['_value'])) {
                if (is_array($value['_value'])) {
                    foreach ($value['_value'] as $el => $val) {
                        $this->addElement($el, $val);
                    }
                } else {
                    $this->getXMLWriter()->text((string) $value['_value']);
                }
            }
        } else {
            foreach ($value as $el => $val) {
                if (is_array($val)) {
                    $this->addElement($el, $val, $namespace);
                } else {
                    $this->getXMLWriter()->writeElement(($namespace ? $namespace . ':' : '') . $el, (string) $val);
                }
            }
        }
        $this->getXMLWriter()->endElement();
    }

    /**
     * @param string      $element
     * @param             $value
     * @param string|null $namespace
     */
    private function addElementArrayNonAssoc(string $element, $value, ?string $namespace = null): void
    {
        foreach ($value as $val) {
            $this->addElement($element, $val, $namespace);
        }
    }

    /**
     * @param string $sitemap
     */
    public function openSitemapIndex(string $sitemap): void
    {
        $this->setCurrentSitemap($sitemap);
        $this->getXMLWriter()->openMemory();
        $this->getXMLWriter()->startDocument('1.0', 'UTF-8');
        $this->getXMLWriter()->setIndent(true);
        $this->getXMLWriter()->startElement('sitemapindex');
        $this->getXMLWriter()->writeAttribute('xmlns', Sitemap::SCHEMA);
        $this->flushData();
    }

    /**
     * @throws \Exception
     */
    public function closeSitemapIndex(): void
    {
        $this->getXMLWriter()->endElement();
        $this->getXMLWriter()->endDocument();
        $this->flushData();
        $this->endFile();
    }

    /**
     * @param string $sitemap
     * @param string|null $lastmod
     */
    public function addSitemap(string $sitemap, string $lastmod = null): void
    {
        $this->getXMLWriter()->startElement('sitemap');
        $this->getXMLWriter()->writeElement('loc', $sitemap);
        if (isset($lastmod)) {
            $this->getXMLWriter()->writeElement('lastmod', $lastmod);
        }
        $this->getXMLWriter()->endElement();
        $this->flushData();
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Wszetko\Sitemap\Drivers\XML;
5
6			use Exception;
7			use Wszetko\Sitemap\Interfaces\XML;
8			use Wszetko\Sitemap\Sitemap;
9			use Wszetko\Sitemap\Traits\IsAssoc;
10
11			/**
12			* Class XMLWriter
13			*
14			* @package Wszetko\Sitemap\Drivers\XML
15			*/
16			class XMLWriter implements XML
17			{
18			use IsAssoc;
19
20			/**
21			* @var \XMLWriter
22			*/
23			private $XMLWriter;
24
25			/**
26			* @var string
27			*/
28			private $currentSitemap;
29
30			/**
31			* @var string
32			*/
33			private $workDir;
34
35			/**
36			* @var string
37			*/
38			private $domain;
39
40			/**
41			* XMLWriter constructor.
42			*
43			* @param array $config
44			*
45			* @throws \Exception
46			*/
47			public function __construct(array $config)
48			{
49			$this->XMLWriter = new \XMLWriter();
50
51			if (!isset($config['domain'])) {
52			throw new Exception('Domain is not set.');
53			}
54
55			$this->setDomain($config['domain']);
56			}
57
58			/**
59			* @return string
60			*/
61			public function getDomain(): string
62			{
63			return $this->domain;
64			}
65
66			/**
67			* @param string $domain
68			*/
69			public function setDomain(string $domain): void
70			{
71			$this->domain = $domain;
72			}
73
74			/**
75			* @return string
76			*/
77			public function getCurrentSitemap(): string
78			{
79			return $this->currentSitemap;
80			}
81
82			/**
83			* @param string $currentSitemap
84			*/
85			public function setCurrentSitemap(string $currentSitemap): void
86			{
87			$this->currentSitemap = $currentSitemap;
88			}
89
90			/**
91			* @param string $sitemap
92			* @param array $extensions
93			*/
94			public function openSitemap(string $sitemap, array $extensions = []): void
95			{
96			$this->setCurrentSitemap($sitemap);
97			$this->getXMLWriter()->openMemory();
98			$this->getXMLWriter()->startDocument('1.0', 'UTF-8');
99			$this->getXMLWriter()->setIndent(true);
100			$this->getXMLWriter()->startElement('urlset');
101			$this->getXMLWriter()->writeAttribute('xmlns', Sitemap::SCHEMA);
102
103			foreach ($extensions as $extension => $urlset) {
104			$this->getXMLWriter()->writeAttribute('xmlns:' . $extension, $urlset);
105			}
106
107			$this->flushData();
108			}
109
110			/**
111			* @return \XMLWriter
112			*/
113			private function getXMLWriter(): \XMLWriter
114			{
115			return $this->XMLWriter;
116			}
117
118			/**
119			* Save from buffer to file
120			*
121			* @return void
122			*/
123			private function flushData(): void
124			{
125			file_put_contents($this->getSitemapFileFullPath(), $this->getXMLWriter()->flush(true), FILE_APPEND);
126			}
127
128			/**
129			* @return string
130			*/
131			private function getSitemapFileFullPath(): string
132			{
133			return $this->getWorkDir() . DIRECTORY_SEPARATOR . $this->currentSitemap;
134			}
135
136			/**
137			* @return string
138			*/
139			public function getWorkDir(): string
140			{
141			return $this->workDir;
142			}
143
144			/**
145			* @param string $dir
146			*/
147			public function setWorkDir(string $dir): void
148			{
149			$this->workDir = $dir;
150			}
151
152			/**
153			* @throws \Exception
154			*/
155			public function closeSitemap(): void
156			{
157			$this->getXMLWriter()->endElement();
158			$this->getXMLWriter()->endDocument();
159			$this->flushData();
160			$this->endFile();
161			}
162
163			/**
164			* Remove whitespace chars from end of file (Google don't like them)
165			*
166			* @return void
167			* @throws Exception
168			*/
169			private function endFile(): void
170			{
171			$sitemapFile = fopen($this->getSitemapFileFullPath(), 'r+');
172
173			if ($sitemapFile === false) {
174			throw new Exception("Unable to open file.");
175			}
176
177			fseek($sitemapFile, -1, SEEK_END);
178			$truncate = 0;
179			$length = $this->getSitemapSize();
180			$end = false;
181
182			do {
183			$s = fread($sitemapFile, 1);
184			if (ctype_space($s)) {
185			$truncate++;
186			fseek($sitemapFile, -2, SEEK_CUR);
187			} else {
188			$end = true;
189			}
190			} while (!$end);
191
192			ftruncate($sitemapFile, $length - $truncate);
193			fclose($sitemapFile);
194			}
195
196			/**
197			* @return int
198			*/
199			public function getSitemapSize(): int
200			{
201			clearstatcache(true, $this->getSitemapFileFullPath());
202
203			return file_exists($this->getSitemapFileFullPath()) ? filesize($this->getSitemapFileFullPath()) : 0;
204			}
205
206			/**
207			* @param array $element
208			*/
209			public function addUrl(array $element): void
210			{
211			foreach ($element as $el => $val) {
212			$this->addElement($el, $val);
213			}
214
215			$this->flushData();
216			}
217
218			/**
219			* @param string $element
220			* @param $value
221			* @param string\|null $namespace
222			*/
223			private function addElement(string $element, $value, ?string $namespace = null): void
224			{
225			if (!is_array($value)) {
226			$this->getXMLWriter()->writeElement(($namespace ? $namespace . ':' : '') . $element, (string) $value);
227			} else {
228			if (isset($value['_namespace'])) {
229			$this->addElement($value['_element'], $value[$value['_element']], $value['_namespace']);
230			} else {
231			$this->addElementArray($element, $value, $namespace);
232			}
233			}
234			}
235
236			/**
237			* @param string $element
238			* @param $value
239			* @param string\|null $namespace
240			*/
241			private function addElementArray(string $element, $value, ?string $namespace = null): void
242			{
243			if (!$this->isAssoc($value)) {
244			if (!empty($value)) {
245			$this->addElementArrayNonAssoc($element, $value, $namespace);
246			} else {
247			$this->getXMLWriter()->writeElement(($namespace ? $namespace . ':' : '') . $element);
248			}
249			} else {
250			$this->addElementArrayAssoc($element, $value, $namespace);
251			}
252			}
253
254			private function addElementArrayAssoc(string $element, $value, ?string $namespace = null): void
255			{
256			$this->getXMLWriter()->startElement(($namespace ? $namespace . ':' : '') . $element);
257			if (isset($value['_attributes'])) {
258			foreach ($value['_attributes'] as $attribute => $val) {
259			$this->getXMLWriter()->writeAttribute($attribute, $val);
260			}
261
262			if (isset($value['_value'])) {
263			if (is_array($value['_value'])) {
264			foreach ($value['_value'] as $el => $val) {
265			$this->addElement($el, $val);
266			}
267			} else {
268			$this->getXMLWriter()->text((string) $value['_value']);
269			}
270			}
271			} else {
272			foreach ($value as $el => $val) {
273			if (is_array($val)) {
274			$this->addElement($el, $val, $namespace);
275			} else {
276			$this->getXMLWriter()->writeElement(($namespace ? $namespace . ':' : '') . $el, (string) $val);
277			}
278			}
279			}
280			$this->getXMLWriter()->endElement();
281			}
282
283			/**
284			* @param string $element
285			* @param $value
286			* @param string\|null $namespace
287			*/
288			private function addElementArrayNonAssoc(string $element, $value, ?string $namespace = null): void
289			{
290			foreach ($value as $val) {
291			$this->addElement($element, $val, $namespace);
292			}
293			}
294
295			/**
296			* @param string $sitemap
297			*/
298			public function openSitemapIndex(string $sitemap): void
299			{
300			$this->setCurrentSitemap($sitemap);
301			$this->getXMLWriter()->openMemory();
302			$this->getXMLWriter()->startDocument('1.0', 'UTF-8');
303			$this->getXMLWriter()->setIndent(true);
304			$this->getXMLWriter()->startElement('sitemapindex');
305			$this->getXMLWriter()->writeAttribute('xmlns', Sitemap::SCHEMA);
306			$this->flushData();
307			}
308
309			/**
310			* @throws \Exception
311			*/
312			public function closeSitemapIndex(): void
313			{
314			$this->getXMLWriter()->endElement();
315			$this->getXMLWriter()->endDocument();
316			$this->flushData();
317			$this->endFile();
318			}
319
320			/**
321			* @param string $sitemap
322			* @param string\|null $lastmod
323			*/
324			public function addSitemap(string $sitemap, string $lastmod = null): void
325			{
326			$this->getXMLWriter()->startElement('sitemap');
327			$this->getXMLWriter()->writeElement('loc', $sitemap);
328			if (isset($lastmod)) {
329			$this->getXMLWriter()->writeElement('lastmod', $lastmod);
330			}
331			$this->getXMLWriter()->endElement();
332			$this->flushData();
333			}
334			}
335

wszetko / sitemap

Push — master ( b82f61...793471 )

XMLWriter B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

22 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like