PhpSchool\Terminal\UnixTerminal

Complexity

Total Complexity

49

Size/Duplication

Total Lines	310
Duplicated Lines	0 %

Importance

Changes	7
Bugs	1	Features	1

34 Methods

Rating	Name	Duplication	Size	Complexity
A	moveCursorToRow()	0	3	1
A	enableCanonicalMode()	0	5	2
A	moveCursorToColumn()	0	3	1
A	getColourSupport()	0	3	2
A	isCanonicalMode()	0	3	1
A	moveCursorToTop()	0	3	1
A	getWidth()	0	3	2
A	isEchoBack()	0	3	1
A	getHeight()	0	3	2
A	showSecondaryScreen()	0	3	1
A	supportsColour()	0	7	4
A	__destruct()	0	3	1
A	clearDown()	0	3	1
A	disableCanonicalMode()	0	5	2
A	onSignal()	0	7	2
A	clean()	0	5	2
A	enableCursor()	0	3	1
A	mustBeInteractive()	0	8	3
A	__construct()	0	6	1
A	getOriginalConfiguration()	0	3	2
A	enableEchoBack()	0	4	1
A	refreshDimensions()	0	4	1
A	write()	0	3	1
A	isInteractive()	0	3	2
A	clear()	0	3	1
A	showPrimaryScreen()	0	3	1
A	restoreOriginalConfiguration()	0	3	1
A	handleSignal()	0	4	2
A	getOriginalCanonicalMode()	0	4	1
A	clearLine()	0	3	1
A	read()	0	7	1
A	initTerminal()	0	8	1
A	disableCursor()	0	3	1
A	disableEchoBack()	0	4	1

<?php declare(ticks=1);

namespace PhpSchool\Terminal;

use PhpSchool\Terminal\Exception\NotInteractiveTerminal;
use PhpSchool\Terminal\IO\InputStream;
use PhpSchool\Terminal\IO\OutputStream;

/**
 * @author Michael Woodward <mikeymike.mw@gmail.com>
 * @author Aydin Hassan <aydin@hotmail.co.uk>
 */
class UnixTerminal implements Terminal
{
    /**
     * @var bool
     */
    private $isCanonical;

    /**
     * Whether terminal echo back is enabled or not.
     * Eg. user key presses and the terminal immediately shows it.
     *
     * @var bool
     */
    private $echoBack = true;

    /**
     * @var int
     */
    private $width;

    /**
     * @var int
     */
    private $height;
    
    /**
     * @var int;
     */
    private $colourSupport;

    /**
     * @var string
     */
    private $originalConfiguration;

    /**
     * @var array
     */
    private $signalHandlers = [];

    /**
     * @var InputStream
     */
    private $input;

    /**
     * @var OutputStream
     */
    private $output;

    public function __construct(InputStream $input, OutputStream $output)
    {
        $this->initTerminal();

        $this->input = $input;
        $this->output = $output;
    }

    private function initTerminal() : void
    {
        $this->getOriginalConfiguration();
        $this->getOriginalCanonicalMode();

        pcntl_async_signals(true);

        $this->onSignal(SIGWINCH, [$this, 'refreshDimensions']);
    }

    private function getOriginalCanonicalMode() : void
    {
        exec('stty -a', $output);
        $this->isCanonical = (strpos(implode("\n", $output), ' icanon') !== false);
    }

    private function getOriginalConfiguration() : string
    {
        return $this->originalConfiguration ?: $this->originalConfiguration = exec('stty -g');
    }

    public function getWidth() : int
    {
        return $this->width ?: $this->width = (int) exec('tput cols');
    }

    public function getHeight() : int
    {
        return $this->height ?: $this->height = (int) exec('tput lines');
    }

    public function getColourSupport() : int
    {
        return $this->colourSupport ?: $this->colourSupport = (int) exec('tput colors');
    }

    private function refreshDimensions() : void
    {
        $this->width  = (int) exec('tput cols');
        $this->height = (int) exec('tput lines');
    }

    public function onSignal(int $signo, callable $handler) : void
    {
        if (!isset($this->signalHandlers[$signo])) {
            $this->signalHandlers[$signo] = [];
            pcntl_signal($signo, [$this, 'handleSignal']);
        }
        $this->signalHandlers[$signo][] = $handler;
    }

    public function handleSignal(int $signo) : void
    {
        foreach ($this->signalHandlers[$signo] as $signalHandler) {
            $signalHandler();
        }
    }

