AbstractReader::setGlobalFunctionsHelper() - Code Metrics - Inspection of "Make max read bytes per line configurable" - box/spout - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#366)

by Alexander

created 2017-01-06 04:53 UTC

AbstractReader::setGlobalFunctionsHelper() A

↳ Parent: AbstractReader

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0
ccs	3
cts	3
cp	1
cc	1
eloc	3
nc	1
nop	1
crap	1

<?php

namespace Box\Spout\Reader;

use Box\Spout\Common\Exception\IOException;
use Box\Spout\Reader\Exception\ReaderNotOpenedException;

/**
 * Class AbstractReader
 *
 * @package Box\Spout\Reader
 * @abstract
 */
abstract class AbstractReader implements ReaderInterface
{
    /** @var bool Indicates whether the stream is currently open */
    protected $isStreamOpened = false;

    /** @var \Box\Spout\Common\Helper\GlobalFunctionsHelper Helper to work with global functions */
    protected $globalFunctionsHelper;

    /** @var \Box\Spout\Reader\Common\ReaderOptions Reader's customized options */
    protected $options;

    /**
     * Returns the reader's current options
     *
     * @return \Box\Spout\Reader\Common\ReaderOptions
     */
    abstract protected function getOptions();

    /**
     * Returns whether stream wrappers are supported
     *
     * @return bool
     */
    abstract protected function doesSupportStreamWrapper();

    /**
     * Opens the file at the given file path to make it ready to be read
     *
     * @param  string $filePath Path of the file to be read
     * @return void
     */
    abstract protected function openReader($filePath);

    /**
     * Returns an iterator to iterate over sheets.
     *
     * @return \Iterator To iterate over sheets
     */
    abstract protected function getConcreteSheetIterator();

    /**
     * Closes the reader. To be used after reading the file.
     *
     * @return AbstractReader
     */
    abstract protected function closeReader();

    /**
     * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
     * @return AbstractReader
     */
    public function setGlobalFunctionsHelper($globalFunctionsHelper)
    {
        $this->globalFunctionsHelper = $globalFunctionsHelper;
        return $this;
    }

    /**
     * Sets whether date/time values should be returned as PHP objects or be formatted as strings.
     *
     * @api
     * @param bool $shouldFormatDates
     * @return AbstractReader
     */
    public function setShouldFormatDates($shouldFormatDates)
    {
        $this->getOptions()->setShouldFormatDates($shouldFormatDates);
        return $this;
    }

    /**
     * Sets whether empty rows should be returned or skipped.
     *
     * @api
     * @param bool $shouldPreserveEmptyRows
     * @return AbstractReader
     */
    public function setShouldPreserveEmptyRows($shouldPreserveEmptyRows)
    {
        $this->getOptions()->setShouldPreserveEmptyRows($shouldPreserveEmptyRows);
        return $this;
    }

    /**
     * Prepares the reader to read the given file. It also makes sure
     * that the file exists and is readable.
     *
     * @api
     * @param  string $filePath Path of the file to be read
     * @return void
     * @throws \Box\Spout\Common\Exception\IOException If the file at the given path does not exist, is not readable or is corrupted
     */
    public function open($filePath)
    {
        if ($this->isStreamWrapper($filePath) && (!$this->doesSupportStreamWrapper() || !$this->isSupportedStreamWrapper($filePath))) {
            throw new IOException("Could not open $filePath for reading! Stream wrapper used is not supported for this type of file.");
        }

        if (!$this->isPhpStream($filePath)) {
            // we skip the checks if the provided file path points to a PHP stream
            if (!$this->globalFunctionsHelper->file_exists($filePath)) {
                throw new IOException("Could not open $filePath for reading! File does not exist.");
            } else if (!$this->globalFunctionsHelper->is_readable($filePath)) {
                throw new IOException("Could not open $filePath for reading! File is not readable.");
            }
        }

        try {
            $fileRealPath = $this->getFileRealPath($filePath);
            $this->openReader($fileRealPath);
            $this->isStreamOpened = true;
        } catch (\Exception $exception) {
            throw new IOException("Could not open $filePath for reading! ({$exception->getMessage()})");
        }
    }

    /**
     * Returns the real path of the given path.
     * If the given path is a valid stream wrapper, returns the path unchanged.
     *
     * @param string $filePath
     * @return string
     */
    protected function getFileRealPath($filePath)
    {
        if ($this->isSupportedStreamWrapper($filePath)) {
            return $filePath;
        }

        // Need to use realpath to fix "Can't open file" on some Windows setup
        return realpath($filePath);
    }

    /**
     * Returns the scheme of the custom stream wrapper, if the path indicates a stream wrapper is used.
     * For example, php://temp => php, s3://path/to/file => s3...
     *
     * @param string $filePath Path of the file to be read
     * @return string|null The stream wrapper scheme or NULL if not a stream wrapper
     */
    protected function getStreamWrapperScheme($filePath)
    {
        $streamScheme = null;
        if (preg_match('/^(\w+):\/\//', $filePath, $matches)) {
            $streamScheme = $matches[1];
        }
        return $streamScheme;
    }

