Refactor writers for better DI (#427)

This commit is a big refactor that improves the code organization.
It focuses on how dependencies are injected into the different classes. This is now done via some factories.

Also, the code is now built around entities (data model that only exposes getters and setters), managers (used to manage an entity) and helpers (used by the managers to perform some specific tasks).

The refactoring is not fully complete, as some dependencies are still hidden...

src/Spout/Writer/XLSX/Factory/InternalFactory.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Factory;
+
+use Box\Spout\Common\Escaper;
+use Box\Spout\Common\Helper\StringHelper;
+use Box\Spout\Writer\Common\Manager\OptionsManagerInterface;
+use Box\Spout\Writer\Common\Options;
+use Box\Spout\Writer\Factory\EntityFactory;
+use Box\Spout\Writer\Factory\InternalFactoryInterface;
+use Box\Spout\Writer\Factory\WorkbookFactory;
+use Box\Spout\Writer\Factory\WorksheetFactory;
+use Box\Spout\Writer\XLSX\Helper\FileSystemHelper;
+use Box\Spout\Writer\XLSX\Helper\SharedStringsHelper;
+use Box\Spout\Writer\XLSX\Helper\StyleHelper;
+use Box\Spout\Writer\XLSX\Manager\WorkbookManager;
+use Box\Spout\Writer\XLSX\Manager\WorksheetManager;
+
+/**
+ * Class InternalFactory
+ * Factory for all useful types of objects needed by the XLSX Writer
+ *
+ * @package Box\Spout\Writer\XLSX\Factory
+ */
+class InternalFactory implements InternalFactoryInterface
+{
+    /** @var EntityFactory */
+    private $entityFactory;
+
+    /**
+     * InternalFactory constructor.
+     *
+     * @param EntityFactory $entityFactory
+     */
+    public function __construct(EntityFactory $entityFactory)
+    {
+        $this->entityFactory = $entityFactory;
+    }
+
+    /**
+     * @param OptionsManagerInterface $optionsManager
+     * @return WorkbookManager
+     */
+    public function createWorkbookManager(OptionsManagerInterface $optionsManager)
+    {
+        $workbook = $this->entityFactory->createWorkbook();
+
+        $fileSystemHelper = $this->createFileSystemHelper($optionsManager);
+        $fileSystemHelper->createBaseFilesAndFolders();
+
+        $xlFolder = $fileSystemHelper->getXlFolder();
+        $sharedStringsHelper = $this->createSharedStringsHelper($xlFolder);
+
+        $styleHelper = $this->createStyleHelper($optionsManager);
+
+        $worksheetManager = $this->createWorksheetManager($optionsManager, $sharedStringsHelper, $styleHelper);
+
+        return new WorkbookManager($workbook, $optionsManager, $worksheetManager, $styleHelper, $fileSystemHelper, $this->entityFactory);
+    }
+
+    /**
+     * @param OptionsManagerInterface $optionsManager
+     * @param SharedStringsHelper $sharedStringsHelper
+     * @param StyleHelper $styleHelper
+     * @return WorksheetManager
+     */
+    private function createWorksheetManager(
+        OptionsManagerInterface $optionsManager,
+        SharedStringsHelper $sharedStringsHelper,
+        StyleHelper $styleHelper
+    )
+    {
+        $stringsEscaper = $this->createStringsEscaper();
+        $stringsHelper = $this->createStringHelper();
+
+        return new WorksheetManager($optionsManager, $sharedStringsHelper, $styleHelper, $stringsEscaper, $stringsHelper);
+    }
+
+    /**
+     * @param string $xlFolder Path to the "xl" folder
+     * @return SharedStringsHelper
+     */
+    private function createSharedStringsHelper($xlFolder)
+    {
+        return new SharedStringsHelper($xlFolder);
+    }
+
+    /**
+     * @param OptionsManagerInterface $optionsManager
+     * @return FileSystemHelper
+     */
+    private function createFileSystemHelper(OptionsManagerInterface $optionsManager)
+    {
+        $tempFolder = $optionsManager->getOption(Options::TEMP_FOLDER);
+        return new FileSystemHelper($tempFolder);
+    }
+
+    /**
+     * @param OptionsManagerInterface $optionsManager
+     * @return StyleHelper
+     */
+    private function createStyleHelper(OptionsManagerInterface $optionsManager)
+    {
+        $defaultRowStyle = $optionsManager->getOption(Options::DEFAULT_ROW_STYLE);
+        return new StyleHelper($defaultRowStyle);
+    }
+
+    /**
+     * @return Escaper\XLSX
+     */
+    private function createStringsEscaper()
+    {
+        return Escaper\XLSX::getInstance();
+    }
+
+    /**
+     * @return StringHelper
+     */
+    private function createStringHelper()
+    {
+        return new StringHelper();
+    }
+}

src/Spout/Writer/XLSX/Helper/FileSystemHelper.php

@@ -2,8 +2,9 @@
 
 namespace Box\Spout\Writer\XLSX\Helper;
 
+use Box\Spout\Writer\Common\Helper\FileSystemWithRootFolderHelperInterface;
 use Box\Spout\Writer\Common\Helper\ZipHelper;
-use Box\Spout\Writer\XLSX\Internal\Worksheet;
+use Box\Spout\Writer\Entity\Worksheet;
 
 /**
  * Class FileSystemHelper
@@ -12,7 +13,7 @@ use Box\Spout\Writer\XLSX\Internal\Worksheet;
  *
  * @package Box\Spout\Writer\XLSX\Helper
  */
-class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
+class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper implements FileSystemWithRootFolderHelperInterface
 {
     const APP_NAME = 'Spout';
 
@@ -30,22 +31,22 @@ class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
     const STYLES_XML_FILE_NAME = 'styles.xml';
 
     /** @var string Path to the root folder inside the temp folder where the files to create the XLSX will be stored */
-    protected $rootFolder;
+    private $rootFolder;
 
     /** @var string Path to the "_rels" folder inside the root folder */
-    protected $relsFolder;
+    private $relsFolder;
 
     /** @var string Path to the "docProps" folder inside the root folder */
-    protected $docPropsFolder;
+    private $docPropsFolder;
 
     /** @var string Path to the "xl" folder inside the root folder */
-    protected $xlFolder;
+    private $xlFolder;
 
     /** @var string Path to the "_rels" folder inside the "xl" folder */
-    protected $xlRelsFolder;
+    private $xlRelsFolder;
 
     /** @var string Path to the "worksheets" folder inside the "xl" folder */
-    protected $xlWorksheetsFolder;
+    private $xlWorksheetsFolder;
 
     /**
      * @return string
@@ -92,7 +93,7 @@ class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
      */
-    protected function createRootFolder()
+    private function createRootFolder()
     {
         $this->rootFolder = $this->createFolder($this->baseFolderRealPath, uniqid('xlsx', true));
         return $this;
@@ -104,7 +105,7 @@ class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder or the ".rels" file
      */
-    protected function createRelsFolderAndFile()
+    private function createRelsFolderAndFile()
     {
         $this->relsFolder = $this->createFolder($this->rootFolder, self::RELS_FOLDER_NAME);
 
@@ -119,7 +120,7 @@ class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
      */
-    protected function createRelsFile()
+    private function createRelsFile()
     {
         $relsFileContents = <<<EOD
 <?xml version="1.0" encoding="UTF-8"?>
@@ -141,7 +142,7 @@ EOD;
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder or one of the files
      */
-    protected function createDocPropsFolderAndFiles()
+    private function createDocPropsFolderAndFiles()
     {
         $this->docPropsFolder = $this->createFolder($this->rootFolder, self::DOC_PROPS_FOLDER_NAME);
 
@@ -157,7 +158,7 @@ EOD;
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
      */
-    protected function createAppXmlFile()
+    private function createAppXmlFile()
     {
         $appName = self::APP_NAME;
         $appXmlFileContents = <<<EOD
@@ -179,7 +180,7 @@ EOD;
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
      */
-    protected function createCoreXmlFile()
+    private function createCoreXmlFile()
     {
         $createdDate = (new \DateTime())->format(\DateTime::W3C);
         $coreXmlFileContents = <<<EOD
@@ -202,7 +203,7 @@ EOD;
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the folders
      */
-    protected function createXlFolderAndSubFolders()
+    private function createXlFolderAndSubFolders()
     {
         $this->xlFolder = $this->createFolder($this->rootFolder, self::XL_FOLDER_NAME);
         $this->createXlRelsFolder();
@@ -217,7 +218,7 @@ EOD;
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
      */
-    protected function createXlRelsFolder()
+    private function createXlRelsFolder()
     {
         $this->xlRelsFolder = $this->createFolder($this->xlFolder, self::RELS_FOLDER_NAME);
         return $this;
@@ -229,7 +230,7 @@ EOD;
      * @return FileSystemHelper
      * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
      */
-    protected function createXlWorksheetsFolder()
+    private function createXlWorksheetsFolder()
     {
         $this->xlWorksheetsFolder = $this->createFolder($this->xlFolder, self::WORKSHEETS_FOLDER_NAME);
         return $this;

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

@@ -2,7 +2,7 @@
 
 namespace Box\Spout\Writer\XLSX\Helper;
 
-use Box\Spout\Writer\Common\Helper\AbstractStyleHelper;
+use Box\Spout\Writer\Common\Helper\StyleHelperAbstract;
 use Box\Spout\Writer\Style\Color;
 use Box\Spout\Writer\Style\Style;
 
@@ -12,7 +12,7 @@ use Box\Spout\Writer\Style\Style;
  *
  * @package Box\Spout\Writer\XLSX\Helper
  */
-class StyleHelper extends AbstractStyleHelper
+class StyleHelper extends StyleHelperAbstract
 {
     /**
      * @var array

src/Spout/Writer/XLSX/Internal/Workbook.php

@@ -1,135 +0,0 @@
-<?php
-
-namespace Box\Spout\Writer\XLSX\Internal;
-
-use Box\Spout\Writer\Common\Internal\AbstractWorkbook;
-use Box\Spout\Writer\Common\Manager\OptionsManagerInterface;
-use Box\Spout\Writer\Common\Options;
-use Box\Spout\Writer\XLSX\Helper\FileSystemHelper;
-use Box\Spout\Writer\XLSX\Helper\SharedStringsHelper;
-use Box\Spout\Writer\XLSX\Helper\StyleHelper;
-use Box\Spout\Writer\Common\Sheet;
-use Box\Spout\Writer\XLSX\Manager\OptionsManager;
-
-/**
- * Class Workbook
- * Represents a workbook within a XLSX file.
- * It provides the functions to work with worksheets.
- *
- * @package Box\Spout\Writer\XLSX\Internal
- */
-class Workbook extends AbstractWorkbook
-{
-    /**
-     * Maximum number of rows a XLSX sheet can contain
-     * @see http://office.microsoft.com/en-us/excel-help/excel-specifications-and-limits-HP010073849.aspx
-     */
-    protected static $maxRowsPerWorksheet = 1048576;
-
-    /** @var bool Whether inline or shared strings should be used */
-    protected $shouldUseInlineStrings;
-
-    /** @var \Box\Spout\Writer\XLSX\Helper\FileSystemHelper Helper to perform file system operations */
-    protected $fileSystemHelper;
-
-    /** @var \Box\Spout\Writer\XLSX\Helper\SharedStringsHelper Helper to write shared strings */
-    protected $sharedStringsHelper;
-
-    /** @var \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to apply styles */
-    protected $styleHelper;
-
-    /**
-     * @param \Box\Spout\Writer\Common\Manager\OptionsManagerInterface $optionsManager Options manager
-     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the base folders
-     */
-    public function __construct(OptionsManagerInterface $optionsManager)
-    {
-        parent::__construct($optionsManager);
-
-        $tempFolder = $optionsManager->getOption(Options::TEMP_FOLDER);
-        $this->fileSystemHelper = new FileSystemHelper($tempFolder);
-        $this->fileSystemHelper->createBaseFilesAndFolders();
-
-        $defaultRowStyle = $optionsManager->getOption(Options::DEFAULT_ROW_STYLE);
-        $this->styleHelper = new StyleHelper($defaultRowStyle);
-
-        // This helper will be shared by all sheets
-        $xlFolder = $this->fileSystemHelper->getXlFolder();
-        $this->sharedStringsHelper = new SharedStringsHelper($xlFolder);
-    }
-
-    /**
-     * @return \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to apply styles to XLSX files
-     */
-    protected function getStyleHelper()
-    {
-        return $this->styleHelper;
-    }
-
-    /**
-     * @return int Maximum number of rows/columns a sheet can contain
-     */
-    protected function getMaxRowsPerWorksheet()
-    {
-        return self::$maxRowsPerWorksheet;
-    }
-
-    /**
-     * Creates a new sheet in the workbook. The current sheet remains unchanged.
-     *
-     * @return Worksheet The created sheet
-     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
-     */
-    public function addNewSheet()
-    {
-        $newSheetIndex = count($this->worksheets);
-        $sheet = new Sheet($newSheetIndex, $this->internalId);
-
-        $worksheetFilesFolder = $this->fileSystemHelper->getXlWorksheetsFolder();
-        $worksheet = new Worksheet($sheet, $worksheetFilesFolder, $this->sharedStringsHelper, $this->styleHelper, $this->optionManager);
-        $this->worksheets[] = $worksheet;
-
-        return $worksheet;
-    }
-
-    /**
-     * Closes the workbook and all its associated sheets.
-     * All the necessary files are written to disk and zipped together to create the XLSX file.
-     * All the temporary files are then deleted.
-     *
-     * @param resource $finalFilePointer Pointer to the XLSX that will be created
-     * @return void
-     */
-    public function close($finalFilePointer)
-    {
-        /** @var Worksheet[] $worksheets */
-        $worksheets = $this->worksheets;
-
-        foreach ($worksheets as $worksheet) {
-            $worksheet->close();
-        }
-
-        $this->sharedStringsHelper->close();
-
-        // Finish creating all the necessary files before zipping everything together
-        $this->fileSystemHelper
-            ->createContentTypesFile($worksheets)
-            ->createWorkbookFile($worksheets)
-            ->createWorkbookRelsFile($worksheets)
-            ->createStylesFile($this->styleHelper)
-            ->zipRootFolderAndCopyToStream($finalFilePointer);
-
-        $this->cleanupTempFolder();
-    }
-
-    /**
-     * Deletes the root folder created in the temp folder and all its contents.
-     *
-     * @return void
-     */
-    protected function cleanupTempFolder()
-    {
-        $xlsxRootFolder = $this->fileSystemHelper->getRootFolder();
-        $this->fileSystemHelper->deleteFolderRecursively($xlsxRootFolder);
-    }
-}

src/Spout/Writer/XLSX/Manager/WorkbookManager.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Manager;
+
+use Box\Spout\Writer\Common\Sheet;
+use Box\Spout\Writer\Manager\WorkbookManagerAbstract;
+use Box\Spout\Writer\XLSX\Helper\FileSystemHelper;
+use Box\Spout\Writer\XLSX\Helper\StyleHelper;
+
+/**
+ * Class WorkbookManager
+ * XLSX workbook manager, providing the interfaces to work with workbook.
+ *
+ * @package Box\Spout\Writer\XLSX\Manager
+ */
+class WorkbookManager extends WorkbookManagerAbstract
+{
+    /**
+     * Maximum number of rows a XLSX sheet can contain
+     * @see http://office.microsoft.com/en-us/excel-help/excel-specifications-and-limits-HP010073849.aspx
+     */
+    protected static $maxRowsPerWorksheet = 1048576;
+
+    /** @var WorksheetManager Object used to manage worksheets */
+    protected $worksheetManager;
+
+    /** @var FileSystemHelper Helper to perform file system operations */
+    protected $fileSystemHelper;
+
+    /** @var StyleHelper Helper to apply styles */
+    protected $styleHelper;
+
+    /**
+     * @return int Maximum number of rows/columns a sheet can contain
+     */
+    protected function getMaxRowsPerWorksheet()
+    {
+        return self::$maxRowsPerWorksheet;
+    }
+
+    /**
+     * @param Sheet $sheet
+     * @return string The file path where the data for the given sheet will be stored
+     */
+    public function getWorksheetFilePath(Sheet $sheet)
+    {
+        $worksheetFilesFolder = $this->fileSystemHelper->getXlWorksheetsFolder();
+        return $worksheetFilesFolder . '/' . strtolower($sheet->getName()) . '.xml';
+    }
+
+    /**
+     * Closes custom objects that are still opened
+     *
+     * @return void
+     */
+    protected function closeRemainingObjects()
+    {
+        $this->worksheetManager->getSharedStringsHelper()->close();
+    }
+
+    /**
+     * Writes all the necessary files to disk and zip them together to create the final file.
+     *
+     * @param resource $finalFilePointer Pointer to the spreadsheet that will be created
+     * @return void
+     */
+    protected function writeAllFilesToDiskAndZipThem($finalFilePointer)
+    {
+        $worksheets = $this->getWorksheets();
+
+        $this->fileSystemHelper
+            ->createContentTypesFile($worksheets)
+            ->createWorkbookFile($worksheets)
+            ->createWorkbookRelsFile($worksheets)
+            ->createStylesFile($this->styleHelper)
+            ->zipRootFolderAndCopyToStream($finalFilePointer);
+    }
+}

src/Spout/Writer/XLSX/Manager/WorksheetManager.php

@@ -1,24 +1,27 @@
 <?php
 
-namespace Box\Spout\Writer\XLSX\Internal;
+namespace Box\Spout\Writer\XLSX\Manager;
 
 use Box\Spout\Common\Exception\InvalidArgumentException;
 use Box\Spout\Common\Exception\IOException;
 use Box\Spout\Common\Helper\StringHelper;
 use Box\Spout\Writer\Common\Cell;
 use Box\Spout\Writer\Common\Helper\CellHelper;
-use Box\Spout\Writer\Common\Internal\WorksheetInterface;
 use Box\Spout\Writer\Common\Manager\OptionsManagerInterface;
 use Box\Spout\Writer\Common\Options;
+use Box\Spout\Writer\Entity\Worksheet;
+use Box\Spout\Writer\Manager\WorksheetManagerInterface;
+use Box\Spout\Writer\Style\Style;
+use Box\Spout\Writer\XLSX\Helper\SharedStringsHelper;
+use Box\Spout\Writer\XLSX\Helper\StyleHelper;
 
 /**
- * Class Worksheet
- * Represents a worksheet within a XLSX file. The difference with the Sheet object is
- * that this class provides an interface to write data
+ * Class WorksheetManager
+ * XLSX worksheet manager, providing the interfaces to work with XLSX worksheets.
  *
- * @package Box\Spout\Writer\XLSX\Internal
+ * @package Box\Spout\Writer\XLSX\Manager
  */
-class Worksheet implements WorksheetInterface
+class WorksheetManager implements WorksheetManagerInterface
 {
     /**
      * Maximum number of characters a cell can contain
@@ -33,126 +36,103 @@ class Worksheet implements WorksheetInterface
 <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
 EOD;
 
-    /** @var \Box\Spout\Writer\Common\Sheet The "external" sheet */
-    protected $externalSheet;
-
-    /** @var string Path to the XML file that will contain the sheet data */
-    protected $worksheetFilePath;
-
-    /** @var \Box\Spout\Writer\XLSX\Helper\SharedStringsHelper Helper to write shared strings */
-    protected $sharedStringsHelper;
-
-    /** @var \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to work with styles */
-    protected $styleHelper;
-
     /** @var bool Whether inline or shared strings should be used */
     protected $shouldUseInlineStrings;
 
+    /** @var SharedStringsHelper Helper to write shared strings */
+    private $sharedStringsHelper;
+
+    /** @var StyleHelper Helper to work with styles */
+    private $styleHelper;
+
     /** @var \Box\Spout\Common\Escaper\XLSX Strings escaper */
-    protected $stringsEscaper;
+    private $stringsEscaper;
 
-    /** @var \Box\Spout\Common\Helper\StringHelper String helper */
-    protected $stringHelper;
-
-    /** @var Resource Pointer to the sheet data file (e.g. xl/worksheets/sheet1.xml) */
-    protected $sheetFilePointer;
-
-    /** @var int Index of the last written row */
-    protected $lastWrittenRowIndex = 0;
+    /** @var StringHelper String helper */
+    private $stringHelper;
 
     /**
-     * @param \Box\Spout\Writer\Common\Sheet $externalSheet The associated "external" sheet
-     * @param string $worksheetFilesFolder Temporary folder where the files to create the XLSX will be stored
-     * @param \Box\Spout\Writer\XLSX\Helper\SharedStringsHelper $sharedStringsHelper Helper for shared strings
-     * @param \Box\Spout\Writer\XLSX\Helper\StyleHelper $styleHelper Helper to work with styles
-     * @param \Box\Spout\Writer\Common\Manager\OptionsManagerInterface $optionsManager Options manager
-     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     * WorksheetManager constructor.
+     *
+     * @param OptionsManagerInterface $optionsManager
+     * @param SharedStringsHelper $sharedStringsHelper
+     * @param StyleHelper $styleHelper
+     * @param \Box\Spout\Common\Escaper\XLSX $stringsEscaper
+     * @param StringHelper $stringHelper
      */
-    public function __construct($externalSheet, $worksheetFilesFolder, $sharedStringsHelper, $styleHelper, OptionsManagerInterface $optionsManager)
+    public function __construct(
+        OptionsManagerInterface $optionsManager,
+        SharedStringsHelper $sharedStringsHelper,
+        StyleHelper $styleHelper,
+        \Box\Spout\Common\Escaper\XLSX $stringsEscaper,
+        StringHelper $stringHelper)
     {
-        $this->externalSheet = $externalSheet;
+        $this->shouldUseInlineStrings = $optionsManager->getOption(Options::SHOULD_USE_INLINE_STRINGS);
         $this->sharedStringsHelper = $sharedStringsHelper;
         $this->styleHelper = $styleHelper;
-        $this->shouldUseInlineStrings = $optionsManager->getOption(Options::SHOULD_USE_INLINE_STRINGS);
-
-        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
-        $this->stringsEscaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
-        $this->stringHelper = new StringHelper();
-
-        $this->worksheetFilePath = $worksheetFilesFolder . '/' . strtolower($this->externalSheet->getName()) . '.xml';
-        $this->startSheet();
+        $this->stringsEscaper = $stringsEscaper;
+        $this->stringHelper = $stringHelper;
     }
 
+    /**
+     * @return SharedStringsHelper
+     */
+    public function getSharedStringsHelper()
+    {
+        return $this->sharedStringsHelper;
+    }
+
+
     /**
      * Prepares the worksheet to accept data
      *
+     * @param Worksheet $worksheet The worksheet to start
      * @return void
      * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
      */
-    protected function startSheet()
+    public function startSheet(Worksheet $worksheet)
     {
-        $this->sheetFilePointer = fopen($this->worksheetFilePath, 'w');
-        $this->throwIfSheetFilePointerIsNotAvailable();
+        $sheetFilePointer = fopen($worksheet->getFilePath(), 'w');
+        $this->throwIfSheetFilePointerIsNotAvailable($sheetFilePointer);
 
-        fwrite($this->sheetFilePointer, self::SHEET_XML_FILE_HEADER);
-        fwrite($this->sheetFilePointer, '<sheetData>');
+        $worksheet->setFilePointer($sheetFilePointer);
+
+        fwrite($sheetFilePointer, self::SHEET_XML_FILE_HEADER);
+        fwrite($sheetFilePointer, '<sheetData>');
     }
 
     /**
-     * Checks if the book has been created. Throws an exception if not created yet.
+     * Checks if the sheet has been sucessfully created. Throws an exception if not.
      *
+     * @param bool|resource $sheetFilePointer Pointer to the sheet data file or FALSE if unable to open the file
      * @return void
-     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     * @throws IOException If the sheet data file cannot be opened for writing
      */
-    protected function throwIfSheetFilePointerIsNotAvailable()
+    private function throwIfSheetFilePointerIsNotAvailable($sheetFilePointer)
     {
-        if (!$this->sheetFilePointer) {
+        if (!$sheetFilePointer) {
             throw new IOException('Unable to open sheet for writing.');
         }
     }
 
     /**
-     * @return \Box\Spout\Writer\Common\Sheet The "external" sheet
-     */
-    public function getExternalSheet()
-    {
-        return $this->externalSheet;
-    }
-
-    /**
-     * @return int The index of the last written row
-     */
-    public function getLastWrittenRowIndex()
-    {
-        return $this->lastWrittenRowIndex;
-    }
-
-    /**
-     * @return int The ID of the worksheet
-     */
-    public function getId()
-    {
-        // sheet index is zero-based, while ID is 1-based
-        return $this->externalSheet->getIndex() + 1;
-    }
-
-    /**
-     * Adds data to the worksheet.
+     * Adds data to the given worksheet.
      *
+     * @param Worksheet $worksheet The worksheet to add the row to
      * @param array $dataRow Array containing data to be written. Cannot be empty.
      *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row. NULL means use default style.
+     * @param Style $rowStyle Style to be applied to the row. NULL means use default style.
      * @return void
-     * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
-     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     * @throws IOException If the data cannot be written
+     * @throws InvalidArgumentException If a cell value's type is not supported
      */
-    public function addRow($dataRow, $style)
+    public function addRow(Worksheet $worksheet, $dataRow, $rowStyle)
     {
         if (!$this->isEmptyRow($dataRow)) {
-            $this->addNonEmptyRow($dataRow, $style);
+            $this->addNonEmptyRow($worksheet, $dataRow, $rowStyle);
         }
 
-        $this->lastWrittenRowIndex++;
+        $worksheet->setLastWrittenRowIndex($worksheet->getLastWrittenRowIndex() + 1);
     }
 
     /**
@@ -172,6 +152,7 @@ EOD;
     /**
      * Adds non empty row to the worksheet.
      *
+     * @param Worksheet $worksheet The worksheet to add the row to
      * @param array $dataRow Array containing data to be written. Cannot be empty.
      *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
      * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row. NULL means use default style.
@@ -179,10 +160,10 @@ EOD;
      * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
      * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
      */
-    private function addNonEmptyRow($dataRow, $style)
+    private function addNonEmptyRow(Worksheet $worksheet, $dataRow, $style)
     {
         $cellNumber = 0;
-        $rowIndex = $this->lastWrittenRowIndex + 1;
+        $rowIndex = $worksheet->getLastWrittenRowIndex() + 1;
         $numCells = count($dataRow);
 
         $rowXML = '<row r="' . $rowIndex . '" spans="1:' . $numCells . '">';
@@ -194,9 +175,9 @@ EOD;
 
         $rowXML .= '</row>';
 
-        $wasWriteSuccessful = fwrite($this->sheetFilePointer, $rowXML);
+        $wasWriteSuccessful = fwrite($worksheet->getFilePointer(), $rowXML);
         if ($wasWriteSuccessful === false) {
-            throw new IOException("Unable to write data in {$this->worksheetFilePath}");
+            throw new IOException("Unable to write data in {$worksheet->getFilePath()}");
         }
     }
 
@@ -270,16 +251,19 @@ EOD;
     /**
      * Closes the worksheet
      *
+     * @param Worksheet $worksheet
      * @return void
      */
-    public function close()
+    public function close(Worksheet $worksheet)
     {
-        if (!is_resource($this->sheetFilePointer)) {
+        $worksheetFilePointer = $worksheet->getFilePointer();
+
+        if (!is_resource($worksheetFilePointer)) {
             return;
         }
 
-        fwrite($this->sheetFilePointer, '</sheetData>');
-        fwrite($this->sheetFilePointer, '</worksheet>');
-        fclose($this->sheetFilePointer);
+        fwrite($worksheetFilePointer, '</sheetData>');
+        fwrite($worksheetFilePointer, '</worksheet>');
+        fclose($worksheetFilePointer);
     }
-}
+}

src/Spout/Writer/XLSX/Writer.php

@@ -2,10 +2,8 @@
 
 namespace Box\Spout\Writer\XLSX;
 
-use Box\Spout\Writer\AbstractMultiSheetsWriter;
 use Box\Spout\Writer\Common\Options;
-use Box\Spout\Writer\Style\StyleBuilder;
-use Box\Spout\Writer\XLSX\Internal\Workbook;
+use Box\Spout\Writer\WriterMultiSheetsAbstract;
 
 /**
  * Class Writer
@@ -13,14 +11,11 @@ use Box\Spout\Writer\XLSX\Internal\Workbook;
  *
  * @package Box\Spout\Writer\XLSX
  */
-class Writer extends AbstractMultiSheetsWriter
+class Writer extends WriterMultiSheetsAbstract
 {
     /** @var string Content-Type value for the header */
     protected static $headerContentType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
 
-    /** @var Internal\Workbook The workbook for the XLSX file */
-    protected $book;
-
     /**
      * Sets a custom temporary folder for creating intermediate files/folders.
      * This must be set before opening the writer.
@@ -54,56 +49,4 @@ class Writer extends AbstractMultiSheetsWriter
         $this->optionsManager->setOption(Options::SHOULD_USE_INLINE_STRINGS, $shouldUseInlineStrings);
         return $this;
     }
-
-    /**
-     * Configures the write and sets the current sheet pointer to a new sheet.
-     *
-     * @return void
-     * @throws \Box\Spout\Common\Exception\IOException If unable to open the file for writing
-     */
-    protected function openWriter()
-    {
-        if (!$this->book) {
-            $this->book = new Workbook($this->optionsManager);
-            $this->book->addNewSheetAndMakeItCurrent();
-        }
-    }
-
-    /**
-     * @return Internal\Workbook The workbook representing the file to be written
-     */
-    protected function getWorkbook()
-    {
-        return $this->book;
-    }
-
-    /**
-     * Adds data to the currently opened writer.
-     * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
-     * with the creation of new worksheets if one worksheet has reached its maximum capicity.
-     *
-     * @param array $dataRow Array containing data to be written.
-     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
-     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row.
-     * @return void
-     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the book is not created yet
-     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
-     */
-    protected function addRowToWriter(array $dataRow, $style)
-    {
-        $this->throwIfBookIsNotAvailable();
-        $this->book->addRowToCurrentWorksheet($dataRow, $style);
-    }
-
-    /**
-     * Closes the writer, preventing any additional writing.
-     *
-     * @return void
-     */
-    protected function closeWriter()
-    {
-        if ($this->book) {
-            $this->book->close($this->filePointer);
-        }
-    }
 }