WorkbookManagerAbstract::setCurrentSheet() - Code Metrics - Inspection of "Row objects and Cell styling" - box/spout - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — develop_3.0 (#434)

by Hura

created 2017-07-31 18:58 UTC

WorkbookManagerAbstract::setCurrentSheet() A

↳ Parent: WorkbookManagerAbstract

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2.0185

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	5
cts	6
cp	0.8333
rs	9.6666
c	0
b	0
f	0
cc	2
eloc	6
nc	2
nop	1
crap	2.0185

<?php

namespace Box\Spout\Writer\Common\Manager;

use Box\Spout\Common\Exception\IOException;
use Box\Spout\Writer\Common\Helper\FileSystemWithRootFolderHelperInterface;
use Box\Spout\Writer\Common\Entity\Options;
use Box\Spout\Writer\Common\Manager\Style\StyleManagerInterface;
use Box\Spout\Writer\Common\Entity\Row;
use Box\Spout\Writer\Common\Entity\Sheet;
use Box\Spout\Writer\Common\Entity\Workbook;
use Box\Spout\Writer\Common\Entity\Worksheet;
use Box\Spout\Writer\Exception\SheetNotFoundException;
use Box\Spout\Writer\Exception\WriterException;
use Box\Spout\Writer\Common\Creator\EntityFactory;

/**
 * Class WorkbookManagerAbstract
 * Abstract workbook manager, providing the generic interfaces to work with workbook.
 *
 * @package Box\Spout\Writer\Common\Manager
 */
abstract class WorkbookManagerAbstract implements WorkbookManagerInterface
{
    /** @var Workbook The workbook to manage */
    protected $workbook;

    /** @var OptionsManagerInterface */
    protected $optionManager;

    /** @var WorksheetManagerInterface */
    protected $worksheetManager;

    /** @var StyleManagerInterface Manages styles */
    protected $styleManager;

    /** @var FileSystemWithRootFolderHelperInterface Helper to perform file system operations */
    protected $fileSystemHelper;

    /** @var EntityFactory Factory to create entities */
    protected $entityFactory;

    /** @var Worksheet The worksheet where data will be written to */
    protected $currentWorksheet;


    /**
     * @param Workbook $workbook
     * @param OptionsManagerInterface $optionsManager
     * @param WorksheetManagerInterface $worksheetManager
     * @param StyleManagerInterface $styleManager
     * @param FileSystemWithRootFolderHelperInterface $fileSystemHelper
     * @param EntityFactory $entityFactory
     */
    public function __construct(
        Workbook $workbook,
        OptionsManagerInterface $optionsManager,
        WorksheetManagerInterface $worksheetManager,
        StyleManagerInterface $styleManager,
        FileSystemWithRootFolderHelperInterface $fileSystemHelper,
        EntityFactory $entityFactory)
    {
        $this->workbook = $workbook;
        $this->optionManager = $optionsManager;
        $this->worksheetManager = $worksheetManager;
        $this->styleManager = $styleManager;
        $this->fileSystemHelper = $fileSystemHelper;
        $this->entityFactory = $entityFactory;
    }

    /**
     * @return int Maximum number of rows/columns a sheet can contain
     */
    abstract protected function getMaxRowsPerWorksheet();

    /**
     * @param Sheet $sheet
     * @return string The file path where the data for the given sheet will be stored
     */
    abstract protected function getWorksheetFilePath(Sheet $sheet);

    /**
     * @return Workbook
     */
    public function getWorkbook()
    {
        return $this->workbook;
    }

    /**
     * Creates a new sheet in the workbook and make it the current sheet.
     * The writing will resume where it stopped (i.e. data won't be truncated).
     *
     * @return Worksheet The created sheet
     * @throws IOException If unable to open the sheet for writing
     */
    public function addNewSheetAndMakeItCurrent()
    {
        $worksheet = $this->addNewSheet();
        $this->setCurrentWorksheet($worksheet);

        return $worksheet;
    }

    /**
     * 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
     */
    private function addNewSheet()
    {
        $worksheets = $this->getWorksheets();

        $newSheetIndex = count($worksheets);
        $sheet = $this->entityFactory->createSheet($newSheetIndex, $this->workbook->getInternalId());

        $worksheetFilePath = $this->getWorksheetFilePath($sheet);
        $worksheet = $this->entityFactory->createWorksheet($worksheetFilePath, $sheet);

        $this->worksheetManager->startSheet($worksheet);

        $worksheets[] = $worksheet;
        $this->workbook->setWorksheets($worksheets);

        return $worksheet;
    }

    /**
     * @return Worksheet[] All the workbook's sheets
     */
    public function getWorksheets()
    {
        return $this->workbook->getWorksheets();
    }

    /**
     * Returns the current sheet
     *
     * @return Worksheet The current sheet
     */
    public function getCurrentWorksheet()
    {
        return $this->currentWorksheet;
    }

    /**
     * Sets the given sheet as the current one. New data will be written to this sheet.
     * The writing will resume where it stopped (i.e. data won't be truncated).
     *
     * @param Sheet $sheet The "external" sheet to set as current
     * @return void
     * @throws SheetNotFoundException If the given sheet does not exist in the workbook
     */
    public function setCurrentSheet(Sheet $sheet)
    {
        $worksheet = $this->getWorksheetFromExternalSheet($sheet);
        if ($worksheet !== null) {
            $this->currentWorksheet = $worksheet;
        } else {
            throw new SheetNotFoundException('The given sheet does not exist in the workbook.');
        }
    }

    /**
     * @param Worksheet $worksheet
     * @return void
     */
    private function setCurrentWorksheet($worksheet)
    {
        $this->currentWorksheet = $worksheet;
    }

    /**
     * Returns the worksheet associated to the given external sheet.
     *
     * @param Sheet $sheet
     * @return Worksheet|null The worksheet associated to the given external sheet or null if not found.
     */
    private function getWorksheetFromExternalSheet($sheet)
    {
        $worksheetFound = null;

        foreach ($this->getWorksheets() as $worksheet) {
            if ($worksheet->getExternalSheet() === $sheet) {
                $worksheetFound = $worksheet;
                break;
            }
        }

        return $worksheetFound;
    }

    /**
     * Adds a row to the current sheet.
     * 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 Row $row The row to added
     * @return void
     * @throws IOException If trying to create a new sheet and unable to open the sheet for writing
     * @throws WriterException If unable to write data
     */
    public function addRowToCurrentWorksheet(Row $row)
    {
        $currentWorksheet = $this->getCurrentWorksheet();
        $hasReachedMaxRows = $this->hasCurrentWorkseetReachedMaxRows();

        // if we reached the maximum number of rows for the current sheet...
        if ($hasReachedMaxRows) {
            // ... continue writing in a new sheet if option set
            if ($this->optionManager->getOption(Options::SHOULD_CREATE_NEW_SHEETS_AUTOMATICALLY)) {
                $currentWorksheet = $this->addNewSheetAndMakeItCurrent();

                $this->addRowWithStyleToWorksheet($currentWorksheet, $row);
            } else {
                // otherwise, do nothing as the data won't be written anyways
            }
        } else {
            $this->addRowWithStyleToWorksheet($currentWorksheet, $row);
        }
    }

    /**
     * @return bool Whether the current worksheet has reached the maximum number of rows per sheet.
     */
    private function hasCurrentWorkseetReachedMaxRows()
    {
        $currentWorksheet = $this->getCurrentWorksheet();
        return ($currentWorksheet->getLastWrittenRowIndex() >= $this->getMaxRowsPerWorksheet());
    }

    /**
     * Adds data with the given style to the given sheet.
     *
     * @param Worksheet $worksheet Worksheet to write the row to
     * @param array $dataRow Array containing data to be written. Cannot be empty.
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
     * @return void
     * @throws WriterException If unable to write data
     */
    private function addRowWithStyleToWorksheet(Worksheet $worksheet, Row $row)
    {
        $this->worksheetManager->addRow($worksheet, $row);

        // update max num columns for the worksheet
        $currentMaxNumColumns = $worksheet->getMaxNumColumns();
        $cellsCount = count($row->getCells());
        $worksheet->setMaxNumColumns(max($currentMaxNumColumns, $cellsCount));
    }

    /**
     * Closes the workbook and all its associated sheets.
     * All the necessary files are written to disk and zipped together to create the final file.
     * All the temporary files are then deleted.
     *
     * @param resource $finalFilePointer Pointer to the spreadsheet that will be created
     * @return void
     */
    public function close($finalFilePointer)
    {
        $this->closeAllWorksheets();
        $this->closeRemainingObjects();
        $this->writeAllFilesToDiskAndZipThem($finalFilePointer);
        $this->cleanupTempFolder();
    }

    /**
     * Closes custom objects that are still opened
     *
     * @return void
     */
    protected function closeRemainingObjects()
    {
        // do nothing by default
    }

    /**
     * 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
     */
    abstract protected function writeAllFilesToDiskAndZipThem($finalFilePointer);

    /**
     * Closes all workbook's associated sheets.
     *
     * @return void
     */
    private function closeAllWorksheets()
    {
        $worksheets = $this->getWorksheets();

        foreach ($worksheets as $worksheet) {
            $this->worksheetManager->close($worksheet);
        }
    }

    /**
     * Deletes the root folder created in the temp folder and all its contents.
     *
     * @return void
     */
    protected function cleanupTempFolder()
    {
        $rootFolder = $this->fileSystemHelper->getRootFolder();
        $this->fileSystemHelper->deleteFolderRecursively($rootFolder);
    }
}


1		<?php
2
3		namespace Box\Spout\Writer\Common\Manager;
4
5		use Box\Spout\Common\Exception\IOException;
6		use Box\Spout\Writer\Common\Helper\FileSystemWithRootFolderHelperInterface;
7		use Box\Spout\Writer\Common\Entity\Options;
8		use Box\Spout\Writer\Common\Manager\Style\StyleManagerInterface;
9		use Box\Spout\Writer\Common\Entity\Row;
10		use Box\Spout\Writer\Common\Entity\Sheet;
11		use Box\Spout\Writer\Common\Entity\Workbook;
12		use Box\Spout\Writer\Common\Entity\Worksheet;
13		use Box\Spout\Writer\Exception\SheetNotFoundException;
14		use Box\Spout\Writer\Exception\WriterException;
15		use Box\Spout\Writer\Common\Creator\EntityFactory;
16
17		/**
18		* Class WorkbookManagerAbstract
19		* Abstract workbook manager, providing the generic interfaces to work with workbook.
20		*
21		* @package Box\Spout\Writer\Common\Manager
22		*/
23		abstract class WorkbookManagerAbstract implements WorkbookManagerInterface
24		{
25		/** @var Workbook The workbook to manage */
26		protected $workbook;
27
28		/** @var OptionsManagerInterface */
29		protected $optionManager;
30
31		/** @var WorksheetManagerInterface */
32		protected $worksheetManager;
33
34		/** @var StyleManagerInterface Manages styles */
35		protected $styleManager;
36
37		/** @var FileSystemWithRootFolderHelperInterface Helper to perform file system operations */
38		protected $fileSystemHelper;
39
40		/** @var EntityFactory Factory to create entities */
41		protected $entityFactory;
42
43		/** @var Worksheet The worksheet where data will be written to */
44		protected $currentWorksheet;
45
46
47		/**
48		* @param Workbook $workbook
49		* @param OptionsManagerInterface $optionsManager
50		* @param WorksheetManagerInterface $worksheetManager
51		* @param StyleManagerInterface $styleManager
52		* @param FileSystemWithRootFolderHelperInterface $fileSystemHelper
53		* @param EntityFactory $entityFactory
54		*/
55	84	public function __construct(
56		Workbook $workbook,
57		OptionsManagerInterface $optionsManager,
58		WorksheetManagerInterface $worksheetManager,
59		StyleManagerInterface $styleManager,
60		FileSystemWithRootFolderHelperInterface $fileSystemHelper,
61		EntityFactory $entityFactory)
62		{
63	84	$this->workbook = $workbook;
64	84	$this->optionManager = $optionsManager;
65	84	$this->worksheetManager = $worksheetManager;
66	84	$this->styleManager = $styleManager;
67	84	$this->fileSystemHelper = $fileSystemHelper;
68	84	$this->entityFactory = $entityFactory;
69	84	}
70
71		/**
72		* @return int Maximum number of rows/columns a sheet can contain
73		*/
74		abstract protected function getMaxRowsPerWorksheet();
75
76		/**
77		* @param Sheet $sheet
78		* @return string The file path where the data for the given sheet will be stored
79		*/
80		abstract protected function getWorksheetFilePath(Sheet $sheet);
81
82		/**
83		* @return Workbook
84		*/
85	67	public function getWorkbook()
86		{
87	67	return $this->workbook;
88		}
89
90		/**
91		* Creates a new sheet in the workbook and make it the current sheet.
92		* The writing will resume where it stopped (i.e. data won't be truncated).
93		*
94		* @return Worksheet The created sheet
95		* @throws IOException If unable to open the sheet for writing
96		*/
97	84	public function addNewSheetAndMakeItCurrent()
98		{
99	84	$worksheet = $this->addNewSheet();
100	84	$this->setCurrentWorksheet($worksheet);
101
102	84	return $worksheet;
103		}
104
105		/**
106		* Creates a new sheet in the workbook. The current sheet remains unchanged.
107		*
108		* @return Worksheet The created sheet
109		* @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
110		*/
111	84	private function addNewSheet()
112		{
113	84	$worksheets = $this->getWorksheets();
114
115	84	$newSheetIndex = count($worksheets);
116	84	$sheet = $this->entityFactory->createSheet($newSheetIndex, $this->workbook->getInternalId());
117
118	84	$worksheetFilePath = $this->getWorksheetFilePath($sheet);
119	84	$worksheet = $this->entityFactory->createWorksheet($worksheetFilePath, $sheet);
120
121	84	$this->worksheetManager->startSheet($worksheet);
122
123	84	$worksheets[] = $worksheet;
124	84	$this->workbook->setWorksheets($worksheets);
125
126	84	return $worksheet;
127		}
128
129		/**
130		* @return Worksheet[] All the workbook's sheets
131		*/
132	84	public function getWorksheets()
133		{
134	84	return $this->workbook->getWorksheets();
135		}
136
137		/**
138		* Returns the current sheet
139		*
140		* @return Worksheet The current sheet
141		*/
142	67	public function getCurrentWorksheet()
143		{
144	67	return $this->currentWorksheet;
145		}
146
147		/**
148		* Sets the given sheet as the current one. New data will be written to this sheet.
149		* The writing will resume where it stopped (i.e. data won't be truncated).
150		*
151		* @param Sheet $sheet The "external" sheet to set as current
152		* @return void
153		* @throws SheetNotFoundException If the given sheet does not exist in the workbook
154		*/
155	4	public function setCurrentSheet(Sheet $sheet)
156		{
157	4	$worksheet = $this->getWorksheetFromExternalSheet($sheet);
158	4	if ($worksheet !== null) {
159	4	$this->currentWorksheet = $worksheet;
160		} else {
161		throw new SheetNotFoundException('The given sheet does not exist in the workbook.');
162		}
163	4	}
164
165		/**
166		* @param Worksheet $worksheet
167		* @return void
168		*/
169	84	private function setCurrentWorksheet($worksheet)
170		{
171	84	$this->currentWorksheet = $worksheet;
172	84	}
173
174		/**
175		* Returns the worksheet associated to the given external sheet.
176		*
177		* @param Sheet $sheet
178		* @return Worksheet\|null The worksheet associated to the given external sheet or null if not found.
179		*/
180	4	private function getWorksheetFromExternalSheet($sheet)
181		{
182	4	$worksheetFound = null;
183
184	4	foreach ($this->getWorksheets() as $worksheet) {
185	4	if ($worksheet->getExternalSheet() === $sheet) {
186	4	$worksheetFound = $worksheet;
187	4	break;
188		}
189		}
190
191	4	return $worksheetFound;
192		}
193
194		/**
195		* Adds a row to the current sheet.
196		* If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
197		* with the creation of new worksheets if one worksheet has reached its maximum capicity.
198		*
199		* @param Row $row The row to added
200		* @return void
201		* @throws IOException If trying to create a new sheet and unable to open the sheet for writing
202		* @throws WriterException If unable to write data
203		*/
204	61	public function addRowToCurrentWorksheet(Row $row)
205		{
206	61	$currentWorksheet = $this->getCurrentWorksheet();
207	61	$hasReachedMaxRows = $this->hasCurrentWorkseetReachedMaxRows();
208
209		// if we reached the maximum number of rows for the current sheet...
210	61	if ($hasReachedMaxRows) {
211		// ... continue writing in a new sheet if option set
212	4	if ($this->optionManager->getOption(Options::SHOULD_CREATE_NEW_SHEETS_AUTOMATICALLY)) {
213	2	$currentWorksheet = $this->addNewSheetAndMakeItCurrent();
214
215	2	$this->addRowWithStyleToWorksheet($currentWorksheet, $row);
216	4	} else {
217		// otherwise, do nothing as the data won't be written anyways
218		}
219		} else {
220	61	$this->addRowWithStyleToWorksheet($currentWorksheet, $row);
221		}
222	58	}
223
224		/**
225		* @return bool Whether the current worksheet has reached the maximum number of rows per sheet.
226		*/
227	61	private function hasCurrentWorkseetReachedMaxRows()
228		{
229	61	$currentWorksheet = $this->getCurrentWorksheet();
230	61	return ($currentWorksheet->getLastWrittenRowIndex() >= $this->getMaxRowsPerWorksheet());
231		}
232
233		/**
234		* Adds data with the given style to the given sheet.
235		*
236		* @param Worksheet $worksheet Worksheet to write the row to
237		* @param array $dataRow Array containing data to be written. Cannot be empty.
		0 ignored issues – show Bug introduced 2017-05-30 10:40 UTC by Report Bug Copy Issue Report There is no parameter named `$dataRow`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
238		* Example $dataRow = ['data1', 1234, null, '', 'data5'];
239		* @return void
240		* @throws WriterException If unable to write data
241		*/
242	61	private function addRowWithStyleToWorksheet(Worksheet $worksheet, Row $row)
243		{
244	61	$this->worksheetManager->addRow($worksheet, $row);
245
246		// update max num columns for the worksheet
247	58	$currentMaxNumColumns = $worksheet->getMaxNumColumns();
248	58	$cellsCount = count($row->getCells());
249	58	$worksheet->setMaxNumColumns(max($currentMaxNumColumns, $cellsCount));
250	58	}
251
252		/**
253		* Closes the workbook and all its associated sheets.
254		* All the necessary files are written to disk and zipped together to create the final file.
255		* All the temporary files are then deleted.
256		*
257		* @param resource $finalFilePointer Pointer to the spreadsheet that will be created
258		* @return void
259		*/
260	69	public function close($finalFilePointer)
261		{
262	69	$this->closeAllWorksheets();
263	69	$this->closeRemainingObjects();
264	69	$this->writeAllFilesToDiskAndZipThem($finalFilePointer);
265	69	$this->cleanupTempFolder();
266	69	}
267
268		/**
269		* Closes custom objects that are still opened
270		*
271		* @return void
272		*/
273	34	protected function closeRemainingObjects()
274		{
275		// do nothing by default
276	34	}
277
278		/**
279		* Writes all the necessary files to disk and zip them together to create the final file.
280		*
281		* @param resource $finalFilePointer Pointer to the spreadsheet that will be created
282		* @return void
283		*/
284		abstract protected function writeAllFilesToDiskAndZipThem($finalFilePointer);
285
286		/**
287		* Closes all workbook's associated sheets.
288		*
289		* @return void
290		*/
291	69	private function closeAllWorksheets()
292		{
293	69	$worksheets = $this->getWorksheets();
294
295	69	foreach ($worksheets as $worksheet) {
296	69	$this->worksheetManager->close($worksheet);
297		}
298	69	}
299
300		/**
301		* Deletes the root folder created in the temp folder and all its contents.
302		*
303		* @return void
304		*/
305	69	protected function cleanupTempFolder()
306		{
307	69	$rootFolder = $this->fileSystemHelper->getRootFolder();
308	69	$this->fileSystemHelper->deleteFolderRecursively($rootFolder);
309	69	}
310		}
311

box / spout

Pull Request — develop_3.0 (#434)

WorkbookManagerAbstract::setCurrentSheet() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like