    /**
     * Checks if the given path is an unsupported stream wrapper
     * (like local path, php://temp, mystream://foo/bar...).
     *
     * @param string $filePath Path of the file to be read
     * @return bool Whether the given path is an unsupported stream wrapper
     */
    protected function isStreamWrapper($filePath)
    {
        return ($this->getStreamWrapperScheme($filePath) !== null);
    }

    /**
     * Checks if the given path is an supported stream wrapper
     * (like php://temp, mystream://foo/bar...).
     * If the given path is a local path, returns true.
     *
     * @param string $filePath Path of the file to be read
     * @return bool Whether the given path is an supported stream wrapper
     */
    protected function isSupportedStreamWrapper($filePath)
    {
        $streamScheme = $this->getStreamWrapperScheme($filePath);
        return ($streamScheme !== null) ?
            in_array($streamScheme, $this->globalFunctionsHelper->stream_get_wrappers()) :
            true;
    }

    /**
     * Checks if a path is a PHP stream (like php://output, php://memory, ...)
     *
     * @param string $filePath Path of the file to be read
     * @return bool Whether the given path maps to a PHP stream
     */
    protected function isPhpStream($filePath)
    {
        $streamScheme = $this->getStreamWrapperScheme($filePath);
        return ($streamScheme === 'php');
    }

    /**
     * Returns an iterator to iterate over sheets.
     *
     * @api
     * @return \Iterator To iterate over sheets
     * @throws \Box\Spout\Reader\Exception\ReaderNotOpenedException If called before opening the reader
     */
    public function getSheetIterator()
    {
        if (!$this->isStreamOpened) {
            throw new ReaderNotOpenedException('Reader should be opened first.');
        }

        return $this->getConcreteSheetIterator();
    }

    /**
     * Closes the reader, preventing any additional reading
     *
     * @api
     * @return void
     */
    public function close()
    {
        if ($this->isStreamOpened) {
            $this->closeReader();

            $sheetIterator = $this->getConcreteSheetIterator();
            if ($sheetIterator) {
                $sheetIterator->end();
            }

            $this->isStreamOpened = false;
        }
    }
}


