Consolidation\SiteProcess\ProcessBase

Complexity

Total Complexity

20

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getAlias()	0	4	1
A	setAlias()	0	4	1
A	io()	0	4	1
A	setIo()	0	4	1
A	getVerbose()	0	4	1
A	setVerbose()	0	4	1
A	getSimulated()	0	4	1
A	setSimulated()	0	4	1
A	getLogger()	0	4	1
A	setLogger()	0	4	1
B	start()	0	22	7
A	realTime()	0	8	2
A	showRealtime()	0	3	1

<?php

namespace Consolidation\SiteProcess;

use Drush\Drush;
use Psr\Log\LoggerInterface;
use Robo\Common\IO;
use Robo\Contract\IOAwareInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Process\Process;

/**
 * A wrapper around Symfony Process.
 *
 * - Supports simulated mode. Typically enabled via a --simulate option.
 * - Supports verbose mode - logs all runs.
 */
class ProcessBase extends Process
{
    /**
     * @var SymfonyStyle
     */
    protected $io;

    private $simulated = false;

    private $verbose = false;

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

    /**
     * @return string
     */
    public function getAlias()
    {
        return $this->alias;
    }

    /**
     * @param string $aliasName
     */
    public function setAlias($aliasName)
    {
        $this->alias = $aliasName;
    }

    /**
     * @var LoggerInterface
     */
    private $logger;

    /**
     * @return SymfonyStyle $io
     */
    public function io()
    {
        return $this->io;
    }

    /**
     * @param $io
     */
    public function setIo($io)
    {
        $this->io = $io;
    }

    /**
     * @return bool
     */
    public function getVerbose()
    {
        return $this->verbose;
    }

    /**
     * @param bool $verbose
     */
    public function setVerbose($verbose)
    {
        $this->verbose = $verbose;
    }

    /**
     * @return bool
     */
    public function getSimulated()
    {
        return $this->simulated;
    }

    /**
     * @param bool $simulated
     */
    public function setSimulated($simulated)
    {
        $this->simulated = $simulated;
    }

    /**
     * @return LoggerInterface
     */
    public function getLogger()
    {
        return $this->logger;
    }

    /**
     * @param LoggerInterface $logger
     */
    public function setLogger($logger)
    {
        $this->logger = $logger;
    }

    /**
     * @inheritDoc
     */
    public function start(callable $callback = null)
    {
        $cmd = $this->getCommandLine();
        if ($this->getSimulated()) {
            $this->getLogger()->notice('Simulating: ' . $cmd);
            // Run a command that always succeeds.
            $this->setCommandLine('exit 0');
        } elseif ($this->getVerbose()) {
            if ($this->getAlias()) {
                $this->io()->section('Start: ' . $cmd);
            }
            $this->getLogger()->info('Executing: ' . $cmd);
        }
        parent::start($callback);
        // Set command back to original value in case anyone asks.
        if ($this->getSimulated()) {
            $this->setCommandLine($cmd);
        }
        if ($this->getAlias() && $this->getVerbose()) {
            $this->io()->section('End: ' . $cmd);
        }
    }

    /**
     * Helper method when you want real-time output from a Process call. See
     * @param $type
     * @param $buffer
     */
    public static function realTime($type, $buffer)
    {
        if (Process::ERR === $type) {
            echo $buffer;
        } else {
            echo $buffer;
        }
    }

    /**
     * Should return a closure. For now return a callable.
     *
     * @return callable
     */
    public static function showRealtime() {
        return '\Consolidation\SiteProcess\ProcessBase::realTime';
    }
}