WriterMultiSheetsAbstract::closeWriter() - Code Metrics - Inspection of "Not just another custom column widths PR" - box/spout - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#715)

unknown

created 2021-05-26 18:04 UTC

WriterMultiSheetsAbstract::closeWriter() A

↳ Parent: WriterMultiSheetsAbstract

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0
crap	2

<?php

namespace Box\Spout\Writer;

use Box\Spout\Common\Creator\HelperFactory;
use Box\Spout\Common\Entity\Row;
use Box\Spout\Common\Exception\IOException;
use Box\Spout\Common\Helper\GlobalFunctionsHelper;
use Box\Spout\Common\Manager\OptionsManagerInterface;
use Box\Spout\Writer\Common\Creator\ManagerFactoryInterface;
use Box\Spout\Writer\Common\Entity\Options;
use Box\Spout\Writer\Common\Entity\Sheet;
use Box\Spout\Writer\Common\Entity\Worksheet;
use Box\Spout\Writer\Common\Manager\WorkbookManagerInterface;
use Box\Spout\Writer\Exception\SheetNotFoundException;
use Box\Spout\Writer\Exception\WriterAlreadyOpenedException;
use Box\Spout\Writer\Exception\WriterNotOpenedException;

/**
 * Class WriterMultiSheetsAbstract
 *
 * @abstract
 */
abstract class WriterMultiSheetsAbstract extends WriterAbstract
{
    /** @var ManagerFactoryInterface */
    private $managerFactory;

    /** @var WorkbookManagerInterface */
    private $workbookManager;

    /**
     * @param OptionsManagerInterface $optionsManager
     * @param GlobalFunctionsHelper $globalFunctionsHelper
     * @param HelperFactory $helperFactory
     * @param ManagerFactoryInterface $managerFactory
     */
    public function __construct(
        OptionsManagerInterface $optionsManager,
        GlobalFunctionsHelper $globalFunctionsHelper,
        HelperFactory $helperFactory,
        ManagerFactoryInterface $managerFactory
    ) {
        parent::__construct($optionsManager, $globalFunctionsHelper, $helperFactory);
        $this->managerFactory = $managerFactory;
    }