    /**
     * Disables echoing every character back to the terminal. This means
     * we do not have to clear the line when reading.
     */
    public function disableEchoBack() : void
    {
        exec('stty -echo');
        $this->echoBack = false;
    }

    /**
     * Enable echoing back every character input to the terminal.
     */
    public function enableEchoBack() : void
    {
        exec('stty echo');
        $this->echoBack = true;
    }

    /**
     * Is echo back mode enabled
     */
    public function isEchoBack() : bool
    {
        return $this->echoBack;
    }

    /**
     * Disable canonical input (allow each key press for reading, rather than the whole line)
     *
     * @see https://www.gnu.org/software/libc/manual/html_node/Canonical-or-Not.html
     */
    public function disableCanonicalMode() : void
    {
        if ($this->isCanonical) {
            exec('stty -icanon');
            $this->isCanonical = false;
        }
    }

    /**
     * Enable canonical input - read input by line
     *
     * @see https://www.gnu.org/software/libc/manual/html_node/Canonical-or-Not.html
     */
    public function enableCanonicalMode() : void
    {
        if (!$this->isCanonical) {
            exec('stty icanon');
            $this->isCanonical = true;
        }
    }

    /**
     * Is canonical mode enabled or not
     */
    public function isCanonicalMode() : bool
    {
        return $this->isCanonical;
    }

    /**
     * Restore the original terminal configuration
     */
    public function restoreOriginalConfiguration() : void
    {
        exec('stty ' . $this->getOriginalConfiguration());
    }

    /**
     * Check if the Input & Output streams are interactive. Eg - they are
     * connected to a terminal.
     *
     * @return bool
     */
    public function isInteractive() : bool
    {
        return $this->input->isInteractive() && $this->output->isInteractive();
    }

    /**
     * Assert that both the Input & Output streams are interactive. Throw
     * `NotInteractiveTerminal` if not.
     */
    public function mustBeInteractive() : void
    {
        if (!$this->input->isInteractive()) {
            throw NotInteractiveTerminal::inputNotInteractive();
        }

        if (!$this->output->isInteractive()) {
            throw NotInteractiveTerminal::outputNotInteractive();
        }
    }

    /**
     * @see https://github.com/symfony/Console/blob/master/Output/StreamOutput.php#L95-L102
     */
    public function supportsColour() : bool
    {
        if (DIRECTORY_SEPARATOR === '\\') {
            return false !== getenv('ANSICON') || 'ON' === getenv('ConEmuANSI') || 'xterm' === getenv('TERM');
        }

        return $this->isInteractive();
    }

    public function clear() : void
    {
        $this->output->write("\033[2J");
    }

    public function clearLine() : void
    {
        $this->output->write("\033[2K");
    }

    /**
     * Erase screen from the current line down to the bottom of the screen
     */
    public function clearDown() : void
    {
        $this->output->write("\033[J");
    }

    public function clean() : void
    {
        foreach (range(0, $this->getHeight()) as $rowNum) {
            $this->moveCursorToRow($rowNum);
            $this->clearLine();
        }
    }

    public function enableCursor() : void
    {
        $this->output->write("\033[?25h");
    }

    public function disableCursor() : void
    {
        $this->output->write("\033[?25l");
    }

    public function moveCursorToTop() : void
    {
        $this->output->write("\033[H");
    }

    public function moveCursorToRow(int $rowNumber) : void
    {
        $this->output->write(sprintf("\033[%d;0H", $rowNumber));
    }

    public function moveCursorToColumn(int $column) : void
    {
        $this->output->write(sprintf("\033[%dC", $column));
    }

    public function showSecondaryScreen() : void
    {
        $this->output->write("\033[?47h");
    }

    public function showPrimaryScreen() : void
    {
        $this->output->write("\033[?47l");
    }

    /**
     * Read bytes from the input stream
     */
    public function read(int $bytes): string
    {
        $buffer = '';
        $this->input->read($bytes, function ($data) use (&$buffer) {
            $buffer .= $data;
        });
        return $buffer;
    }

    /**
     * Write to the output stream
     */
    public function write(string $buffer): void
    {
        $this->output->write($buffer);
    }

    /**
     * Restore the original terminal configuration on shutdown.
     */
    public function __destruct()
    {
        $this->restoreOriginalConfiguration();
    }
}