SharedStringsHelper::getSharedStringsUniqueCount() - Code Metrics - Inspection of "Add Performance tests" - box/spout - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — perf-tests ( 2fc93e...db6806 )

by Adrien

created 2016-07-13 15:57 UTC

SharedStringsHelper::getSharedStringsUniqueCount() B

↳ Parent: SharedStringsHelper

Complexity

Conditions	5
Paths	8

Size

Total Lines	19
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	1	Features	1

Metric	Value
c	4
b	1
f	1
dl	0
loc	19
rs	8.8571
cc	5
eloc	8
nc	8
nop	1

<?php

namespace Box\Spout\Reader\XLSX\Helper;

use Box\Spout\Common\Exception\IOException;
use Box\Spout\Reader\Exception\XMLProcessingException;
use Box\Spout\Reader\Wrapper\SimpleXMLElement;
use Box\Spout\Reader\Wrapper\XMLReader;
use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyFactory;
use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyInterface;

/**
 * Class SharedStringsHelper
 * This class provides helper functions for reading sharedStrings XML file
 *
 * @package Box\Spout\Reader\XLSX\Helper
 */
class SharedStringsHelper
{
    /** Path of sharedStrings XML file inside the XLSX file */
    const SHARED_STRINGS_XML_FILE_PATH = 'xl/sharedStrings.xml';

    /** Main namespace for the sharedStrings.xml file */
    const MAIN_NAMESPACE_FOR_SHARED_STRINGS_XML = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';

    /** @var string Path of the XLSX file being read */
    protected $filePath;

    /** @var string Temporary folder where the temporary files to store shared strings will be stored */
    protected $tempFolder;

    /** @var CachingStrategyInterface The best caching strategy for storing shared strings */
    protected $cachingStrategy;

    /**
     * @param string $filePath Path of the XLSX file being read
     * @param string|void $tempFolder Temporary folder where the temporary files to store shared strings will be stored
     */
    public function __construct($filePath, $tempFolder = null)
    {
        $this->filePath = $filePath;
        $this->tempFolder = $tempFolder;
    }

    /**
     * Returns whether the XLSX file contains a shared strings XML file
     *
     * @return bool
     */
    public function hasSharedStrings()
    {
        $hasSharedStrings = false;
        $zip = new \ZipArchive();

        if ($zip->open($this->filePath) === true) {
            $hasSharedStrings = ($zip->locateName(self::SHARED_STRINGS_XML_FILE_PATH) !== false);
            $zip->close();
        }

        return $hasSharedStrings;
    }

    /**
     * Builds an in-memory array containing all the shared strings of the sheet.
     * All the strings are stored in a XML file, located at 'xl/sharedStrings.xml'.
     * It is then accessed by the sheet data, via the string index in the built table.
     *
     * More documentation available here: http://msdn.microsoft.com/en-us/library/office/gg278314.aspx
     *
     * The XML file can be really big with sheets containing a lot of data. That is why
     * we need to use a XML reader that provides streaming like the XMLReader library.
     * Please note that SimpleXML does not provide such a functionality but since it is faster
     * and more handy to parse few XML nodes, it is used in combination with XMLReader for that purpose.
     *
     * @return void
     * @throws \Box\Spout\Common\Exception\IOException If sharedStrings.xml can't be read
     */
    public function extractSharedStrings()
    {
        $xmlReader = new XMLReader();
        $sharedStringIndex = 0;
        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
        $escaper = \Box\Spout\Common\Escaper\XLSX::getInstance();

        $sharedStringsFilePath = $this->getSharedStringsFilePath();
        if ($xmlReader->open($sharedStringsFilePath) === false) {
            throw new IOException('Could not open "' . self::SHARED_STRINGS_XML_FILE_PATH . '".');
        }

        try {
            $sharedStringsUniqueCount = $this->getSharedStringsUniqueCount($xmlReader);
            $this->cachingStrategy = $this->getBestSharedStringsCachingStrategy($sharedStringsUniqueCount);

            $xmlReader->readUntilNodeFound('si');

            while ($xmlReader->name === 'si') {
                $node = $this->getSimpleXmlElementNodeFromXMLReader($xmlReader);
                $node->registerXPathNamespace('ns', self::MAIN_NAMESPACE_FOR_SHARED_STRINGS_XML);

                // removes nodes that should not be read, like the pronunciation of the Kanji characters
                $cleanNode = $this->removeSuperfluousTextNodes($node);

                // find all text nodes "t"; there can be multiple if the cell contains formatting
                $textNodes = $cleanNode->xpath('//ns:t');

                $textValue = '';
                foreach ($textNodes as $nodeIndex => $textNode) {
                    if ($nodeIndex !== 0) {
                        // add a space between each "t" node
                        $textValue .= ' ';
                    }

                    if ($this->shouldPreserveWhitespace($textNode)) {
                        $textValue .= $textNode->__toString();
                    } else {
                        $textValue .= trim($textNode->__toString());
                    }
                }

                $unescapedTextValue = $escaper->unescape($textValue);
                $this->cachingStrategy->addStringForIndex($unescapedTextValue, $sharedStringIndex);

                $sharedStringIndex++;

                // jump to the next 'si' tag
                $xmlReader->next('si');
            }

        } catch (XMLProcessingException $exception) {
            throw new IOException("The sharedStrings.xml file is invalid and cannot be read. [{$exception->getMessage()}]");
        }

        $this->cachingStrategy->closeCache();

        $xmlReader->close();
    }

