WriterAbstract::resetRowStyleToDefault() - 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 Adrien

created 2017-10-21 16:37 UTC

WriterAbstract::resetRowStyleToDefault() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

namespace Box\Spout\Writer;

use Box\Spout\Common\Creator\HelperFactory;
use Box\Spout\Common\Exception\InvalidArgumentException;
use Box\Spout\Common\Exception\IOException;
use Box\Spout\Common\Exception\SpoutException;
use Box\Spout\Common\Helper\GlobalFunctionsHelper;
use Box\Spout\Common\Manager\OptionsManagerInterface;
use Box\Spout\Writer\Common\Creator\EntityFactory;
use Box\Spout\Writer\Common\Entity\Cell;
use Box\Spout\Writer\Common\Entity\Options;
use Box\Spout\Writer\Common\Entity\Row;
use Box\Spout\Writer\Common\Entity\Style\Style;
use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
use Box\Spout\Writer\Exception\WriterAlreadyOpenedException;
use Box\Spout\Writer\Exception\WriterNotOpenedException;

/**
 * Class WriterAbstract
 *
 * @abstract
 */
abstract class WriterAbstract implements WriterInterface
{
    /** @var string Path to the output file */
    protected $outputFilePath;

    /** @var resource Pointer to the file/stream we will write to */
    protected $filePointer;

    /** @var bool Indicates whether the writer has been opened or not */
    protected $isWriterOpened = false;

    /** @var GlobalFunctionsHelper Helper to work with global functions */
    protected $globalFunctionsHelper;

    /** @var HelperFactory $helperFactory */
    protected $helperFactory;

    /** @var OptionsManagerInterface Writer options manager */
    protected $optionsManager;

    /** @var StyleMerger Helps merge styles together */
    protected $styleMerger;

    /** @var string Content-Type value for the header - to be defined by child class */
    protected static $headerContentType;

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

    /**
     * Opens the streamer and makes it ready to accept data.
     *
     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
     * @return void
     */
    abstract protected function openWriter();

    /**
     * Adds a row to the currently opened writer.
     *
     * @param Row $row The row containing cells and styles
     * @return void
     */
    abstract protected function addRowToWriter(Row $row);

    /**
     * Closes the streamer, preventing any additional writing.
     *
     * @return void
     */
    abstract protected function closeWriter();