1		<?php
2
3		namespace Box\Spout\Reader;
4
5		use Box\Spout\Common\Exception\IOException;
6		use Box\Spout\Reader\Exception\ReaderNotOpenedException;
7
8		/**
9		* Class AbstractReader
10		*
11		* @package Box\Spout\Reader
12		* @abstract
13		*/
14		abstract class AbstractReader implements ReaderInterface
15		{
16		/** @var bool Indicates whether the stream is currently open */
17		protected $isStreamOpened = false;
18
19		/** @var \Box\Spout\Common\Helper\GlobalFunctionsHelper Helper to work with global functions */
20		protected $globalFunctionsHelper;
21
22		/** @var \Box\Spout\Reader\Common\ReaderOptions Reader's customized options */
23		protected $options;
24
25		/**
26		* Returns the reader's current options
27		*
28		* @return \Box\Spout\Reader\Common\ReaderOptions
29		*/
30		abstract protected function getOptions();
31
32		/**
33		* Returns whether stream wrappers are supported
34		*
35		* @return bool
36		*/
37		abstract protected function doesSupportStreamWrapper();
38
39		/**
40		* Opens the file at the given file path to make it ready to be read
41		*
42		* @param string $filePath Path of the file to be read
43		* @return void
44		*/
45		abstract protected function openReader($filePath);
46
47		/**
48		* Returns an iterator to iterate over sheets.
49		*
50		* @return \Iterator To iterate over sheets
51		*/
52		abstract protected function getConcreteSheetIterator();
53
54		/**
55		* Closes the reader. To be used after reading the file.
56		*
57		* @return AbstractReader
58		*/
59		abstract protected function closeReader();
60
61		/**
62		* @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
63		* @return AbstractReader
64		*/
65	306	public function setGlobalFunctionsHelper($globalFunctionsHelper)
66		{
67	306	$this->globalFunctionsHelper = $globalFunctionsHelper;
68	306	return $this;
69		}
70
71		/**
72		* Sets whether date/time values should be returned as PHP objects or be formatted as strings.
73		*
74		* @api
75		* @param bool $shouldFormatDates
76		* @return AbstractReader
77		*/
78	186	public function setShouldFormatDates($shouldFormatDates)
79		{
80	186	$this->getOptions()->setShouldFormatDates($shouldFormatDates);
81	186	return $this;
82	3	}
83
84		/**
85		* Sets whether empty rows should be returned or skipped.
86		*
87		* @api
88		* @param bool $shouldPreserveEmptyRows
89		* @return AbstractReader
90		*/
91	249	public function setShouldPreserveEmptyRows($shouldPreserveEmptyRows)
92		{
93	249	$this->getOptions()->setShouldPreserveEmptyRows($shouldPreserveEmptyRows);
94	249	return $this;
95		}
96
97		/**
98		* Prepares the reader to read the given file. It also makes sure
99		* that the file exists and is readable.
100		*
101		* @api
102		* @param string $filePath Path of the file to be read
103		* @return void
104		* @throws \Box\Spout\Common\Exception\IOException If the file at the given path does not exist, is not readable or is corrupted
105		*/
106	303	public function open($filePath)
107		{
108	303	if ($this->isStreamWrapper($filePath) && (!$this->doesSupportStreamWrapper() \|\| !$this->isSupportedStreamWrapper($filePath))) {
109	15	throw new IOException("Could not open $filePath for reading! Stream wrapper used is not supported for this type of file.");
110		}
111
112	288	if (!$this->isPhpStream($filePath)) {
113		// we skip the checks if the provided file path points to a PHP stream
114	288	if (!$this->globalFunctionsHelper->file_exists($filePath)) {
115	9	throw new IOException("Could not open $filePath for reading! File does not exist.");
116	279	} else if (!$this->globalFunctionsHelper->is_readable($filePath)) {
117	3	throw new IOException("Could not open $filePath for reading! File is not readable.");
118		}
119	276	}
120
121		try {
122	276	$fileRealPath = $this->getFileRealPath($filePath);
123	276	$this->openReader($fileRealPath);
124	261	$this->isStreamOpened = true;
125	276	} catch (\Exception $exception) {
126	15	throw new IOException("Could not open $filePath for reading! ({$exception->getMessage()})");
127		}
128	261	}
129
130		/**
131		* Returns the real path of the given path.
132		* If the given path is a valid stream wrapper, returns the path unchanged.
133		*
134		* @param string $filePath
135		* @return string
136		*/
137	276	protected function getFileRealPath($filePath)
138		{
139	276	if ($this->isSupportedStreamWrapper($filePath)) {
140	276	return $filePath;
141		}
142
143		// Need to use realpath to fix "Can't open file" on some Windows setup
144		return realpath($filePath);
145		}
146
147		/**
148		* Returns the scheme of the custom stream wrapper, if the path indicates a stream wrapper is used.
149		* For example, php://temp => php, s3://path/to/file => s3...
150		*
151		* @param string $filePath Path of the file to be read
152		* @return string\|null The stream wrapper scheme or NULL if not a stream wrapper
153		*/
154	303	protected function getStreamWrapperScheme($filePath)
155		{
156	303	$streamScheme = null;
157	303	if (preg_match('/^(\w+):\/\//', $filePath, $matches)) {
158	18	$streamScheme = $matches[1];
159	18	}
160	303	return $streamScheme;
161		}
162
163		/**
164		* Checks if the given path is an unsupported stream wrapper
165		* (like local path, php://temp, mystream://foo/bar...).
166		*
167		* @param string $filePath Path of the file to be read
168		* @return bool Whether the given path is an unsupported stream wrapper
169		*/
170	303	protected function isStreamWrapper($filePath)
171		{
172	303	return ($this->getStreamWrapperScheme($filePath) !== null);
173		}
174
175		/**
176		* Checks if the given path is an supported stream wrapper
177		* (like php://temp, mystream://foo/bar...).
178		* If the given path is a local path, returns true.
179		*
180		* @param string $filePath Path of the file to be read
181		* @return bool Whether the given path is an supported stream wrapper
182		*/
183	279	protected function isSupportedStreamWrapper($filePath)
184		{
185	279	$streamScheme = $this->getStreamWrapperScheme($filePath);
186	279	return ($streamScheme !== null) ?
187	279	in_array($streamScheme, $this->globalFunctionsHelper->stream_get_wrappers()) :
188	279	true;
189		}
190
191		/**
192		* Checks if a path is a PHP stream (like php://output, php://memory, ...)
193		*
194		* @param string $filePath Path of the file to be read
195		* @return bool Whether the given path maps to a PHP stream
196		*/
197	288	protected function isPhpStream($filePath)
198		{
199	288	$streamScheme = $this->getStreamWrapperScheme($filePath);
200	288	return ($streamScheme === 'php');
201		}
202
203		/**
204		* Returns an iterator to iterate over sheets.
205		*
206		* @api
207		* @return \Iterator To iterate over sheets
208		* @throws \Box\Spout\Reader\Exception\ReaderNotOpenedException If called before opening the reader
209		*/
210	264	public function getSheetIterator()
211		{
212	264	if (!$this->isStreamOpened) {
213	3	throw new ReaderNotOpenedException('Reader should be opened first.');
214		}
215
216	261	return $this->getConcreteSheetIterator();
217		}
218
219		/**
220		* Closes the reader, preventing any additional reading
221		*
222		* @api
223		* @return void
224		*/
225	249	public function close()
226		{
227	249	if ($this->isStreamOpened) {
228	249	$this->closeReader();
229
230	249	$sheetIterator = $this->getConcreteSheetIterator();
231	249	if ($sheetIterator) {
232	249	$sheetIterator->end();
233	249	}
234
235	249	$this->isStreamOpened = false;
236	249	}
237	249	}
238		}
239

box / spout

Pull Request — master (#366)

AbstractReader::setGlobalFunctionsHelper() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like