    /**
     * @return string The path to the shared strings XML file
     */
    protected function getSharedStringsFilePath()
    {
        return 'zip://' . $this->filePath . '#' . self::SHARED_STRINGS_XML_FILE_PATH;
    }

    /**
     * Returns the shared strings unique count, as specified in <sst> tag.
     *
     * @param \Box\Spout\Reader\Wrapper\XMLReader $xmlReader XMLReader instance
     * @return int|null Number of unique shared strings in the sharedStrings.xml file
     * @throws \Box\Spout\Common\Exception\IOException If sharedStrings.xml is invalid and can't be read
     */
    protected function getSharedStringsUniqueCount($xmlReader)
    {
        $xmlReader->next('sst');

        // Iterate over the "sst" elements to get the actual "sst ELEMENT" (skips any DOCTYPE)
        while ($xmlReader->name === 'sst' && $xmlReader->nodeType !== XMLReader::ELEMENT) {
            $xmlReader->read();
        }

        $uniqueCount = $xmlReader->getAttribute('uniqueCount');

        // some software do not add the "uniqueCount" attribute but only use the "count" one
        // @see https://github.com/box/spout/issues/254
        if ($uniqueCount === null) {
            $uniqueCount = $xmlReader->getAttribute('count');
        }

        return ($uniqueCount !== null) ? intval($uniqueCount) : null;
    }

    /**
     * Returns the best shared strings caching strategy.
     *
     * @param int|null $sharedStringsUniqueCount Number of unique shared strings (NULL if unknown)
     * @return CachingStrategyInterface
     */
    protected function getBestSharedStringsCachingStrategy($sharedStringsUniqueCount)
    {
        return CachingStrategyFactory::getInstance()
                ->getBestCachingStrategy($sharedStringsUniqueCount, $this->tempFolder);
    }

    /**
     * Returns a SimpleXMLElement node from the current node in the given XMLReader instance.
     * This is to simplify the parsing of the subtree.
     *
     * @param \Box\Spout\Reader\Wrapper\XMLReader $xmlReader
     * @return \Box\Spout\Reader\Wrapper\SimpleXMLElement
     * @throws \Box\Spout\Common\Exception\IOException If the current node cannot be read
     */
    protected function getSimpleXmlElementNodeFromXMLReader($xmlReader)
    {
        $node = null;
        try {
            $node = new SimpleXMLElement($xmlReader->readOuterXml());
        } catch (XMLProcessingException $exception) {
            throw new IOException("The sharedStrings.xml file contains unreadable data [{$exception->getMessage()}].");
        }

        return $node;
    }

