GravityMedia\Stream\Stream

Complexity

Total Complexity

29

Size/Duplication

Total Lines	277
Duplicated Lines	10.83 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	11
Bugs	0	Features	5

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getMetaData()	0	4	1
A	isLocal()	0	4	1
A	isReadable()	0	4	1
A	isWritable()	0	4	1
A	isSeekable()	0	4	1
A	getUri()	0	4	1
A	eof()	0	4	1
A	rewind()	0	4	1
A	fromResource()	0	6	1
A	bindResource()	0	14	1
A	getResource()	0	8	2
A	getStat()	0	13	2
A	getSize()	0	8	2
A	tell()	0	4	1
A	seek()	0	14	3
A	read()	15	15	3
A	write()	15	15	3
A	truncate()	0	10	2
A	close()	0	4	1

<?php
/**
 * This file is part of the stream package
 *
 * @author Daniel Schröder <daniel.schroeder@gravitymedia.de>
 */

namespace GravityMedia\Stream;

use GravityMedia\Stream\Exception;

/**
 * Stream
 *
 * @package GravityMedia\Stream
 */
class Stream implements StreamInterface
{
    /**
     * @var string[]
     */
    private static $readModes = ['r', 'w+', 'r+', 'x+', 'c+', 'rb', 'w+b', 'r+b', 'x+b', 'c+b', 'rt', 'w+t',
        'r+t', 'x+t', 'c+t', 'a+'];

    /**
     * @var string[]
     */
    private static $writeModes = ['w', 'w+', 'rw', 'r+', 'x+', 'c+', 'wb', 'w+b', 'r+b', 'x+b', 'c+b', 'w+t',
        'r+t', 'x+t', 'c+t', 'a', 'a+'];

    /**
     * @var resource
     */
    protected $resource;

    /**
     * @var bool
     */
    protected $local;

    /**
     * @var bool
     */
    protected $readable;

    /**
     * @var bool
     */
    protected $writable;

    /**
     * @var bool
     */
    protected $seekable;

    /**
     * @var string
     */
    protected $uri;

    /**
     * Create stream object from resource
     *
     * @param resource $resource
     *
     * @return StreamInterface
     */
    public static function fromResource($resource)
    {
        $instance = new static();

        return $instance->bindResource($resource);
    }

    /**
     * Get meta data from the stream
     *
     * @throws Exception\IOException An exception will be thrown for invalid stream resources
     *
     * @return array
     */
    protected function getMetaData()
    {
        return stream_get_meta_data($this->getResource());
    }

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

        $this->local = stream_is_local($this->getResource());

        $metaData = $this->getMetaData();
        $this->readable = in_array($metaData['mode'], self::$readModes);
        $this->writable = in_array($metaData['mode'], self::$writeModes);
        $this->seekable = $metaData['seekable'];
        $this->uri = $metaData['uri'];

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getResource()
    {
        if (!is_resource($this->resource)) {
            throw new Exception\IOException('Invalid resource');
        }

        return $this->resource;
    }

    /**
     * {@inheritdoc}
     */
    public function isLocal()
    {
        return $this->local;
    }

    /**
     * {@inheritdoc}
     */
    public function isReadable()
    {
        return $this->readable;
    }

    /**
     * {@inheritdoc}
     */
    public function isWritable()
    {
        return $this->writable;
    }

    /**
     * {@inheritdoc}
     */
    public function isSeekable()
    {
        return $this->seekable;
    }

    /**
     * {@inheritdoc}
     */
    public function getUri()
    {
        return $this->uri;
    }

    /**
     * Get information about the stream
     *
     * @param string $info The information to retrieve
     *
     * @throws Exception\IOException An exception will be thrown for invalid stream resources
     *
     * @return int
     */
    protected function getStat($info)
    {
        $resource = $this->getResource();

        $uri = $this->getUri();
        if (is_string($uri)) {
            clearstatcache(true, $uri);
        }

        $stat = fstat($resource);

        return $stat[$info];
    }

    /**
     * {@inheritdoc}
     */
    public function getSize()
    {
        if (!$this->isLocal()) {
            throw new Exception\BadMethodCallException('Stream not local');
        }

        return $this->getStat('size');
    }

    /**
     * {@inheritdoc}
     */
    public function eof()
    {
        return feof($this->getResource());
    }

    /**
     * {@inheritdoc}
     */
    public function tell()
    {
        return ftell($this->getResource());
    }

    /**
     * {@inheritdoc}
     */
    public function seek($offset, $whence = SEEK_SET)
    {
        $resource = $this->getResource();

        if (!$this->isSeekable()) {
            throw new Exception\BadMethodCallException('Stream not seekable');
        }

        if (fseek($resource, $offset, $whence) < 0) {
            throw new Exception\IOException('Unexpected result of operation');
        }

        return $this->tell();
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        return $this->seek(0);
    }

    /**
     * {@inheritdoc}
     */
    public function read($length)

This method seems to be duplicated in your project.

    {
        $resource = $this->getResource();

        if (!$this->isReadable()) {
            throw new Exception\BadMethodCallException('Stream not readable');
        }

        $data = @fread($resource, $length);
        if (false === $data) {
            throw new Exception\IOException('Unexpected result of operation');
        }

        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public function write($data)

This method seems to be duplicated in your project.

    {
        $resource = $this->getResource();

        if (!$this->isWritable()) {
            throw new Exception\BadMethodCallException('Stream not writable');
        }

        $length = @fwrite($resource, $data);
        if (false === $length) {
            throw new Exception\IOException('Unexpected result of operation');
        }

        return $length;
    }

    /**
     * {@inheritdoc}
     */
    public function truncate($size)
    {
        $resource = $this->getResource();

        if (!$this->isWritable()) {
            throw new Exception\BadMethodCallException('Stream not writable');
        }

        return @ftruncate($resource, $size);
    }

    /**
     * {@inheritdoc}
     */
    public function close()
    {
        return @fclose($this->resource);
    }
}