    /**
     * Sets the default styles for all rows added with "addRow"
     *
     * @param Style $defaultStyle
     * @return WriterAbstract
     */
    public function setDefaultRowStyle($defaultStyle)
    {
        $this->optionsManager->setOption(Options::DEFAULT_ROW_STYLE, $defaultStyle);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function openToFile($outputFilePath)
    {
        $this->outputFilePath = $outputFilePath;

        $this->filePointer = $this->globalFunctionsHelper->fopen($this->outputFilePath, 'wb+');
        $this->throwIfFilePointerIsNotAvailable();

        $this->openWriter();
        $this->isWriterOpened = true;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function openToBrowser($outputFileName)
    {
        $this->outputFilePath = $this->globalFunctionsHelper->basename($outputFileName);

        $this->filePointer = $this->globalFunctionsHelper->fopen('php://output', 'w');
        $this->throwIfFilePointerIsNotAvailable();

        // Clear any previous output (otherwise the generated file will be corrupted)
        // @see https://github.com/box/spout/issues/241
        $this->globalFunctionsHelper->ob_end_clean();

        // Set headers
        $this->globalFunctionsHelper->header('Content-Type: ' . static::$headerContentType);
        $this->globalFunctionsHelper->header('Content-Disposition: attachment; filename="' . $this->outputFilePath . '"');

        /*
         * When forcing the download of a file over SSL,IE8 and lower browsers fail
         * if the Cache-Control and Pragma headers are not set.
         *
         * @see http://support.microsoft.com/KB/323308
         * @see https://github.com/liuggio/ExcelBundle/issues/45
         */
        $this->globalFunctionsHelper->header('Cache-Control: max-age=0');
        $this->globalFunctionsHelper->header('Pragma: public');

        $this->openWriter();
        $this->isWriterOpened = true;

        return $this;
    }

    /**
     * Checks if the pointer to the file/stream to write to is available.
     * Will throw an exception if not available.
     *
     * @throws \Box\Spout\Common\Exception\IOException If the pointer is not available
     * @return void
     */
    protected function throwIfFilePointerIsNotAvailable()
    {
        if (!$this->filePointer) {
            throw new IOException('File pointer has not be opened');
        }
    }

    /**
     * Checks if the writer has already been opened, since some actions must be done before it gets opened.
     * Throws an exception if already opened.
     *
     * @param string $message Error message
     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened and must not be.
     * @return void
     */
    protected function throwIfWriterAlreadyOpened($message)
    {
        if ($this->isWriterOpened) {
            throw new WriterAlreadyOpenedException($message);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function addRow(Row $row)
    {
        if ($this->isWriterOpened) {
            if ($row->hasCells()) {
                try {
                    $this->applyDefaultRowStyle($row);
                    $this->addRowToWriter($row);
                } catch (SpoutException $e) {
                    // if an exception occurs while writing data,
                    // close the writer and remove all files created so far.
                    $this->closeAndAttemptToCleanupAllFiles();

                    // re-throw the exception to alert developers of the error
                    throw $e;
                }
            }
        } else {
            throw new WriterNotOpenedException('The writer needs to be opened before adding row.');
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function withRow(\Closure $callback)
    {
        return $this->addRow($callback(EntityFactory::createRow([])));
    }

    /**
     * {@inheritdoc}
     */
    public function addRows(array $dataRows)
    {
        foreach ($dataRows as $dataRow) {
            if (!$dataRow instanceof Row) {
                $this->closeAndAttemptToCleanupAllFiles();
                throw new InvalidArgumentException();
            }

            $this->addRow($dataRow);
        }

        return $this;
    }

    /**
     * @param array $dataRow
     * @param Style|null $style
     * @return Row
     */
    protected function createRowFromArray(array $dataRow, Style $style = null)
    {
        $row = EntityFactory::createRow(array_map(function ($value) {
            if ($value instanceof Cell) {
                return $value;
            }

            return new Cell($value);
        }, $dataRow));

        if ($style !== null) {
            $row->setStyle($style);
        }

        return $row;
    }

    /**
     * @TODO: Move this into styleMerger
     *
     * @param Row $row
     * @return $this
     */
    private function applyDefaultRowStyle(Row $row)
    {
        $defaultRowStyle = $this->optionsManager->getOption(Options::DEFAULT_ROW_STYLE);
        if ($defaultRowStyle === null) {
            return $this;
        }

        $mergedStyle = $this->styleMerger->merge($row->getStyle(), $defaultRowStyle);
        $row->setStyle($mergedStyle);
    }

    /**
     * Closes the writer. This will close the streamer as well, preventing new data
     * to be written to the file.
     *
     * @return void
     */
    public function close()
    {
        if (!$this->isWriterOpened) {
            return;
        }

        $this->closeWriter();

        if (is_resource($this->filePointer)) {
            $this->globalFunctionsHelper->fclose($this->filePointer);
        }

        $this->isWriterOpened = false;
    }

    /**
     * Closes the writer and attempts to cleanup all files that were
     * created during the writing process (temp files & final file).
     *
     * @return void
     */
    private function closeAndAttemptToCleanupAllFiles()
    {
        // close the writer, which should remove all temp files
        $this->close();

        // remove output file if it was created
        if ($this->globalFunctionsHelper->file_exists($this->outputFilePath)) {
            $outputFolderPath = dirname($this->outputFilePath);
            $fileSystemHelper = $this->helperFactory->createFileSystemHelper($outputFolderPath);
            $fileSystemHelper->deleteFile($this->outputFilePath);
        }
    }
}


1		<?php
2
3		namespace Box\Spout\Writer;
4
5		use Box\Spout\Common\Creator\HelperFactory;
6		use Box\Spout\Common\Exception\InvalidArgumentException;
7		use Box\Spout\Common\Exception\IOException;
8		use Box\Spout\Common\Exception\SpoutException;
9		use Box\Spout\Common\Helper\GlobalFunctionsHelper;
10		use Box\Spout\Common\Manager\OptionsManagerInterface;
11		use Box\Spout\Writer\Common\Creator\EntityFactory;
12		use Box\Spout\Writer\Common\Entity\Cell;
13		use Box\Spout\Writer\Common\Entity\Options;
14		use Box\Spout\Writer\Common\Entity\Row;
15		use Box\Spout\Writer\Common\Entity\Style\Style;
16		use Box\Spout\Writer\Common\Manager\Style\StyleMerger;
17		use Box\Spout\Writer\Exception\WriterAlreadyOpenedException;
18		use Box\Spout\Writer\Exception\WriterNotOpenedException;
19
20		/**
21		* Class WriterAbstract
22		*
23		* @abstract
24		*/
25		abstract class WriterAbstract implements WriterInterface
26		{
27		/** @var string Path to the output file */
28		protected $outputFilePath;
29
30		/** @var resource Pointer to the file/stream we will write to */
31		protected $filePointer;
32
33		/** @var bool Indicates whether the writer has been opened or not */
34		protected $isWriterOpened = false;
35
36		/** @var GlobalFunctionsHelper Helper to work with global functions */
37		protected $globalFunctionsHelper;
38
39		/** @var HelperFactory $helperFactory */
40		protected $helperFactory;
41
42		/** @var OptionsManagerInterface Writer options manager */
43		protected $optionsManager;
44
45		/** @var StyleMerger Helps merge styles together */
46		protected $styleMerger;
47
48		/** @var string Content-Type value for the header - to be defined by child class */
49		protected static $headerContentType;
50
51		/**
52		* @param OptionsManagerInterface $optionsManager
53		* @param StyleMerger $styleMerger
54		* @param GlobalFunctionsHelper $globalFunctionsHelper
55		* @param HelperFactory $helperFactory
56		*/
57	108	public function __construct(
58		OptionsManagerInterface $optionsManager,
59		StyleMerger $styleMerger,
60		GlobalFunctionsHelper $globalFunctionsHelper,
61		HelperFactory $helperFactory
62		) {
63	108	$this->optionsManager = $optionsManager;
64	108	$this->styleMerger = $styleMerger;
65	108	$this->globalFunctionsHelper = $globalFunctionsHelper;
66	108	$this->helperFactory = $helperFactory;
67	108	}
68
69		/**
70		* Opens the streamer and makes it ready to accept data.
71		*
72		* @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
73		* @return void
74		*/
75		abstract protected function openWriter();
76
77		/**
78		* Adds a row to the currently opened writer.
79		*
80		* @param Row $row The row containing cells and styles
81		* @return void
82		*/
83		abstract protected function addRowToWriter(Row $row);
84
85		/**
86		* Closes the streamer, preventing any additional writing.
87		*
88		* @return void
89		*/
90		abstract protected function closeWriter();
91
92		/**
93		* Sets the default styles for all rows added with "addRow"
94		*
95		* @param Style $defaultStyle
96		* @return WriterAbstract
97		*/
98	2	public function setDefaultRowStyle($defaultStyle)
99		{
100	2	$this->optionsManager->setOption(Options::DEFAULT_ROW_STYLE, $defaultStyle);
101
102	2	return $this;
103		}
104
105		/**
106		* {@inheritdoc}
107		*/
108	97	public function openToFile($outputFilePath)
109		{
110	97	$this->outputFilePath = $outputFilePath;
111
112	97	$this->filePointer = $this->globalFunctionsHelper->fopen($this->outputFilePath, 'wb+');
113	97	$this->throwIfFilePointerIsNotAvailable();
114
115	94	$this->openWriter();
116	94	$this->isWriterOpened = true;
117
118	94	return $this;
119		}
120
121		/**
122		* {@inheritdoc}
123		*/
124		public function openToBrowser($outputFileName)
125		{
126		$this->outputFilePath = $this->globalFunctionsHelper->basename($outputFileName);
127
128		$this->filePointer = $this->globalFunctionsHelper->fopen('php://output', 'w');
129		$this->throwIfFilePointerIsNotAvailable();
130
131		// Clear any previous output (otherwise the generated file will be corrupted)
132		// @see https://github.com/box/spout/issues/241
133		$this->globalFunctionsHelper->ob_end_clean();
134
135		// Set headers
136		$this->globalFunctionsHelper->header('Content-Type: ' . static::$headerContentType);
137		$this->globalFunctionsHelper->header('Content-Disposition: attachment; filename="' . $this->outputFilePath . '"');
138
139		/*
140		* When forcing the download of a file over SSL,IE8 and lower browsers fail
141		* if the Cache-Control and Pragma headers are not set.
142		*
143		* @see http://support.microsoft.com/KB/323308
144		* @see https://github.com/liuggio/ExcelBundle/issues/45
145		*/
146		$this->globalFunctionsHelper->header('Cache-Control: max-age=0');
147		$this->globalFunctionsHelper->header('Pragma: public');
148
149		$this->openWriter();
150		$this->isWriterOpened = true;
151
152		return $this;
153		}
154
155		/**
156		* Checks if the pointer to the file/stream to write to is available.
157		* Will throw an exception if not available.
158		*
159		* @throws \Box\Spout\Common\Exception\IOException If the pointer is not available
160		* @return void
161		*/
162	97	protected function throwIfFilePointerIsNotAvailable()
163		{
164	97	if (!$this->filePointer) {
165	3	throw new IOException('File pointer has not be opened');
166		}
167	94	}
168
169		/**
170		* Checks if the writer has already been opened, since some actions must be done before it gets opened.
171		* Throws an exception if already opened.
172		*
173		* @param string $message Error message
174		* @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened and must not be.
175		* @return void
176		*/
177	53	protected function throwIfWriterAlreadyOpened($message)
178		{
179	53	if ($this->isWriterOpened) {
180	5	throw new WriterAlreadyOpenedException($message);
181		}
182	48	}
183
184		/**
185		* {@inheritdoc}
186		*/
187	81	public function addRow(Row $row)
188		{
189	81	if ($this->isWriterOpened) {
190	71	if ($row->hasCells()) {
191		try {
192	70	$this->applyDefaultRowStyle($row);
193	70	$this->addRowToWriter($row);
194	3	} catch (SpoutException $e) {
195		// if an exception occurs while writing data,
196		// close the writer and remove all files created so far.
197	3	$this->closeAndAttemptToCleanupAllFiles();
198
199		// re-throw the exception to alert developers of the error
200	71	throw $e;
201		}
202		}
203		} else {
204	10	throw new WriterNotOpenedException('The writer needs to be opened before adding row.');
205		}
206
207	68	return $this;
208		}
209
210		/**
211		* {@inheritdoc}
212		*/
213		public function withRow(\Closure $callback)
214		{
215		return $this->addRow($callback(EntityFactory::createRow([])));
216		}
217
218		/**
219		* {@inheritdoc}
220		*/
221	63	public function addRows(array $dataRows)
222		{
223	63	foreach ($dataRows as $dataRow) {
224	63	if (!$dataRow instanceof Row) {
225	3	$this->closeAndAttemptToCleanupAllFiles();
226	3	throw new InvalidArgumentException();
227		}
228
229	61	$this->addRow($dataRow);
230		}
231
232	52	return $this;
233		}
234
235		/**
236		* @param array $dataRow
237		* @param Style\|null $style
238		* @return Row
239		*/
240		protected function createRowFromArray(array $dataRow, Style $style = null)
241		{
242		$row = EntityFactory::createRow(array_map(function ($value) {
243		if ($value instanceof Cell) {
244		return $value;
245		}
246
247		return new Cell($value);
248		}, $dataRow));
249
250		if ($style !== null) {
251		$row->setStyle($style);
252		}
253
254		return $row;
255		}
256
257		/**
258		* @TODO: Move this into styleMerger
259		*
260		* @param Row $row
261		* @return $this
262		*/
263	70	private function applyDefaultRowStyle(Row $row)
264		{
265	70	$defaultRowStyle = $this->optionsManager->getOption(Options::DEFAULT_ROW_STYLE);
266	70	if ($defaultRowStyle === null) {
267	8	return $this;
268		}
269
270	62	$mergedStyle = $this->styleMerger->merge($row->getStyle(), $defaultRowStyle);
271	62	$row->setStyle($mergedStyle);
272	62	}
273
274		/**
275		* Closes the writer. This will close the streamer as well, preventing new data
276		* to be written to the file.
277		*
278		* @return void
279		*/
280	80	public function close()
281		{
282	80	if (!$this->isWriterOpened) {
283	4	return;
284		}
285
286	79	$this->closeWriter();
287
288	79	if (is_resource($this->filePointer)) {
289	79	$this->globalFunctionsHelper->fclose($this->filePointer);
290		}
291
292	79	$this->isWriterOpened = false;
293	79	}
294
295		/**
296		* Closes the writer and attempts to cleanup all files that were
297		* created during the writing process (temp files & final file).
298		*
299		* @return void
300		*/
301	6	private function closeAndAttemptToCleanupAllFiles()
302		{
303		// close the writer, which should remove all temp files
304	6	$this->close();
305
306		// remove output file if it was created
307	6	if ($this->globalFunctionsHelper->file_exists($this->outputFilePath)) {
308	5	$outputFolderPath = dirname($this->outputFilePath);
309	5	$fileSystemHelper = $this->helperFactory->createFileSystemHelper($outputFolderPath);
310	5	$fileSystemHelper->deleteFile($this->outputFilePath);
311		}
312	6	}
313		}
314

box / spout

Pull Request — develop_3.0 (#434)

WriterAbstract::resetRowStyleToDefault() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like