    /**
     * Removes nodes that should not be read, like the pronunciation of the Kanji characters.
     * By keeping them, their text content would be added to the read string.
     *
     * @param \Box\Spout\Reader\Wrapper\SimpleXMLElement $parentNode Parent node that may contain nodes to remove
     * @return \Box\Spout\Reader\Wrapper\SimpleXMLElement Cleaned parent node
     */
    protected function removeSuperfluousTextNodes($parentNode)
    {
        $tagsToRemove = [
            'rPh', // Pronunciation of the text
            'pPr', // Paragraph Properties / Previous Paragraph Properties
            'rPr', // Run Properties for the Paragraph Mark / Previous Run Properties for the Paragraph Mark
        ];

        foreach ($tagsToRemove as $tagToRemove) {
            $xpath = '//ns:' . $tagToRemove;
            $parentNode->removeNodesMatchingXPath($xpath);
        }

        return $parentNode;
    }

    /**
     * If the text node has the attribute 'xml:space="preserve"', then preserve whitespace.
     *
     * @param \Box\Spout\Reader\Wrapper\SimpleXMLElement $textNode The text node element (<t>) whitespace may be preserved
     * @return bool Whether whitespace should be preserved
     */
    protected function shouldPreserveWhitespace($textNode)
    {
        $spaceValue = $textNode->getAttribute('space', 'xml');
        return ($spaceValue === 'preserve');
    }

    /**
     * Returns the shared string at the given index, using the previously chosen caching strategy.
     *
     * @param int $sharedStringIndex Index of the shared string in the sharedStrings.xml file
     * @return string The shared string at the given index
     * @throws \Box\Spout\Reader\Exception\SharedStringNotFoundException If no shared string found for the given index
     */
    public function getStringAtIndex($sharedStringIndex)
    {
        return $this->cachingStrategy->getStringAtIndex($sharedStringIndex);
    }

    /**
     * Destroys the cache, freeing memory and removing any created artifacts
     *
     * @return void
     */
    public function cleanup()
    {
        if ($this->cachingStrategy) {
            $this->cachingStrategy->clearCache();
        }
    }
}


