Refactor readers for better di (#457)

* Refactor readers to get a proper DI

Similar to what was done with writers, readers also needed to be updated to match the new way of doing things.
This commits promotes a better DI (factories, injection through constructors).

* Escapers should not be singletons

Instead, they should be proper object that can be injected where needed.

src/Spout/Reader/XLSX/Creator/EntityFactory.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Box\Spout\Reader\XLSX\Creator;
+
+use Box\Spout\Reader\Common\Creator\EntityFactoryInterface;
+use Box\Spout\Reader\Common\XMLProcessor;
+use Box\Spout\Reader\XLSX\Helper\SharedStringsHelper;
+use Box\Spout\Reader\XLSX\RowIterator;
+use Box\Spout\Reader\XLSX\Sheet;
+use Box\Spout\Reader\XLSX\SheetIterator;
+use Box\Spout\Reader\Wrapper\XMLReader;
+
+/**
+ * Class EntityFactory
+ * Factory to create entities
+ *
+ * @package Box\Spout\Reader\XLSX\Creator
+ */
+class EntityFactory implements EntityFactoryInterface
+{
+    /** @var HelperFactory */
+    private $helperFactory;
+
+    /**
+     * @param HelperFactory $helperFactory
+     */
+    public function __construct(HelperFactory $helperFactory)
+    {
+        $this->helperFactory = $helperFactory;
+    }
+
+    /**
+     * @param string $filePath Path of the file to be read
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
+     * @param SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
+     * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
+     * @return SheetIterator
+     */
+    public function createSheetIterator($filePath, $optionsManager, $sharedStringsHelper, $globalFunctionsHelper)
+    {
+        return new SheetIterator(
+            $filePath,
+            $optionsManager,
+            $sharedStringsHelper,
+            $globalFunctionsHelper,
+            $this,
+            $this->helperFactory
+        );
+    }
+
+    /**
+     * @param string $filePath Path of the XLSX file being read
+     * @param string $sheetDataXMLFilePath Path of the sheet data XML file as in [Content_Types].xml
+     * @param int $sheetIndex Index of the sheet, based on order in the workbook (zero-based)
+     * @param string $sheetName Name of the sheet
+     * @param bool $isSheetActive Whether the sheet was defined as active
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
+     * @param SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
+     * @return Sheet
+     */
+    public function createSheet(
+        $filePath,
+        $sheetDataXMLFilePath,
+        $sheetIndex,
+        $sheetName,
+        $isSheetActive,
+        $optionsManager,
+        $sharedStringsHelper)
+    {
+        return new Sheet(
+            $filePath,
+            $sheetDataXMLFilePath,
+            $sheetIndex,
+            $sheetName,
+            $isSheetActive,
+            $optionsManager,
+            $sharedStringsHelper,
+            $this
+        );
+    }
+
+    /**
+     * @param string $filePath Path of the XLSX file being read
+     * @param string $sheetDataXMLFilePath Path of the sheet data XML file as in [Content_Types].xml
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
+     * @param SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
+     * @return RowIterator
+     */
+    public function createRowIterator($filePath, $sheetDataXMLFilePath, $optionsManager, $sharedStringsHelper)
+    {
+        return new RowIterator($filePath, $sheetDataXMLFilePath, $optionsManager, $sharedStringsHelper, $this, $this->helperFactory);
+    }
+
+    /**
+     * @return \ZipArchive
+     */
+    public function createZipArchive()
+    {
+        return new \ZipArchive();
+    }
+
+    /**
+     * @return XMLReader
+     */
+    public function createXMLReader()
+    {
+        return new XMLReader();
+    }
+
+    /**
+     * @param $xmlReader
+     * @return XMLProcessor
+     */
+    public function createXMLProcessor($xmlReader)
+    {
+        return new XMLProcessor($xmlReader);
+    }
+}

src/Spout/Reader/XLSX/Creator/HelperFactory.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Box\Spout\Reader\XLSX\Creator;
+
+use Box\Spout\Common\Helper\Escaper;
+use Box\Spout\Reader\XLSX\Helper\CellValueFormatter;
+use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyFactory;
+use Box\Spout\Reader\XLSX\Helper\SharedStringsHelper;
+use Box\Spout\Reader\XLSX\Helper\SheetHelper;
+use Box\Spout\Reader\XLSX\Helper\StyleHelper;
+
+
+/**
+ * Class EntityFactory
+ * Factory to create helpers
+ *
+ * @package Box\Spout\Reader\XLSX\Creator
+ */
+class HelperFactory extends \Box\Spout\Common\Creator\HelperFactory
+{
+    /** @var CachingStrategyFactory */
+    private $cachingStrategyFactory;
+
+    /**
+     * @param CachingStrategyFactory $cachingStrategyFactory Factory to create shared strings caching strategies
+     */
+    public function __construct(CachingStrategyFactory $cachingStrategyFactory)
+    {
+        $this->cachingStrategyFactory = $cachingStrategyFactory;
+    }
+
+    /**
+     * @param string $filePath Path of the XLSX file being read
+     * @param string $tempFolder Temporary folder where the temporary files to store shared strings will be stored
+     * @param EntityFactory $entityFactory Factory to create entities
+     * @return SharedStringsHelper
+     */
+    public function createSharedStringsHelper($filePath, $tempFolder, $entityFactory)
+    {
+        return new SharedStringsHelper($filePath, $tempFolder, $entityFactory, $this, $this->cachingStrategyFactory);
+    }
+
+    /**
+     * @param string $filePath Path of the XLSX file being read
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
+     * @param \Box\Spout\Reader\XLSX\Helper\SharedStringsHelper Helper to work with shared strings
+     * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
+     * @param EntityFactory $entityFactory Factory to create entities
+     * @return SheetHelper
+     */
+    public function createSheetHelper($filePath, $optionsManager, $sharedStringsHelper, $globalFunctionsHelper, $entityFactory)
+    {
+        $escaper = $this->createStringsEscaper();
+        return new SheetHelper($filePath, $optionsManager, $sharedStringsHelper, $globalFunctionsHelper, $escaper, $entityFactory);
+    }
+
+    /**
+     * @param string $filePath Path of the XLSX file being read
+     * @param EntityFactory $entityFactory Factory to create entities
+     * @return StyleHelper
+     */
+    public function createStyleHelper($filePath, $entityFactory)
+    {
+        return new StyleHelper($filePath, $entityFactory);
+    }
+
+    /**
+     * @param SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
+     * @param StyleHelper $styleHelper Helper to work with styles
+     * @param bool $shouldFormatDates Whether date/time values should be returned as PHP objects or be formatted as strings
+     * @return CellValueFormatter
+     */
+    public function createCellValueFormatter($sharedStringsHelper, $styleHelper, $shouldFormatDates)
+    {
+        $escaper = $this->createStringsEscaper();
+        return new CellValueFormatter($sharedStringsHelper, $styleHelper, $shouldFormatDates, $escaper);
+    }
+
+    /**
+     * @return Escaper\XLSX
+     */
+    public function createStringsEscaper()
+    {
+        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
+        return new Escaper\XLSX();
+    }
+}

src/Spout/Reader/XLSX/Helper/CellValueFormatter.php

@@ -47,22 +47,21 @@ class CellValueFormatter
     /** @var bool Whether date/time values should be returned as PHP objects or be formatted as strings */
     protected $shouldFormatDates;
 
-    /** @var \Box\Spout\Common\Escaper\XLSX Used to unescape XML data */
+    /** @var \Box\Spout\Common\Helper\Escaper\XLSX Used to unescape XML data */
     protected $escaper;
 
     /**
      * @param SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
      * @param StyleHelper $styleHelper Helper to work with styles
      * @param bool $shouldFormatDates Whether date/time values should be returned as PHP objects or be formatted as strings
+     * @param \Box\Spout\Common\Helper\Escaper\XLSX $escaper Used to unescape XML data
      */
-    public function __construct($sharedStringsHelper, $styleHelper, $shouldFormatDates)
+    public function __construct($sharedStringsHelper, $styleHelper, $shouldFormatDates, $escaper)
     {
         $this->sharedStringsHelper = $sharedStringsHelper;
         $this->styleHelper = $styleHelper;
         $this->shouldFormatDates = $shouldFormatDates;
-
-        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
-        $this->escaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
+        $this->escaper = $escaper;
     }
 
     /**

src/Spout/Reader/XLSX/Helper/SharedStringsCaching/CachingStrategyFactory.php

@@ -1,6 +1,7 @@
 <?php
 
 namespace Box\Spout\Reader\XLSX\Helper\SharedStringsCaching;
+use Box\Spout\Reader\XLSX\Creator\HelperFactory;
 
 /**
  * Class CachingStrategyFactory
@@ -50,44 +51,22 @@ class CachingStrategyFactory
      */
     const MAX_NUM_STRINGS_PER_TEMP_FILE = 10000;
 
-    /** @var CachingStrategyFactory|null Singleton instance */
-    protected static $instance = null;
-
-    /**
-     * Private constructor for singleton
-     */
-    private function __construct()
-    {
-    }
-
-    /**
-     * Returns the singleton instance of the factory
-     *
-     * @return CachingStrategyFactory
-     */
-    public static function getInstance()
-    {
-        if (self::$instance === null) {
-            self::$instance = new CachingStrategyFactory();
-        }
-
-        return self::$instance;
-    }
 
     /**
      * Returns the best caching strategy, given the number of unique shared strings
      * and the amount of memory available.
      *
      * @param int|null $sharedStringsUniqueCount Number of unique shared strings (NULL if unknown)
-     * @param string|void $tempFolder Temporary folder where the temporary files to store shared strings will be stored
+     * @param string $tempFolder Temporary folder where the temporary files to store shared strings will be stored
+     * @param HelperFactory $helperFactory Factory to create helpers
      * @return CachingStrategyInterface The best caching strategy
      */
-    public function getBestCachingStrategy($sharedStringsUniqueCount, $tempFolder = null)
+    public function createBestCachingStrategy($sharedStringsUniqueCount, $tempFolder, $helperFactory)
     {
         if ($this->isInMemoryStrategyUsageSafe($sharedStringsUniqueCount)) {
             return new InMemoryStrategy($sharedStringsUniqueCount);
         } else {
-            return new FileBasedStrategy($tempFolder, self::MAX_NUM_STRINGS_PER_TEMP_FILE);
+            return new FileBasedStrategy($tempFolder, self::MAX_NUM_STRINGS_PER_TEMP_FILE, $helperFactory);
         }
     }
 

src/Spout/Reader/XLSX/Helper/SharedStringsCaching/FileBasedStrategy.php

@@ -5,6 +5,7 @@ namespace Box\Spout\Reader\XLSX\Helper\SharedStringsCaching;
 use Box\Spout\Common\Helper\FileSystemHelper;
 use Box\Spout\Common\Helper\GlobalFunctionsHelper;
 use Box\Spout\Reader\Exception\SharedStringNotFoundException;
+use Box\Spout\Reader\XLSX\Creator\HelperFactory;
 
 /**
  * Class FileBasedStrategy
@@ -51,18 +52,18 @@ class FileBasedStrategy implements CachingStrategyInterface
     protected $inMemoryTempFileContents;
 
     /**
-     * @param string|null $tempFolder Temporary folder where the temporary files to store shared strings will be stored
+     * @param string $tempFolder Temporary folder where the temporary files to store shared strings will be stored
      * @param int $maxNumStringsPerTempFile Maximum number of strings that can be stored in one temp file
+     * @param HelperFactory $helperFactory Factory to create helpers
      */
-    public function __construct($tempFolder, $maxNumStringsPerTempFile)
+    public function __construct($tempFolder, $maxNumStringsPerTempFile, $helperFactory)
     {
-        $rootTempFolder = ($tempFolder) ?: sys_get_temp_dir();
-        $this->fileSystemHelper = new FileSystemHelper($rootTempFolder);
-        $this->tempFolder = $this->fileSystemHelper->createFolder($rootTempFolder, uniqid('sharedstrings'));
+        $this->fileSystemHelper = $helperFactory->createFileSystemHelper($tempFolder);
+        $this->tempFolder = $this->fileSystemHelper->createFolder($tempFolder, uniqid('sharedstrings'));
 
         $this->maxNumStringsPerTempFile = $maxNumStringsPerTempFile;
 
-        $this->globalFunctionsHelper = new GlobalFunctionsHelper();
+        $this->globalFunctionsHelper = $helperFactory->createGlobalFunctionsHelper();
         $this->tempFilePointer = null;
     }
 

src/Spout/Reader/XLSX/Helper/SharedStringsHelper.php

@@ -5,6 +5,8 @@ namespace Box\Spout\Reader\XLSX\Helper;
 use Box\Spout\Common\Exception\IOException;
 use Box\Spout\Reader\Exception\XMLProcessingException;
 use Box\Spout\Reader\Wrapper\XMLReader;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
+use Box\Spout\Reader\XLSX\Creator\HelperFactory;
 use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyFactory;
 use Box\Spout\Reader\XLSX\Helper\SharedStringsCaching\CachingStrategyInterface;
 
@@ -40,17 +42,32 @@ class SharedStringsHelper
     /** @var string Temporary folder where the temporary files to store shared strings will be stored */
     protected $tempFolder;
 
+    /** @var EntityFactory Factory to create entities */
+    protected $entityFactory;
+
+    /** @var HelperFactory $helperFactory Factory to create helpers */
+    protected $helperFactory;
+
+    /** @var CachingStrategyFactory Factory to create shared strings caching strategies */
+    protected $cachingStrategyFactory;
+
     /** @var CachingStrategyInterface The best caching strategy for storing shared strings */
     protected $cachingStrategy;
 
     /**
      * @param string $filePath Path of the XLSX file being read
-     * @param string|null|void $tempFolder Temporary folder where the temporary files to store shared strings will be stored
+     * @param string $tempFolder Temporary folder where the temporary files to store shared strings will be stored
+     * @param EntityFactory $entityFactory Factory to create entities
+     * @param HelperFactory $helperFactory Factory to create helpers
+     * @param CachingStrategyFactory $cachingStrategyFactory Factory to create shared strings caching strategies
      */
-    public function __construct($filePath, $tempFolder = null)
+    public function __construct($filePath, $tempFolder, $entityFactory, $helperFactory, $cachingStrategyFactory)
     {
         $this->filePath = $filePath;
         $this->tempFolder = $tempFolder;
+        $this->entityFactory = $entityFactory;
+        $this->helperFactory = $helperFactory;
+        $this->cachingStrategyFactory = $cachingStrategyFactory;
     }
 
     /**
@@ -61,7 +78,7 @@ class SharedStringsHelper
     public function hasSharedStrings()
     {
         $hasSharedStrings = false;
-        $zip = new \ZipArchive();
+        $zip = $this->entityFactory->createZipArchive();
 
         if ($zip->open($this->filePath) === true) {
             $hasSharedStrings = ($zip->locateName(self::SHARED_STRINGS_XML_FILE_PATH) !== false);
@@ -86,7 +103,7 @@ class SharedStringsHelper
      */
     public function extractSharedStrings()
     {
-        $xmlReader = new XMLReader();
+        $xmlReader = $this->entityFactory->createXMLReader();
         $sharedStringIndex = 0;
 
         if ($xmlReader->openFileInZip($this->filePath, self::SHARED_STRINGS_XML_FILE_PATH) === false) {
@@ -151,8 +168,8 @@ class SharedStringsHelper
      */
     protected function getBestSharedStringsCachingStrategy($sharedStringsUniqueCount)
     {
-        return CachingStrategyFactory::getInstance()
-                ->getBestCachingStrategy($sharedStringsUniqueCount, $this->tempFolder);
+        return $this->cachingStrategyFactory
+                ->createBestCachingStrategy($sharedStringsUniqueCount, $this->tempFolder, $this->helperFactory);
     }
 
     /**

src/Spout/Reader/XLSX/Helper/SheetHelper.php

@@ -3,6 +3,7 @@
 namespace Box\Spout\Reader\XLSX\Helper;
 
 use Box\Spout\Reader\Wrapper\XMLReader;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
 use Box\Spout\Reader\XLSX\Sheet;
 
 /**
@@ -33,8 +34,8 @@ class SheetHelper
     /** @var string Path of the XLSX file being read */
     protected $filePath;
 
-    /** @var \Box\Spout\Reader\XLSX\ReaderOptions Reader's current options */
-    protected $options;
+    /** @var \Box\Spout\Common\Manager\OptionsManagerInterface Reader's options manager */
+    protected $optionsManager;
 
     /** @var \Box\Spout\Reader\XLSX\Helper\SharedStringsHelper Helper to work with shared strings */
     protected $sharedStringsHelper;
@@ -42,18 +43,28 @@ class SheetHelper
     /** @var \Box\Spout\Common\Helper\GlobalFunctionsHelper Helper to work with global functions */
     protected $globalFunctionsHelper;
 
+    /** @var EntityFactory Factory to create entities */
+    protected $entityFactory;
+
+    /** @var \Box\Spout\Common\Helper\Escaper\XLSX Used to unescape XML data */
+    protected $escaper;
+
     /**
      * @param string $filePath Path of the XLSX file being read
-     * @param \Box\Spout\Reader\XLSX\ReaderOptions $options Reader's current options
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
      * @param \Box\Spout\Reader\XLSX\Helper\SharedStringsHelper Helper to work with shared strings
      * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
+     * @param \Box\Spout\Common\Helper\Escaper\XLSX $escaper Used to unescape XML data
+     * @param EntityFactory $entityFactory Factory to create entities
      */
-    public function __construct($filePath, $options, $sharedStringsHelper, $globalFunctionsHelper)
+    public function __construct($filePath, $optionsManager, $sharedStringsHelper, $globalFunctionsHelper, $escaper, $entityFactory)
     {
         $this->filePath = $filePath;
-        $this->options = $options;
+        $this->optionsManager = $optionsManager;
         $this->sharedStringsHelper = $sharedStringsHelper;
         $this->globalFunctionsHelper = $globalFunctionsHelper;
+        $this->escaper = $escaper;
+        $this->entityFactory = $entityFactory;
     }
 
     /**
@@ -68,7 +79,8 @@ class SheetHelper
         $sheetIndex = 0;
         $activeSheetIndex = 0; // By default, the first sheet is active
 
-        $xmlReader = new XMLReader();
+        $xmlReader = $this->entityFactory->createXMLReader();
+
         if ($xmlReader->openFileInZip($this->filePath, self::WORKBOOK_XML_FILE_PATH)) {
             while ($xmlReader->read()) {
                 if ($xmlReader->isPositionedOnStartingNode(self::XML_NODE_WORKBOOK_VIEW)) {
@@ -105,17 +117,18 @@ class SheetHelper
     {
         $sheetId = $xmlReaderOnSheetNode->getAttribute(self::XML_ATTRIBUTE_R_ID);
         $escapedSheetName = $xmlReaderOnSheetNode->getAttribute(self::XML_ATTRIBUTE_NAME);
-
-        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
-        $escaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
-        $sheetName = $escaper->unescape($escapedSheetName);
+        $sheetName = $this->escaper->unescape($escapedSheetName);
 
         $sheetDataXMLFilePath = $this->getSheetDataXMLFilePathForSheetId($sheetId);
 
-        return new Sheet(
-            $this->filePath, $sheetDataXMLFilePath,
-            $sheetIndexZeroBased, $sheetName, $isSheetActive,
-            $this->options, $this->sharedStringsHelper
+        return $this->entityFactory->createSheet(
+            $this->filePath,
+            $sheetDataXMLFilePath,
+            $sheetIndexZeroBased,
+            $sheetName,
+            $isSheetActive,
+            $this->optionsManager,
+            $this->sharedStringsHelper
         );
     }
 
@@ -128,7 +141,7 @@ class SheetHelper
         $sheetDataXMLFilePath = '';
 
         // find the file path of the sheet, by looking at the "workbook.xml.res" file
-        $xmlReader = new XMLReader();
+        $xmlReader = $this->entityFactory->createXMLReader();
         if ($xmlReader->openFileInZip($this->filePath, self::WORKBOOK_XML_RELS_FILE_PATH)) {
             while ($xmlReader->read()) {
                 if ($xmlReader->isPositionedOnStartingNode(self::XML_NODE_RELATIONSHIP)) {

src/Spout/Reader/XLSX/Helper/StyleHelper.php

@@ -2,7 +2,7 @@
 
 namespace Box\Spout\Reader\XLSX\Helper;
 
-use Box\Spout\Reader\Wrapper\XMLReader;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
 
 /**
  * Class StyleHelper
@@ -53,6 +53,9 @@ class StyleHelper
     /** @var string Path of the XLSX file being read */
     protected $filePath;
 
+    /** @var EntityFactory Factory to create entities */
+    protected $entityFactory;
+
     /** @var array Array containing the IDs of built-in number formats indicating a date */
     protected $builtinNumFmtIdIndicatingDates;
 
@@ -67,10 +70,12 @@ class StyleHelper
 
     /**
      * @param string $filePath Path of the XLSX file being read
+     * @param EntityFactory $entityFactory Factory to create entities
      */
-    public function __construct($filePath)
+    public function __construct($filePath, $entityFactory)
     {
         $this->filePath = $filePath;
+        $this->entityFactory = $entityFactory;
         $this->builtinNumFmtIdIndicatingDates = array_keys(self::$builtinNumFmtIdToNumFormatMapping);
     }
 
@@ -107,7 +112,7 @@ class StyleHelper
         $this->customNumberFormats = [];
         $this->stylesAttributes = [];
 
-        $xmlReader = new XMLReader();
+        $xmlReader = $this->entityFactory->createXMLReader();
 
         if ($xmlReader->openFileInZip($this->filePath, self::STYLES_XML_FILE_PATH)) {
             while ($xmlReader->read()) {

src/Spout/Reader/XLSX/Manager/OptionsManager.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Box\Spout\Reader\XLSX\Manager;
+
+use Box\Spout\Common\Manager\OptionsManagerAbstract;
+use Box\Spout\Reader\Common\Entity\Options;
+
+/**
+ * Class OptionsManager
+ * XLSX Reader options manager
+ *
+ * @package Box\Spout\Reader\XLSX\Manager
+ */
+class OptionsManager extends OptionsManagerAbstract
+{
+    /**
+     * @inheritdoc
+     */
+    protected function getSupportedOptions()
+    {
+        return [
+            Options::TEMP_FOLDER,
+            Options::SHOULD_FORMAT_DATES,
+            Options::SHOULD_PRESERVE_EMPTY_ROWS,
+        ];
+    }
+
+    /**
+     * @inheritdoc
+     */
+    protected function setDefaultOptions()
+    {
+        $this->setOption(Options::TEMP_FOLDER, sys_get_temp_dir());
+        $this->setOption(Options::SHOULD_FORMAT_DATES, false);
+        $this->setOption(Options::SHOULD_PRESERVE_EMPTY_ROWS, false);
+    }
+}

src/Spout/Reader/XLSX/Reader.php

@@ -3,8 +3,13 @@
 namespace Box\Spout\Reader\XLSX;
 
 use Box\Spout\Common\Exception\IOException;
-use Box\Spout\Reader\AbstractReader;
-use Box\Spout\Reader\XLSX\Helper\SharedStringsHelper;
+use Box\Spout\Common\Helper\GlobalFunctionsHelper;
+use Box\Spout\Common\Manager\OptionsManagerInterface;
+use Box\Spout\Reader\Common\Creator\EntityFactoryInterface;
+use Box\Spout\Reader\Common\Entity\Options;
+use Box\Spout\Reader\ReaderAbstract;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
+use Box\Spout\Reader\XLSX\Creator\HelperFactory;
 
 /**
  * Class Reader
@@ -12,8 +17,11 @@ use Box\Spout\Reader\XLSX\Helper\SharedStringsHelper;
  *
  * @package Box\Spout\Reader\XLSX
  */
-class Reader extends AbstractReader
+class Reader extends ReaderAbstract
 {
+    /** @var HelperFactory */
+    protected $helperFactory;
+
     /** @var \ZipArchive */
     protected $zip;
 
@@ -25,16 +33,19 @@ class Reader extends AbstractReader
 
 
     /**
-     * Returns the reader's current options
-     *
-     * @return ReaderOptions
+     * @param OptionsManagerInterface $optionsManager
+     * @param GlobalFunctionsHelper $globalFunctionsHelper
+     * @param EntityFactoryInterface $entityFactory
+     * @param HelperFactory $helperFactory
      */
-    protected function getOptions()
+    public function __construct(
+        OptionsManagerInterface $optionsManager,
+        GlobalFunctionsHelper $globalFunctionsHelper,
+        EntityFactoryInterface $entityFactory,
+        HelperFactory $helperFactory)
     {
-        if (!isset($this->options)) {
-            $this->options = new ReaderOptions();
-        }
-        return $this->options;
+        parent::__construct($optionsManager, $globalFunctionsHelper, $entityFactory);
+        $this->helperFactory = $helperFactory;
     }
 
     /**
@@ -43,7 +54,7 @@ class Reader extends AbstractReader
      */
     public function setTempFolder($tempFolder)
     {
-        $this->getOptions()->setTempFolder($tempFolder);
+        $this->optionsManager->setOption(Options::TEMP_FOLDER, $tempFolder);
         return $this;
     }
 
@@ -69,17 +80,21 @@ class Reader extends AbstractReader
      */
     protected function openReader($filePath)
     {
-        $this->zip = new \ZipArchive();
+        /** @var EntityFactory $entityFactory */
+        $entityFactory = $this->entityFactory;
+
+        $this->zip = $entityFactory->createZipArchive();
 
         if ($this->zip->open($filePath) === true) {
-            $this->sharedStringsHelper = new SharedStringsHelper($filePath, $this->getOptions()->getTempFolder());
+            $tempFolder = $this->optionsManager->getOption(Options::TEMP_FOLDER);
+            $this->sharedStringsHelper = $this->helperFactory->createSharedStringsHelper($filePath, $tempFolder, $entityFactory);
 
             if ($this->sharedStringsHelper->hasSharedStrings()) {
                 // Extracts all the strings from the sheets for easy access in the future
                 $this->sharedStringsHelper->extractSharedStrings();
             }
 
-            $this->sheetIterator = new SheetIterator($filePath, $this->getOptions(), $this->sharedStringsHelper, $this->globalFunctionsHelper);
+            $this->sheetIterator = $entityFactory->createSheetIterator($filePath, $this->optionsManager, $this->sharedStringsHelper, $this->globalFunctionsHelper);
         } else {
             throw new IOException("Could not open $filePath for reading.");
         }

src/Spout/Reader/XLSX/ReaderOptions.php

@@ -1,33 +0,0 @@
-<?php
-
-namespace Box\Spout\Reader\XLSX;
-
-/**
- * Class ReaderOptions
- * This class is used to customize the reader's behavior
- *
- * @package Box\Spout\Reader\XLSX
- */
-class ReaderOptions extends \Box\Spout\Reader\Common\ReaderOptions
-{
-    /** @var string|null Temporary folder where the temporary files will be created */
-    protected $tempFolder = null;
-
-    /**
-     * @return string|null Temporary folder where the temporary files will be created
-     */
-    public function getTempFolder()
-    {
-        return $this->tempFolder;
-    }
-
-    /**
-     * @param string|null $tempFolder Temporary folder where the temporary files will be created
-     * @return ReaderOptions
-     */
-    public function setTempFolder($tempFolder)
-    {
-        $this->tempFolder = $tempFolder;
-        return $this;
-    }
-}

src/Spout/Reader/XLSX/RowIterator.php

@@ -3,9 +3,12 @@
 namespace Box\Spout\Reader\XLSX;
 
 use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Reader\Common\Entity\Options;
 use Box\Spout\Reader\Exception\XMLProcessingException;
 use Box\Spout\Reader\IteratorInterface;
 use Box\Spout\Reader\Wrapper\XMLReader;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
+use Box\Spout\Reader\XLSX\Creator\HelperFactory;
 use Box\Spout\Reader\XLSX\Helper\CellHelper;
 use Box\Spout\Reader\XLSX\Helper\CellValueFormatter;
 use Box\Spout\Reader\XLSX\Helper\StyleHelper;
@@ -81,23 +84,25 @@ class RowIterator implements IteratorInterface
     /**
      * @param string $filePath Path of the XLSX file being read
      * @param string $sheetDataXMLFilePath Path of the sheet data XML file as in [Content_Types].xml
-     * @param \Box\Spout\Reader\XLSX\ReaderOptions $options Reader's current options
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
      * @param Helper\SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
+     * @param EntityFactory $entityFactory Factory to create entities
+     * @param HelperFactory $helperFactory Factory to create helpers
      */
-    public function __construct($filePath, $sheetDataXMLFilePath, $options, $sharedStringsHelper)
+    public function __construct($filePath, $sheetDataXMLFilePath, $optionsManager, $sharedStringsHelper, $entityFactory, $helperFactory)
     {
         $this->filePath = $filePath;
         $this->sheetDataXMLFilePath = $this->normalizeSheetDataXMLFilePath($sheetDataXMLFilePath);
 
-        $this->xmlReader = new XMLReader();
+        $this->xmlReader = $entityFactory->createXMLReader();
 
-        $this->styleHelper = new StyleHelper($filePath);
-        $this->cellValueFormatter = new CellValueFormatter($sharedStringsHelper, $this->styleHelper, $options->shouldFormatDates());
+        $this->styleHelper = $helperFactory->createStyleHelper($filePath, $entityFactory);
+        $this->cellValueFormatter = $helperFactory->createCellValueFormatter($sharedStringsHelper, $this->styleHelper, $optionsManager->getOption(Options::SHOULD_FORMAT_DATES));
 
-        $this->shouldPreserveEmptyRows = $options->shouldPreserveEmptyRows();
+        $this->shouldPreserveEmptyRows = $optionsManager->getOption(Options::SHOULD_PRESERVE_EMPTY_ROWS);
 
         // Register all callbacks to process different nodes when reading the XML file
-        $this->xmlProcessor = new XMLProcessor($this->xmlReader);
+        $this->xmlProcessor = $entityFactory->createXMLProcessor($this->xmlReader);
         $this->xmlProcessor->registerCallback(self::XML_NODE_DIMENSION, XMLProcessor::NODE_TYPE_START, [$this, 'processDimensionStartingNode']);
         $this->xmlProcessor->registerCallback(self::XML_NODE_ROW, XMLProcessor::NODE_TYPE_START, [$this, 'processRowStartingNode']);
         $this->xmlProcessor->registerCallback(self::XML_NODE_CELL, XMLProcessor::NODE_TYPE_START, [$this, 'processCellStartingNode']);

src/Spout/Reader/XLSX/Sheet.php

@@ -3,6 +3,7 @@
 namespace Box\Spout\Reader\XLSX;
 
 use Box\Spout\Reader\SheetInterface;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
 
 /**
  * Class Sheet
@@ -30,12 +31,20 @@ class Sheet implements SheetInterface
      * @param int $sheetIndex Index of the sheet, based on order in the workbook (zero-based)
      * @param string $sheetName Name of the sheet
      * @param bool $isSheetActive Whether the sheet was defined as active
-     * @param \Box\Spout\Reader\XLSX\ReaderOptions $options Reader's current options
-     * @param Helper\SharedStringsHelper Helper to work with shared strings
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
+     * @param Helper\SharedStringsHelper $sharedStringsHelper Helper to work with shared strings
+     * @param EntityFactory $entityFactory Factory to create entities
      */
-    public function __construct($filePath, $sheetDataXMLFilePath, $sheetIndex, $sheetName, $isSheetActive, $options, $sharedStringsHelper)
+    public function __construct(
+        $filePath,
+        $sheetDataXMLFilePath,
+        $sheetIndex, $sheetName,
+        $isSheetActive,
+        $optionsManager,
+        $sharedStringsHelper,
+        $entityFactory)
     {
-        $this->rowIterator = new RowIterator($filePath, $sheetDataXMLFilePath, $options, $sharedStringsHelper);
+        $this->rowIterator = $entityFactory->createRowIterator($filePath, $sheetDataXMLFilePath, $optionsManager, $sharedStringsHelper);
         $this->index = $sheetIndex;
         $this->name = $sheetName;
         $this->isActive = $isSheetActive;

src/Spout/Reader/XLSX/SheetIterator.php

@@ -3,6 +3,8 @@
 namespace Box\Spout\Reader\XLSX;
 
 use Box\Spout\Reader\IteratorInterface;
+use Box\Spout\Reader\XLSX\Creator\EntityFactory;
+use Box\Spout\Reader\XLSX\Creator\HelperFactory;
 use Box\Spout\Reader\XLSX\Helper\SheetHelper;
 use Box\Spout\Reader\Exception\NoSheetsFoundException;
 
@@ -22,15 +24,23 @@ class SheetIterator implements IteratorInterface
 
     /**
      * @param string $filePath Path of the file to be read
-     * @param \Box\Spout\Reader\XLSX\ReaderOptions $options Reader's current options
+     * @param \Box\Spout\Common\Manager\OptionsManagerInterface $optionsManager Reader's options manager
      * @param \Box\Spout\Reader\XLSX\Helper\SharedStringsHelper $sharedStringsHelper
      * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
+     * @param EntityFactory $entityFactory Factory to create entities
+     * @param HelperFactory $helperFactory Factory to create helpers
      * @throws \Box\Spout\Reader\Exception\NoSheetsFoundException If there are no sheets in the file
      */
-    public function __construct($filePath, $options, $sharedStringsHelper, $globalFunctionsHelper)
+    public function __construct(
+        $filePath,
+        $optionsManager,
+        $sharedStringsHelper,
+        $globalFunctionsHelper,
+        $entityFactory,
+        $helperFactory)
     {
         // Fetch all available sheets
-        $sheetHelper = new SheetHelper($filePath, $options, $sharedStringsHelper, $globalFunctionsHelper);
+        $sheetHelper = $helperFactory->createSheetHelper($filePath, $optionsManager, $sharedStringsHelper, $globalFunctionsHelper, $entityFactory);
         $this->sheets = $sheetHelper->getSheets();
 
         if (count($this->sheets) === 0) {