SPSS\Buffer

Complexity

Total Complexity

52

Size/Duplication

Total Lines	384
Duplicated Lines	0 %

Test Coverage

Coverage

44.17%

Importance

Changes	2
Bugs	0	Features	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	writeInt()	0	3	1
B	factory()	0	24	7
A	getMetaData()	0	3	1
A	writeNumeric()	0	3	1
A	writeShort()	0	3	1
A	rewind()	0	4	2
A	position()	0	4	1
A	allocate()	0	11	3
A	readInt()	0	3	1
A	__construct()	0	9	3
A	writeFloat()	0	3	1
A	readBytes()	0	8	2
A	readNumeric()	0	13	3
A	readFloat()	0	3	1
A	seek()	0	5	1
A	skip()	0	3	1
A	readShort()	0	3	1
A	write()	0	6	2
A	saveToFile()	0	5	1
A	read()	0	8	2
A	readDouble()	0	3	1
A	writeDouble()	0	3	1
A	truncate()	0	4	1
A	readString()	0	17	5
A	writeNull()	0	3	1
A	writeStream()	0	15	3
A	getStream()	0	3	1
A	writeString()	0	9	3

<?php

namespace SPSS;

class Buffer
{
    /**
     * @var mixed
     */
    public $context;

    /**
     * @var bool
     */
    public $isBigEndian = false;

    /**
     * @var string
     */
    public $charset;

    /**
     * @var resource
     */
    private $_stream;

    /**
     * @var int
     */
    private $_position = 0;

    /**
     * Buffer constructor.
     *
     * @param resource $stream Stream resource to wrap.
     * @param array $options Associative array of options.
     */
    private function __construct($stream, $options = [])
    {
        if (! is_resource($stream)) {
            throw new \InvalidArgumentException('Stream must be a resource.');
        }
        $this->_stream = $stream;

        if (isset($options['context'])) {
            $this->context = $options['context'];
        }
    }

    /**
     * Create a new stream based on the input type.
     *
     * @param resource|string $resource Entity body data
     * @param array $options Additional options
     * @return Buffer
     */
    public static function factory($resource = '', $options = [])
    {
        $type = gettype($resource);

        switch ($type) {
            case 'string':
                $stream = isset($options['memory']) ?
                    fopen('php://memory', 'r+') :
                    fopen('php://temp', 'r+');
                if ($resource !== '') {
                    fwrite($stream, $resource);

It seems like $resource can also be of type resource; however, parameter $string of fwrite() does only seem to accept string, maybe add an additional type check?

It seems like $stream can also be of type false; however, parameter $handle of fwrite() does only seem to accept resource, maybe add an additional type check?

                    fseek($stream, 0);

It seems like $stream can also be of type false; however, parameter $handle of fseek() does only seem to accept resource, maybe add an additional type check?

                }

                return new self($stream, $options);

It seems like $stream can also be of type false; however, parameter $stream of SPSS\Buffer::__construct() does only seem to accept resource, maybe add an additional type check?

            case 'resource':
                return new self($resource, $options);

It seems like $resource can also be of type string; however, parameter $stream of SPSS\Buffer::__construct() does only seem to accept resource, maybe add an additional type check?

            case 'object':
                if (method_exists($resource, '__toString')) {
                    return self::factory((string) $resource, $options);
                }
        }

        throw new \InvalidArgumentException(sprintf('Invalid resource type: %s.', $type));
    }

    /**
     * @param int $length
     * @param bool $skip
     * @return Buffer
     * @throws Exception
     */
    public function allocate($length, $skip = true)
    {
        $stream = fopen('php://memory', 'r+');
        if (stream_copy_to_stream($this->_stream, $stream, $length)) {

It seems like $stream can also be of type false; however, parameter $dest of stream_copy_to_stream() does only seem to accept resource, maybe add an additional type check?

            if ($skip) {
                $this->skip($length);
            }

            return new self($stream);

It seems like $stream can also be of type false; however, parameter $stream of SPSS\Buffer::__construct() does only seem to accept resource, maybe add an additional type check?

        }
        throw new Exception('Buffer allocation failed.');
    }

    /**
     * @param int $length
     * @return void
     */
    public function skip($length)
    {
        $this->_position += $length;
    }

    /**
     * @param string $file Path to file
     * @return false|int
     */
    public function saveToFile($file)
    {
        rewind($this->_stream);

        return file_put_contents($file, $this->_stream);
    }

    /**
     * @param resource $resource
     * @param null|int $maxlength
     * @return false|int
     */
    public function writeStream($resource, $maxlength = null)
    {
        if (! is_resource($resource)) {
            throw new \InvalidArgumentException('Invalid resource type.');
        }

        if ($maxlength) {

The expression $maxlength of type integer|null is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== null instead.

            $length = stream_copy_to_stream($resource, $this->_stream, $maxlength);
        } else {
            $length = stream_copy_to_stream($resource, $this->_stream);
        }

        $this->_position += $length;

        return $length;
    }

    /**
     * @return resource
     */
    public function getStream()
    {
        return $this->_stream;
    }