1			<?php
2
3			namespace Box\Spout\Reader\XLSX\Helper;
4
5			use Box\Spout\Common\Exception\IOException;
6			use Box\Spout\Reader\Exception\XMLProcessingException;
7			use Box\Spout\Reader\Wrapper\SimpleXMLElement;
8			use Box\Spout\Reader\Wrapper\XMLReader;
9			use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyFactory;
10			use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyInterface;
11
12			/**
13			* Class SharedStringsHelper
14			* This class provides helper functions for reading sharedStrings XML file
15			*
16			* @package Box\Spout\Reader\XLSX\Helper
17			*/
18			class SharedStringsHelper
19			{
20			/** Path of sharedStrings XML file inside the XLSX file */
21			const SHARED_STRINGS_XML_FILE_PATH = 'xl/sharedStrings.xml';
22
23			/** Main namespace for the sharedStrings.xml file */
24			const MAIN_NAMESPACE_FOR_SHARED_STRINGS_XML = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
25
26			/** @var string Path of the XLSX file being read */
27			protected $filePath;
28
29			/** @var string Temporary folder where the temporary files to store shared strings will be stored */
30			protected $tempFolder;
31
32			/** @var CachingStrategyInterface The best caching strategy for storing shared strings */
33			protected $cachingStrategy;
34
35			/**
36			* @param string $filePath Path of the XLSX file being read
37			* @param string\|void $tempFolder Temporary folder where the temporary files to store shared strings will be stored
38			*/
39			public function __construct($filePath, $tempFolder = null)
40			{
41			$this->filePath = $filePath;
42			$this->tempFolder = $tempFolder;
43			}
44
45			/**
46			* Returns whether the XLSX file contains a shared strings XML file
47			*
48			* @return bool
49			*/
50			public function hasSharedStrings()
51			{
52			$hasSharedStrings = false;
53			$zip = new \ZipArchive();
54
55			if ($zip->open($this->filePath) === true) {
56			$hasSharedStrings = ($zip->locateName(self::SHARED_STRINGS_XML_FILE_PATH) !== false);
57			$zip->close();
58			}
59
60			return $hasSharedStrings;
61			}
62
63			/**
64			* Builds an in-memory array containing all the shared strings of the sheet.
65			* All the strings are stored in a XML file, located at 'xl/sharedStrings.xml'.
66			* It is then accessed by the sheet data, via the string index in the built table.
67			*
68			* More documentation available here: http://msdn.microsoft.com/en-us/library/office/gg278314.aspx
69			*
70			* The XML file can be really big with sheets containing a lot of data. That is why
71			* we need to use a XML reader that provides streaming like the XMLReader library.
72			* Please note that SimpleXML does not provide such a functionality but since it is faster
73			* and more handy to parse few XML nodes, it is used in combination with XMLReader for that purpose.
74			*
75			* @return void
76			* @throws \Box\Spout\Common\Exception\IOException If sharedStrings.xml can't be read
77			*/
78			public function extractSharedStrings()
79			{
80			$xmlReader = new XMLReader();
81			$sharedStringIndex = 0;
82			/** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
83			$escaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
84
85			$sharedStringsFilePath = $this->getSharedStringsFilePath();
86			if ($xmlReader->open($sharedStringsFilePath) === false) {
87			throw new IOException('Could not open "' . self::SHARED_STRINGS_XML_FILE_PATH . '".');
88			}
89
90			try {
91			$sharedStringsUniqueCount = $this->getSharedStringsUniqueCount($xmlReader);
92			$this->cachingStrategy = $this->getBestSharedStringsCachingStrategy($sharedStringsUniqueCount);
93
94			$xmlReader->readUntilNodeFound('si');
95
96			while ($xmlReader->name === 'si') {
97			$node = $this->getSimpleXmlElementNodeFromXMLReader($xmlReader);
98			$node->registerXPathNamespace('ns', self::MAIN_NAMESPACE_FOR_SHARED_STRINGS_XML);
99
100			// removes nodes that should not be read, like the pronunciation of the Kanji characters
101			$cleanNode = $this->removeSuperfluousTextNodes($node);
102
103			// find all text nodes "t"; there can be multiple if the cell contains formatting
104			$textNodes = $cleanNode->xpath('//ns:t');
105
106			$textValue = '';
107			foreach ($textNodes as $nodeIndex => $textNode) {
108			if ($nodeIndex !== 0) {
109			// add a space between each "t" node
110			$textValue .= ' ';
111			}
112
113			if ($this->shouldPreserveWhitespace($textNode)) {
114			$textValue .= $textNode->__toString();
115			} else {
116			$textValue .= trim($textNode->__toString());
117			}
118			}
119
120			$unescapedTextValue = $escaper->unescape($textValue);
121			$this->cachingStrategy->addStringForIndex($unescapedTextValue, $sharedStringIndex);
122
123			$sharedStringIndex++;
124
125			// jump to the next 'si' tag
126			$xmlReader->next('si');
127			}
128
129			} catch (XMLProcessingException $exception) {
130			throw new IOException("The sharedStrings.xml file is invalid and cannot be read. [{$exception->getMessage()}]");
131			}
132
133			$this->cachingStrategy->closeCache();
134
135			$xmlReader->close();
136			}
137
138			/**
139			* @return string The path to the shared strings XML file
140			*/
141			protected function getSharedStringsFilePath()
142			{
143			return 'zip://' . $this->filePath . '#' . self::SHARED_STRINGS_XML_FILE_PATH;
144			}
145
146			/**
147			* Returns the shared strings unique count, as specified in <sst> tag.
148			*
149			* @param \Box\Spout\Reader\Wrapper\XMLReader $xmlReader XMLReader instance
150			* @return int\|null Number of unique shared strings in the sharedStrings.xml file
151			* @throws \Box\Spout\Common\Exception\IOException If sharedStrings.xml is invalid and can't be read
152			*/
153			protected function getSharedStringsUniqueCount($xmlReader)
154			{
155			$xmlReader->next('sst');
156
157			// Iterate over the "sst" elements to get the actual "sst ELEMENT" (skips any DOCTYPE)
158			while ($xmlReader->name === 'sst' && $xmlReader->nodeType !== XMLReader::ELEMENT) {
159			$xmlReader->read();
160			}
161
162			$uniqueCount = $xmlReader->getAttribute('uniqueCount');
163
164			// some software do not add the "uniqueCount" attribute but only use the "count" one
165			// @see https://github.com/box/spout/issues/254
166			if ($uniqueCount === null) {
167			$uniqueCount = $xmlReader->getAttribute('count');
168			}
169
170			return ($uniqueCount !== null) ? intval($uniqueCount) : null;
171			}
172
173			/**
174			* Returns the best shared strings caching strategy.
175			*
176			* @param int\|null $sharedStringsUniqueCount Number of unique shared strings (NULL if unknown)
177			* @return CachingStrategyInterface
178			*/
179			protected function getBestSharedStringsCachingStrategy($sharedStringsUniqueCount)
180			{
181			return CachingStrategyFactory::getInstance()
182			->getBestCachingStrategy($sharedStringsUniqueCount, $this->tempFolder);
183			}
184
185			/**
186			* Returns a SimpleXMLElement node from the current node in the given XMLReader instance.
187			* This is to simplify the parsing of the subtree.
188			*
189			* @param \Box\Spout\Reader\Wrapper\XMLReader $xmlReader
190			* @return \Box\Spout\Reader\Wrapper\SimpleXMLElement
191			* @throws \Box\Spout\Common\Exception\IOException If the current node cannot be read
192			*/
193			protected function getSimpleXmlElementNodeFromXMLReader($xmlReader)
194			{
195			$node = null;
196			try {
197			$node = new SimpleXMLElement($xmlReader->readOuterXml());
198			} catch (XMLProcessingException $exception) {
199			throw new IOException("The sharedStrings.xml file contains unreadable data [{$exception->getMessage()}].");
200			}
201
202			return $node;
203			}
204
205			/**
206			* Removes nodes that should not be read, like the pronunciation of the Kanji characters.
207			* By keeping them, their text content would be added to the read string.
208			*
209			* @param \Box\Spout\Reader\Wrapper\SimpleXMLElement $parentNode Parent node that may contain nodes to remove
210			* @return \Box\Spout\Reader\Wrapper\SimpleXMLElement Cleaned parent node
211			*/
212			protected function removeSuperfluousTextNodes($parentNode)
213			{
214			$tagsToRemove = [
215			'rPh', // Pronunciation of the text
216			'pPr', // Paragraph Properties / Previous Paragraph Properties
217			'rPr', // Run Properties for the Paragraph Mark / Previous Run Properties for the Paragraph Mark
218			];
219
220			foreach ($tagsToRemove as $tagToRemove) {
221			$xpath = '//ns:' . $tagToRemove;
222			$parentNode->removeNodesMatchingXPath($xpath);
223			}
224
225			return $parentNode;
226			}
227
228			/**
229			* If the text node has the attribute 'xml:space="preserve"', then preserve whitespace.
230			*
231			* @param \Box\Spout\Reader\Wrapper\SimpleXMLElement $textNode The text node element (<t>) whitespace may be preserved
232			* @return bool Whether whitespace should be preserved
233			*/
234			protected function shouldPreserveWhitespace($textNode)
235			{
236			$spaceValue = $textNode->getAttribute('space', 'xml');
237			return ($spaceValue === 'preserve');
238			}
239
240			/**
241			* Returns the shared string at the given index, using the previously chosen caching strategy.
242			*
243			* @param int $sharedStringIndex Index of the shared string in the sharedStrings.xml file
244			* @return string The shared string at the given index
245			* @throws \Box\Spout\Reader\Exception\SharedStringNotFoundException If no shared string found for the given index
246			*/
247			public function getStringAtIndex($sharedStringIndex)
248			{
249			return $this->cachingStrategy->getStringAtIndex($sharedStringIndex);
250			}
251
252			/**
253			* Destroys the cache, freeing memory and removing any created artifacts
254			*
255			* @return void
256			*/
257			public function cleanup()
258			{
259			if ($this->cachingStrategy) {
260			$this->cachingStrategy->clearCache();
261			}
262			}
263			}
264

box / spout

Push — perf-tests ( 2fc93e...db6806 )

SharedStringsHelper::getSharedStringsUniqueCount() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like