App\Component\Console\Input

Complexity

Total Complexity

12

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Test Coverage

Coverage

97.37%

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	value()	0	16	2
A	openStream()	0	10	2
A	getStreamName()	0	3	1
A	closeStream()	0	6	2
A	getStreamHandler()	0	4	1
A	setMaxLength()	0	4	1
A	__construct()	0	9	2
A	getMaxLength()	0	3	1

<?php

namespace App\Component\Console;

class Input
{

    const STREAM_STDIN = 'php://stdin';
    const STREAM_MEMORY = 'php://memory';
    const STREAM_TEMP = 'php://temp';
    const STREAM_MODE_READ = 'r';
    const STREAM_MODE_APPEND = 'r+';
    const STREAM_MODE_WRITE = 'w';
    const STREAM_MODE_WRITE_APPEND = 'w+';
    const DEBUGER = 'phpdbg';

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

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

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

    /**
     * $maxLength
     *
     * @var int
     */
    protected $maxLength;

    /**
     * instanciate
     *
     * @param string $streamName
     */
    public function __construct(
        string $streamName = self::STREAM_STDIN,
        string $streamMode = self::STREAM_MODE_WRITE_APPEND
    ) {
        $this->streamName = (php_sapi_name() == self::DEBUGER)
            ? self::STREAM_MEMORY
            : $streamName;
        $this->streamMode = $streamMode;
        $this->setMaxLength(1);
    }

    /**
     * return the input value
     *
     * @return string
     */
    public function value(string $forcedValue = ''): string
    {
        $handle = $this->getStreamHandler();

Are you sure the assignment to $handle is correct as $this->getStreamHandler() targeting App\Component\Console\Input::getStreamHandler() seems to always return null.

        //readline_callback_handler_install('', function () { });
        if (!empty($forcedValue)) {
            $this->setMaxLength(strlen($forcedValue));
            rewind($handle);

$handle of type void is incompatible with the type resource expected by parameter $handle of rewind().

            fwrite($handle, $forcedValue);

$handle of type void is incompatible with the type resource expected by parameter $handle of fwrite().

        }
        $value = stream_get_contents(
            $handle,

$handle of type void is incompatible with the type resource expected by parameter $handle of stream_get_contents().

            $this->getMaxLength(),
            0
        );
        $this->closeStream();
        return $value;
    }

    /**
     * set stream max length
     *
     * @return Input
     */
    public function setMaxLength(int $len): Input
    {
        $this->maxLength = $len;
        return $this;
    }

    /**
     * returns stream handler
     *
     * @return int
     */
    protected function getMaxLength(): int
    {
        return $this->maxLength;
    }

    /**
     * returns stream handler
     *
     * @return void
     */
    protected function getStreamHandler()
    {
        $this->openStream();
        return $this->streamHandler;
    }

    /**
     * returns stream name
     *
     * @return string
     */
    protected function getStreamName(): string
    {
        return $this->streamName;
    }

    /**
     * open resource
     *
     * @return Input
     */
    protected function openStream(): Input
    {
        if (!is_resource($this->streamHandler)) {
            $this->streamHandler = fopen(

It seems like fopen($this->getStreamName(), $this->streamMode, false) can also be of type false. However, the property $streamHandler is declared as type resource. Maybe add an additional type check?

                $this->getStreamName(),
                $this->streamMode,
                false
            );
        }
        return $this;
    }

    /**
     * close resource
     *
     * @return Input
     */
    protected function closeStream(): Input
    {
        if (is_resource($this->streamHandler)) {
            fclose($this->streamHandler);
        }
        return $this;
    }
}