BufferedReader::readLine() - Code Metrics - Inspection of "Fixed windows line ending issue (#1499)" - phingofficial/phing - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 33b6d3...80c378 )

by Siad

created 2021-01-15 20:12 UTC

BufferedReader::readLine() A

↳ Parent: BufferedReader

Complexity

Conditions	5
Paths	6

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	5.025

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	9
c	1
b	0
f	0
nc	6
nop	0
dl	0
loc	17
ccs	9
cts	10
cp	0.9
crap	5.025
rs	9.6111

<?php
/**
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information please see
 * <http://phing.info>.
 */

/**
 * Convenience class for reading files.
 *
 * @author <a href="mailto:[email protected]">Yannick Lecaillez</a>
 *
 * @see FilterReader
 *
 * @package phing.system.io
 */
class BufferedReader extends Reader
{
    private $bufferSize = 0;
    private $buffer = null;
    private $bufferPos = 0;

    /**
     * The Reader we are buffering for.
     *
     * @var InputStreamReader
     */
    private $in;

    /**
     *
     * @param InputStreamReader $reader The reader (e.g. FileReader).
     * @param integer $buffsize The size of the buffer we should use for reading files.
     *                                    A large buffer ensures that most files (all scripts?)
     *                                    are parsed in 1 buffer.
     */
    public function __construct(InputStreamReader $reader, $buffsize = 65536)
    {
        $this->in = $reader;
        $this->bufferSize = $buffsize;
    }

    /**
     * Reads and returns a chunk of data.
     *
     * @param  int $len Number of bytes to read.  Default is to read configured buffer size number of bytes.
     * @return mixed buffer or -1 if EOF.
     */
    public function read($len = null)
    {

        // if $len is specified, we'll use that; otherwise, use the configured buffer size.
        if ($len === null) {
            $len = $this->bufferSize;
        }

        if (($data = $this->in->read($len)) !== -1) {
            // not all files end with a newline character, so we also need to check EOF
            if (!$this->in->eof()) {
                $notValidPart = strrchr($data, "\n");
                $notValidPartSize = strlen($notValidPart);

                if ($notValidPartSize > 1) {
                    // Block doesn't finish on a EOL
                    // Find the last EOL and forget all following stuff
                    $dataSize = strlen($data);
                    $validSize = $dataSize - $notValidPartSize + 1;

                    $data = substr($data, 0, $validSize);

                    // Rewind to the beginning of the forgotten stuff.
                    $this->in->skip(-$notValidPartSize + 1);
                }
            } // if !EOF
        }

        return $data;
    }

    /**
     * @param int $n
     * @return int
     */
    public function skip($n)
    {
        return $this->in->skip($n);
    }

    public function reset()
    {
        $this->in->reset();
    }

    public function close()
    {
        $this->in->close();
    }

    /**
     * Read a line from input stream.
     */
    public function readLine()
    {
        $line = null;
        while (($ch = $this->readChar()) !== -1) {
            if ($ch === "\n") {
                $line = rtrim($line);
                $line = rtrim(/** @scrutinizer ignore-type */ $line);
                break;
            }
            $line .= $ch;
        }

        // Warning : Not considering an empty line as an EOF
        if ($line === null && $ch !== -1) {
            return "";
        }

        return $line;
    }

    /**
     * Reads a single char from the reader.
     *
     * @return string single char or -1 if EOF.
     */
    public function readChar()
    {
        if ($this->buffer === null) {
            // Buffer is empty, fill it ...
            $read = $this->in->read($this->bufferSize);
            if ($read === -1) {
                $ch = -1;
            } else {
                $this->buffer = $read;

                return $this->readChar(); // recurse
            }
        } else {
            // Get next buffered char ...
            // handle case where buffer is read-in, but is empty.  The next readChar() will return -1 EOF,
            // so we just return empty string (char) at this point.  (Probably could also return -1 ...?)
            $ch = ($this->buffer !== "") ? $this->buffer[$this->bufferPos] : '';
            $this->bufferPos++;
            if ($this->bufferPos >= strlen($this->buffer)) {
                $this->buffer = null;
                $this->bufferPos = 0;
            }
        }

        return $ch;
    }

    /**
     * Returns whether eof has been reached in stream.
     * This is important, because filters may want to know if the end of the file (and not just buffer)
     * has been reached.
     *
     * @return boolean
     */
    public function eof()
    {
        return $this->in->eof();
    }

    /**
     * @return string
     */
    public function getResource()
    {
        return $this->in->getResource();
    }
}


phingofficial / phing

Push — master ( 33b6d3...80c378 )

BufferedReader::readLine() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like