ntentan\utils\StringStream

Complexity

Total Complexity

35

Size/Duplication

Total Lines	244
Duplicated Lines	2.46 %

Coupling/Cohesion

Components	2
Dependencies	0

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setFlags()	0	6	1
C	stream_open()	6	49	12
A	stream_read()	0	9	2
A	stream_write()	0	11	2
A	stream_tell()	0	3	1
A	stream_eof()	0	3	1
B	stream_seek()	0	28	6
A	stream_truncate()	0	8	3
A	stream_stat()	0	15	1
A	url_stat()	0	4	1
A	register()	0	9	3
A	unregister()	0	5	2

<?php

/*
 * Adapted for use in ntentan\utils from dvdoug\stringstream package.
 */

/**
 * Stream wrapper for strings.
 * 
 * @author Doug Wright
 */

namespace ntentan\utils;

/**
 * Stream wrapper for strings which allows you to read strings as though they
 * were I/O streams.
 * @author Doug Wright
 * @package StringStream
 */
class StringStream 
{

    /**
     * Content of stream
     * @var string
     */
    private static $string = [];

    /**
     * Whether this stream can be read
     * @var boolean
     */
    private $read;

    /**
     * Whether this stream can be written
     * @var boolean
     */
    private $write;

    /**
     * Options
     * @var int
     */
    private $options;

    /**
     * Current position within stream
     * @var int
     */
    private $position;
    private $path;
    private static $registered = false;

    private function setFlags($read, $write, $position)
    {
        $this->read = $read;
        $this->write = $write;
        $this->position = $position;
    }

    /**
     * Open stream
     * @param string $aPath
     * @param string $aMode
     * @param int $aOptions
     * @param string $aOpenedPath
     * @return boolean
     */
    public function stream_open($aPath, $aMode, $aOptions, &$aOpenedPath) 
    {
        $this->path = substr($aPath, 9);
        if (!isset(self::$string[$this->path])) {
            self::$string[$this->path] = '';
        }
        $this->options = $aOptions;
        $aOpenedPath = $this->path;

        switch ($aMode) {

            case 'r':
            case 'rb':
                $this->setFlags(true, false, 0);
                break;

            case 'r+':
            case 'c+':
                $this->setFlags(true, true, 0);
                break;

            case 'w':
            case 'wb':
                $this->setFlags(false, true, 0);
                break;

            case 'w+':
                $this->setFlags(true, true, 0);
                $this->stream_truncate(0);
                break;

            case 'a':

This code seems to be duplicated across your project.

                $this->setFlags(false, true, strlen(self::$string[$this->path]));
                break;

            case 'a+':

This code seems to be duplicated across your project.

                $this->setFlags(true, true, strlen(self::$string[$this->path]));
                break;

            case 'c':
                $this->setFlags(false, true, 0);
                break;

            default:
                trigger_error($aMode . 'Invalid mode specified (mode specified makes no sense for this stream implementation)', E_USER_ERROR);
        }

        return true;
    }

    /**
     * Read from stream
     * @param int $aBytes number of bytes to return
     * @return string

Should the return type not be string|false?

     */
    function stream_read($aBytes) {

It is generally recommended to explicitly declare the visibility for methods.

        if ($this->read) {
            $read = substr(self::$string[$this->path], $this->position, $aBytes);
            $this->position += strlen($read);
            return $read;
        } else {
            return false;
        }
    }

    /**
     * Write to stream
     * @param string $aData data to write
     * @return int
     */
    function stream_write($aData) {

It is generally recommended to explicitly declare the visibility for methods.

        if ($this->write) {
            $left = substr(self::$string[$this->path], 0, $this->position);
            $right = substr(self::$string[$this->path], $this->position + strlen($aData));
            self::$string[$this->path] = $left . $aData . $right;
            $this->position += strlen($aData);
            return strlen($aData);
        } else {
            return 0;
        }
    }

    /**
     * Return current position
     * @return int
     */
    function stream_tell() {

It is generally recommended to explicitly declare the visibility for methods.

        return $this->position;
    }

    /**
     * Return if EOF
     * @return boolean
     */
    function stream_eof() {

It is generally recommended to explicitly declare the visibility for methods.

        return $this->position >= strlen(self::$string[$this->path]);
    }

    /**
     * Seek to new position
     * @param int $aOffset
     * @param int $aWhence
     * @return boolean

Should the return type not be boolean|null?

     */
    function stream_seek($aOffset, $aWhence) {

It is generally recommended to explicitly declare the visibility for methods.

        switch ($aWhence) {
            case SEEK_SET:
                $this->position = $aOffset;
                if ($aOffset > strlen(self::$string[$this->path])) {
                    $this->stream_truncate($aOffset);
                }
                return true;
                break;

break is not strictly necessary here and could be removed.

            //XXX Code coverage testing shows PHP truncates automatically for SEEK_CUR
            case SEEK_CUR:
                $this->position += $aOffset;
                return true;
                break;

break is not strictly necessary here and could be removed.

            case SEEK_END:
                $this->position = strlen(self::$string[$this->path]) + $aOffset;
                if (($this->position + $aOffset) > strlen(self::$string[$this->path])) {
                    $this->stream_truncate(strlen(self::$string[$this->path]) + $aOffset);
                }
                return true;
                break;

break is not strictly necessary here and could be removed.

            default:
                return false;
        }
    }

    /**
     * Truncate to given size
     * @param int $aSize
     */
    public function stream_truncate($aSize) {
        if (strlen(self::$string[$this->path]) > $aSize) {
            self::$string[$this->path] = substr(self::$string[$this->path], 0, $aSize);
        } else if (strlen(self::$string[$this->path]) < $aSize) {
            self::$string[$this->path] = str_pad(self::$string[$this->path], $aSize, "\0", STR_PAD_RIGHT);
        }
        return true;
    }

    /**
     * Return info about stream
     * @return array
     */
    public function stream_stat() {
        return array('dev' => 0,
            'ino' => 0,
            'mode' => 0,
            'nlink' => 0,
            'uid' => 0,
            'gid' => 0,
            'rdev' => 0,
            'size' => strlen(self::$string[$this->path]),
            'atime' => 0,
            'mtime' => 0,
            'ctime' => 0,
            'blksize' => -1,
            'blocks' => -1);
    }

    /**
     * Return info about stream
     * @param string $aPath
     * @param array $aOptions
     * @return array
     */
    public function url_stat($aPath, $aOptions) {

The parameter $aOptions is not used and could be removed.

        $resource = fopen($aPath, 'r');
        return fstat($resource);
    }

    public static function register() {
        if (!self::$registered) {
            if (in_array("string", stream_get_wrappers())) {
                stream_wrapper_unregister("string");
            }
            stream_wrapper_register("string", __CLASS__);
            self::$registered = true;
        }
    }

    public static function unregister() {
        if (self::$registered) {
            stream_wrapper_unregister('string');
        }
    }

}