IteratorStream - Code Metrics - Inspection of "Removed $that = $this from Collection and used Clo..." - nozavroni/csvelte - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — releases/v0.2.1 ( 8d5d04...e66e88 )

by Luke

created 2016-10-31 01:29 UTC

IteratorStream A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	311
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	3

Test Coverage

Coverage

97.65%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	311
ccs	83
cts	85
cp	0.9765
rs	9.6
wmc	32
lcom	3
cbo	3

17 Methods

Rating	Name	Size	Complexity
A	__construct()	16	4
A	isReadable()	4	1
B	read()	18	5
A	inflateBuffer()	8	3
A	__toString()	5	1
A	getContents()	12	2
A	getSize()	4	1
A	tell()	4	1
A	eof()	7	2
A	rewind()	5	1
A	getMetadata()	7	3
A	close()	10	3
A	detach()	8	1
A	isWritable()	4	1
A	write()	4	1
A	isSeekable()	4	1
A	seek()	4	1

<?php
/**
 * CSVelte: Slender, elegant CSV for PHP.
 *
 * Inspired by Python's CSV module and Frictionless Data and the W3C's CSV
 * standardization efforts, CSVelte was written in an effort to take all the
 * suck out of working with CSV.
 *
 * @version   v0.2.1
 * @copyright Copyright (c) 2016 Luke Visinoni <[email protected]>
 * @author    Luke Visinoni <[email protected]>
 * @license   https://github.com/deni-zen/csvelte/blob/master/LICENSE The MIT License (MIT)
 */
namespace CSVelte\IO;

use InvalidArgumentException;
use \Iterator;
use CSVelte\IO\BufferStream;
use CSVelte\Traits\IsReadable;
use CSVelte\Traits\IsWritable;
use CSVelte\Contract\Streamable;
use Traversable;
use function CSVelte\getvalue;

/**
 * Iterator Stream.
 *
 * A read-only stream that uses an iterable to continuously fill up a buffer as
 * read operations deplete it.
 *
 * @package    CSVelte
 * @subpackage CSVelte\IO
 * @copyright  (c) 2016, Luke Visinoni <[email protected]>
 * @author     Luke Visinoni <[email protected]>
 * @since      v0.2.1
 */
class IteratorStream implements Streamable
{
    use IsReadable, IsWritable;

    /**
     * Buffer stream
     * @var \CSVelte\IO\BufferStream A BufferStream object
     */
    protected $buffer;

    /**
     * Iterator to read from
     *
     * @var Traversable
     */
    protected $iter;

    /**
     * Is stream readable?
     *
     * @var boolean Whether stream is readable
     */
    protected $readable = true;

    /**
     * Is stream writable?
     *
     * @var boolean Whether stream is writable
     */
    protected $writable = false;

    /**
     * Is stream seekable?
     *
     * @var boolean Whether stream is seekable
     */
    protected $seekable = false;

    /**
     * @var array Any additional options / meta data
     */
    protected $meta = [

    ];

    /**
     * Instantiate an iterator stream
     *
     * Instantiate a new iterator stream. The iterator is used to continually
     * refill a buffer as it is drained by read operations.
     *
     * @param \Iterator The iterator to stream data from
     * @param \CSVelte\IO\BufferIterator|null Either a buffer or null (to use
     *     default buffer)
     * @todo this should expect a BufferInterface or a Bufferable rather than
     * a BufferStream
     */
    public function __construct(Traversable $iter, $buffer = null)
    {
        $this->iter = $iter;
        if (is_null($buffer)) {
            $buffer = new BufferStream;
        }
        if (!($buffer instanceof BufferStream)) {
            throw new InvalidArgumentException(sprintf(
                "%s expected %s as second argument, got: %s",
                __CLASS__,
                BufferStream::class,
                is_object($buffer) ? get_class($buffer) : gettype($buffer)
            ));
        }
        $this->buffer = $buffer;
    }

    /**
     * Readability accessor.
     *
     * Despite the fact that any class that implements this interface must also
     * define methods such as read and readLine, that is no guarantee that an
     * object will necessarily be readable. This method should tell the user
     * whether a stream is, in fact, readable.
     *
     * @return boolean True if readable, false otherwise
     */
    public function isReadable()
    {
        return $this->readable;
    }

    public function read($bytes)
    {
        if ($this->buffer) {
            $data = '';
            while (strlen($data) < $bytes) {
                if ($this->buffer->isEmpty()) {
                    $this->inflateBuffer();
                }

                if (!$read = $this->buffer->read($bytes - strlen($data))) {
                    break;
                }
                $data .= $read;
            }
            return $data;
        }
        return false;
    }