    /**
     * Sets whether new sheets should be automatically created when the max rows limit per sheet is reached.
     * This must be set before opening the writer.
     *
     * @param bool $shouldCreateNewSheetsAutomatically Whether new sheets should be automatically created when the max rows limit per sheet is reached
     * @throws WriterAlreadyOpenedException If the writer was already opened
     * @return WriterMultiSheetsAbstract
     */
    public function setShouldCreateNewSheetsAutomatically($shouldCreateNewSheetsAutomatically)
    {
        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');

        $this->optionsManager->setOption(
            Options::SHOULD_CREATE_NEW_SHEETS_AUTOMATICALLY,
            $shouldCreateNewSheetsAutomatically
        );

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    protected function openWriter()
    {
        if (!$this->workbookManager) {
            $this->workbookManager = $this->managerFactory->createWorkbookManager($this->optionsManager);
            $this->workbookManager->addNewSheetAndMakeItCurrent();
        }
    }

    /**
     * Returns all the workbook's sheets
     *
     * @throws WriterNotOpenedException If the writer has not been opened yet
     * @return Sheet[] All the workbook's sheets
     */
    public function getSheets()
    {
        $this->throwIfWorkbookIsNotAvailable();

        $externalSheets = [];
        $worksheets = $this->workbookManager->getWorksheets();

        /** @var Worksheet $worksheet */
        foreach ($worksheets as $worksheet) {
            $externalSheets[] = $worksheet->getExternalSheet();
        }

        return $externalSheets;
    }

    /**
     * Creates a new sheet and make it the current sheet. The data will now be written to this sheet.
     *
     * @throws IOException
     * @throws WriterNotOpenedException If the writer has not been opened yet
     * @return Sheet The created sheet
     */
    public function addNewSheetAndMakeItCurrent()
    {
        $this->throwIfWorkbookIsNotAvailable();
        $worksheet = $this->workbookManager->addNewSheetAndMakeItCurrent();

        return $worksheet->getExternalSheet();
    }

    /**
     * Returns the current sheet
     *
     * @throws WriterNotOpenedException If the writer has not been opened yet
     * @return Sheet The current sheet
     */
    public function getCurrentSheet()
    {
        $this->throwIfWorkbookIsNotAvailable();

        return $this->workbookManager->getCurrentWorksheet()->getExternalSheet();
    }

    /**
     * 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 sheet to set as current
     * @throws SheetNotFoundException If the given sheet does not exist in the workbook
     * @throws WriterNotOpenedException If the writer has not been opened yet
     * @return void
     */
    public function setCurrentSheet($sheet)
    {
        $this->throwIfWorkbookIsNotAvailable();
        $this->workbookManager->setCurrentSheet($sheet);
    }

    /**
     * @param float $width
     * @throws WriterAlreadyOpenedException
     */
    public function setDefaultColumnWidth(float $width)
    {
        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
        $this->optionsManager->setOption(
            Options::DEFAULT_COLUMN_WIDTH,
            $width
        );
    }

    /**
     * @param float $height
     * @throws WriterAlreadyOpenedException
     */
    public function setDefaultRowHeight(float $height)
    {
        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
        $this->optionsManager->setOption(
            Options::DEFAULT_ROW_HEIGHT,
            $height
        );
    }

    /**
     * @param float|null $width
     * @param array $columns One or more columns with this width
     * @throws WriterNotOpenedException
     */
    public function setColumnWidth($width, ...$columns)
    {
        $this->throwIfWorkbookIsNotAvailable();
        $this->workbookManager->setColumnWidth($width, ...$columns);
    }

    /**
     * @param float $width The width to set
     * @param int $start First column index of the range
     * @param int $end Last column index of the range
     * @throws WriterNotOpenedException
     */
    public function setColumnWidthForRange(float $width, int $start, int $end)
    {
        $this->throwIfWorkbookIsNotAvailable();
        $this->workbookManager->setColumnWidthForRange($width, $start, $end);
    }

    /**
     * Checks if the workbook has been created. Throws an exception if not created yet.
     *
     * @throws WriterNotOpenedException If the workbook is not created yet
     * @return void
     */
    protected function throwIfWorkbookIsNotAvailable()
    {
        if (empty($this->workbookManager) || !$this->workbookManager->getWorkbook()) {
            throw new WriterNotOpenedException('The writer must be opened before performing this action.');
        }
    }

    /**
     * {@inheritdoc}
     *
     * @throws Exception\WriterException
     */
    protected function addRowToWriter(Row $row)
    {
        $this->throwIfWorkbookIsNotAvailable();
        $this->workbookManager->addRowToCurrentWorksheet($row);
    }

    /**
     * {@inheritdoc}
     */
    protected function closeWriter()
    {
        if ($this->workbookManager) {
            $this->workbookManager->close($this->filePointer);
        }
    }
}


1		<?php
2
3		namespace Box\Spout\Writer;
4
5		use Box\Spout\Common\Creator\HelperFactory;
6		use Box\Spout\Common\Entity\Row;
7		use Box\Spout\Common\Exception\IOException;
8		use Box\Spout\Common\Helper\GlobalFunctionsHelper;
9		use Box\Spout\Common\Manager\OptionsManagerInterface;
10		use Box\Spout\Writer\Common\Creator\ManagerFactoryInterface;
11		use Box\Spout\Writer\Common\Entity\Options;
12		use Box\Spout\Writer\Common\Entity\Sheet;
13		use Box\Spout\Writer\Common\Entity\Worksheet;
14		use Box\Spout\Writer\Common\Manager\WorkbookManagerInterface;
15		use Box\Spout\Writer\Exception\SheetNotFoundException;
16		use Box\Spout\Writer\Exception\WriterAlreadyOpenedException;
17		use Box\Spout\Writer\Exception\WriterNotOpenedException;
18
19		/**
20		* Class WriterMultiSheetsAbstract
21		*
22		* @abstract
23		*/
24		abstract class WriterMultiSheetsAbstract extends WriterAbstract
25		{
26		/** @var ManagerFactoryInterface */
27		private $managerFactory;
28
29		/** @var WorkbookManagerInterface */
30		private $workbookManager;
31
32		/**
33		* @param OptionsManagerInterface $optionsManager
34		* @param GlobalFunctionsHelper $globalFunctionsHelper
35		* @param HelperFactory $helperFactory
36		* @param ManagerFactoryInterface $managerFactory
37		*/
38	107	public function __construct(
39		OptionsManagerInterface $optionsManager,
40		GlobalFunctionsHelper $globalFunctionsHelper,
41		HelperFactory $helperFactory,
42		ManagerFactoryInterface $managerFactory
43		) {
44	107	parent::__construct($optionsManager, $globalFunctionsHelper, $helperFactory);
45	107	$this->managerFactory = $managerFactory;
46	107	}
47
48		/**
49		* Sets whether new sheets should be automatically created when the max rows limit per sheet is reached.
50		* This must be set before opening the writer.
51		*
52		* @param bool $shouldCreateNewSheetsAutomatically Whether new sheets should be automatically created when the max rows limit per sheet is reached
53		* @throws WriterAlreadyOpenedException If the writer was already opened
54		* @return WriterMultiSheetsAbstract
55		*/
56	35	public function setShouldCreateNewSheetsAutomatically($shouldCreateNewSheetsAutomatically)
57		{
58	35	$this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
59
60	33	$this->optionsManager->setOption(
61	33	Options::SHOULD_CREATE_NEW_SHEETS_AUTOMATICALLY,
62		$shouldCreateNewSheetsAutomatically
63		);
64
65	33	return $this;
66		}
67
68		/**
69		* {@inheritdoc}
70		*/
71	93	protected function openWriter()
72		{
73	93	if (!$this->workbookManager) {
74	93	$this->workbookManager = $this->managerFactory->createWorkbookManager($this->optionsManager);
75	93	$this->workbookManager->addNewSheetAndMakeItCurrent();
76		}
77	93	}
78
79		/**
80		* Returns all the workbook's sheets
81		*
82		* @throws WriterNotOpenedException If the writer has not been opened yet
83		* @return Sheet[] All the workbook's sheets
84		*/
85	14	public function getSheets()
86		{
87	14	$this->throwIfWorkbookIsNotAvailable();
88
89	14	$externalSheets = [];
90	14	$worksheets = $this->workbookManager->getWorksheets();
91
92		/** @var Worksheet $worksheet */
93	14	foreach ($worksheets as $worksheet) {
94	14	$externalSheets[] = $worksheet->getExternalSheet();
95		}
96
97	14	return $externalSheets;
98		}
99
100		/**
101		* Creates a new sheet and make it the current sheet. The data will now be written to this sheet.
102		*
103		* @throws IOException
104		* @throws WriterNotOpenedException If the writer has not been opened yet
105		* @return Sheet The created sheet
106		*/
107	15	public function addNewSheetAndMakeItCurrent()
108		{
109	15	$this->throwIfWorkbookIsNotAvailable();
110	15	$worksheet = $this->workbookManager->addNewSheetAndMakeItCurrent();
111
112	15	return $worksheet->getExternalSheet();
113		}
114
115		/**
116		* Returns the current sheet
117		*
118		* @throws WriterNotOpenedException If the writer has not been opened yet
119		* @return Sheet The current sheet
120		*/
121	10	public function getCurrentSheet()
122		{
123	10	$this->throwIfWorkbookIsNotAvailable();
124
125	10	return $this->workbookManager->getCurrentWorksheet()->getExternalSheet();
126		}
127
128		/**
129		* Sets the given sheet as the current one. New data will be written to this sheet.
130		* The writing will resume where it stopped (i.e. data won't be truncated).
131		*
132		* @param Sheet $sheet The sheet to set as current
133		* @throws SheetNotFoundException If the given sheet does not exist in the workbook
134		* @throws WriterNotOpenedException If the writer has not been opened yet
135		* @return void
136		*/
137	4	public function setCurrentSheet($sheet)
138		{
139	4	$this->throwIfWorkbookIsNotAvailable();
140	4	$this->workbookManager->setCurrentSheet($sheet);
141	4	}
142
143		/**
144		* @param float $width
145		* @throws WriterAlreadyOpenedException
146		*/
147	3	public function setDefaultColumnWidth(float $width)
148		{
149	3	$this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
150	3	$this->optionsManager->setOption(
151	3	Options::DEFAULT_COLUMN_WIDTH,
152		$width
153		);
154	3	}
155
156		/**
157		* @param float $height
158		* @throws WriterAlreadyOpenedException
159		*/
160	2	public function setDefaultRowHeight(float $height)
161		{
162	2	$this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
163	2	$this->optionsManager->setOption(
164	2	Options::DEFAULT_ROW_HEIGHT,
165		$height
166		);
167	2	}
168
169		/**
170		* @param float\|null $width
171		* @param array $columns One or more columns with this width
172		* @throws WriterNotOpenedException
173		*/
174	6	public function setColumnWidth($width, ...$columns)
175		{
176	6	$this->throwIfWorkbookIsNotAvailable();
177	6	$this->workbookManager->setColumnWidth($width, ...$columns);
178	6	}
179
180		/**
181		* @param float $width The width to set
182		* @param int $start First column index of the range
183		* @param int $end Last column index of the range
184		* @throws WriterNotOpenedException
185		*/
186	2	public function setColumnWidthForRange(float $width, int $start, int $end)
187		{
188	2	$this->throwIfWorkbookIsNotAvailable();
189	2	$this->workbookManager->setColumnWidthForRange($width, $start, $end);
190	2	}
191
192		/**
193		* Checks if the workbook has been created. Throws an exception if not created yet.
194		*
195		* @throws WriterNotOpenedException If the workbook is not created yet
196		* @return void
197		*/
198	87	protected function throwIfWorkbookIsNotAvailable()
199		{
200	87	if (empty($this->workbookManager) \|\| !$this->workbookManager->getWorkbook()) {
201		throw new WriterNotOpenedException('The writer must be opened before performing this action.');
202		}
203	87	}
204
205		/**
206		* {@inheritdoc}
207		*
208		* @throws Exception\WriterException
209		*/
210	81	protected function addRowToWriter(Row $row)
211		{
212	81	$this->throwIfWorkbookIsNotAvailable();
213	81	$this->workbookManager->addRowToCurrentWorksheet($row);
214	79	}
215
216		/**
217		* {@inheritdoc}
218		*/
219	86	protected function closeWriter()
220		{
221	86	if ($this->workbookManager) {
222	86	$this->workbookManager->close($this->filePointer);
223		}
224	86	}
225		}
226

box / spout

Pull Request — master (#715)

WriterMultiSheetsAbstract::closeWriter() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like