    /**
     * @param int $length
     * @param int $round
     * @param null $charset

Are you sure the doc-type for parameter $charset is correct as it would always require null to be passed?

     * @return false|string
     */
    public function readString($length, $round = 0, $charset = null)
    {
        if ($bytes = $this->readBytes($length)) {
            if ($round) {
                $this->skip(Utils::roundUp($length, $round) - $length);
            }
            $str = Utils::bytesToString($bytes);
            if ($charset) {

$charset is of type null, thus it always evaluated to false.

                $str = mb_convert_encoding($str, 'utf8', $charset);
            } elseif ($this->charset) {
                $str = mb_convert_encoding($str, 'utf8', $this->charset);
            }

            return $str;
        }

        return false;
    }

    /**
     * @param $length
     * @return false|array
     */
    public function readBytes($length)
    {
        $bytes = $this->read($length);
        if ($bytes != false) {

It seems like you are loosely comparing $bytes of type string to the boolean false. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

            return array_values(unpack('C*', $bytes));

It seems like unpack('C*', $bytes) can also be of type false; however, parameter $input of array_values() does only seem to accept array, maybe add an additional type check?

        }

        return false;
    }

    /**
     * @param int $length
     * @return false|string
     */
    public function read($length = null)
    {
        $bytes = stream_get_contents($this->_stream, $length, $this->_position);
        if ($bytes !== false) {
            $this->_position += $length;
        }

        return $bytes;
    }

    /**
     * @param $data
     * @param int|string $length
     * @param null $charset

Are you sure the doc-type for parameter $charset is correct as it would always require null to be passed?

     * @return false|int
     */
    public function writeString($data, $length = '*', $charset = null)
    {
        if ($charset) {

$charset is of type null, thus it always evaluated to false.

            $data = mb_convert_encoding($data, 'utf8', $charset);
        } elseif ($this->charset) {
            $data = mb_convert_encoding($data, 'utf8', $this->charset);
        }

        return $this->write(pack('A' . $length, $data));
    }

    /**
     * @param string $data
     * @param null|int $length
     * @return false|int
     */
    public function write($data, $length = null)
    {
        $length = $length ? fwrite($this->_stream, $data, $length) : fwrite($this->_stream, $data);
        $this->_position += $length;

        return $length;
    }

    /**
     * @return double
     */
    public function readDouble()
    {
        return $this->readNumeric(8, 'd');

The expression return $this->readNumeric(8, 'd') could also return false which is incompatible with the documented return type double. Did you maybe forget to handle an error condition?

    }

    /**
     * @param $data
     * @return false|int
     */
    public function writeDouble($data)
    {
        return $this->writeNumeric($data, 'd', 8);
    }

    /**
     * @param $data
     * @param $format
     * @param null $length

Are you sure the doc-type for parameter $length is correct as it would always require null to be passed?

     * @return false|int
     */
    public function writeNumeric($data, $format, $length = null)
    {
        return $this->write(pack($format, $data), $length);
    }

    /**
     * @return false|float
     */
    public function readFloat()
    {
        return $this->readNumeric(4, 'f');
    }

    /**
     * @param $data
     * @return false|int
     */
    public function writeFloat($data)
    {
        return $this->writeNumeric($data, 'f', 4);
    }

    /**
     * @return int
     */
    public function readInt()
    {
        return $this->readNumeric(4, 'i');

The expression return $this->readNumeric(4, 'i') could also return false which is incompatible with the documented return type integer. Did you maybe forget to handle an error condition?

    }

    /**
     * @param $data
     * @return false|int
     */
    public function writeInt($data)
    {
        return $this->writeNumeric($data, 'i', 4);
    }

    /**
     * @return false|int
     */
    public function readShort()
    {
        return $this->readNumeric(2, 'v');
    }

    /**
     * @param $data
     * @return false|int
     */
    public function writeShort($data)
    {
        return $this->writeNumeric($data, 'v', 2);
    }

    /**
     * @param $length
     * @return false|int
     */
    public function writeNull($length)
    {
        return $this->write(pack('x' . $length));
    }

    /**
     * @return int
     */
    public function position()
    {
        //        return ftell($this->_stream);
        return $this->_position;
    }

    /**
     * @param int $offset
     * @param int $whence
     * @return int
     */
    public function seek($offset, $whence = SEEK_SET)
    {
        $this->_position = $offset;

        return fseek($this->_stream, $offset, $whence);
    }

    /**
     * @return void
     */
    public function rewind()
    {
        if (rewind($this->_stream)) {
            $this->_position = 0;
        }
    }

    /**
     * @return void
     */
    public function truncate()
    {
        ftruncate($this->_stream, 0);
        $this->_position = 0;
    }

    /**
     * @return array
     */
    public function getMetaData()
    {
        return stream_get_meta_data($this->_stream);
    }

    /**
     * @param int $length
     * @param string $format
     * @return false|int|float|double
     */
    private function readNumeric($length, $format)
    {
        $bytes = $this->read($length);
        if ($bytes != false) {

It seems like you are loosely comparing $bytes of type string to the boolean false. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

            if ($this->isBigEndian) {
                $bytes = strrev($bytes);
            }
            $data = unpack($format, $bytes);

            return $data[1];
        }

        return false;
    }
}