    protected function inflateBuffer()
    {
        while (!$this->buffer->isFull() && $this->iter->valid()) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $data = $this->iter->current();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $this->buffer->write($data);
            $this->iter->next();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }
    }

    /**
     * Read the entire stream, beginning to end.
     *
     * In most stream implementations, __toString() differs from getContents()
     * in that it returns the entire stream rather than just the remainder, but
     * due to the way this stream works (sort of like a conveyor belt), this
     * method is an alias to getContents()
     *
     * @return string The entire stream, beginning to end
     */
    public function __toString()
    {
        $this->rewind();
        return $this->getContents();
    }

    /**
     * Read the remainder of the stream
     *
     * @return string The remainder of the stream
     */
    public function getContents()
    {
        $contents = '';
        while (!$this->eof()) {
            $contents .= $this->read(
                // kind of arbitrary... we have to specify something for the
                // chunk length, so I just used the buffer's "high water mark"
                $this->buffer->getMetadata('hwm')
            );
        }
        return $contents;
    }

    /**
     * Return the size (in bytes) of this stream (if known).
     *
     * @return int|null Size (in bytes) of this stream
     */
    public function getSize()
    {
        // no way to know so return null
    }

    /**
     * Return the current position within the stream/readable
     *
     * I can't decide whether there is any meaningful way to "tell" the
     * current position within this type of stream. For now I'm just
     * going to return false because the nature of this type of stream
     * means that it technically has no definitive beginning or end and
     * therefor no absolute position. If a "tell" is truly needed, I
     * suppose I could keep track of how many bytes have been read over
     * the lifetime of the object, but I don't think that is meaningful
     * and/or useful.
     *
     * @return int|false The current position within readable
     */
    public function tell()
    {
        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Determine whether the end of the stream has been reached
     *
     * @return boolean Whether we're at the end of the stream
     */
    public function eof()
    {
        return (
            !$this->iter->valid() &&
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $this->buffer->eof()
        );
    }

    /**
     * Rewind to beginning of stream
     */
    public function rewind()
    {
        $this->iter->rewind();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        $this->buffer->rewind();
    }

    /**
     * Get stream metadata as an associative array or retrieve a specific key.
     *
     * The keys returned are identical to the keys returned from PHP's
     * stream_get_meta_data() function.
     *
     * @param string $key Specific metadata to retrieve.
     * @return array|mixed|null Returns an associative array if no key is
     *     provided. Returns a specific key value if a key is provided and the
     *     value is found, or null if the key is not found.
     * @see http://php.net/manual/en/function.stream-get-meta-data.php
     */
    public function getMetadata($key = null)
    {
        if (!is_null($key)) {
            return isset($this->meta[$key]) ? $this->meta[$key] : null;
        }
        return $this->meta;
    }

    /**
     * Closes the stream and any underlying resources.
     *
     * @return void
     */
    public function close()
    {
        $buff = $this->buffer->close();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        $iter = true;
        if (method_exists($this->iter, 'close')) {
            $iter = $this->iter->close();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }
        $this->buffer = null;
        return $buff && $iter;
    }

    /**
     * Separates any underlying resources from the stream.
     *
     * After the stream has been detached, the stream is in an unusable state.
     *
     * @return array|Resource Underlying PHP stream, if any
     * @todo I'm not sure what detach is for so I don't know whether what I'm
     *     doing here is right. The reason I have the method at all is because
     *     psr7 StreamInterface has one.f
     */
    public function detach()
    {
        $data = (string) $this;
        $this->buffer = null;
        $this->iter = null;
        $this->readable = false;
        return $data;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Writability accessor.
     *
     * Despite the fact that any class that implements this interface must also
     * define methods such as write and writeLine, that is no guarantee that an
     * object will necessarily be writable. This method should tell the user
     * whether a stream is, in fact, writable.
     *
     * @return boolean True if writable, false otherwise
     */
    public function isWritable()
    {
        return $this->writable;
    }

    /**
     * Write data to the output.
     *
     * @param string The data to write
     * @return int|false The number of bytes written
     */
    public function write($data)
    {
        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

     /**
      * Seekability accessor.
      *
      * Despite the fact that any class that implements this interface must also
      * define methods such as seek, that is no guarantee that an
      * object will necessarily be seekable. This method should tell the user
      * whether a stream is, in fact, seekable.
      *
      * @return boolean True if seekable, false otherwise
      */
    public function isSeekable()
    {
        return $this->seekable;
    }

    /**
     * Seek to specified offset.
     *
     * @param integer Offset to seek to
     * @param integer Position from whence the offset should be applied
     * @return boolean True if seek was successful
     */
    public function seek($offset, $whence = SEEK_SET)
    {
        return $this->seekable;
    }

}


Push — releases/v0.2.1 ( 8d5d04...e66e88 )

IteratorStream A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

17 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

nozavroni / csvelte

Push — releases/v0.2.1 ( 8d5d04...e66e88 )

IteratorStream A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

17 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like