Consolidation\SiteProcess\ProcessBase

Complexity

Total Complexity

15

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
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
A	start()	0	18	4
A	realTime()	0	8	2
A	io()	0	4	1
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 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()) {
            $this->io()->section('Start: ' . $cmd);
            $this->getLogger()->info('Executing: ' . $cmd);
            $this->io()->section('End: ' . $cmd);
        }
        parent::start($callback);
        // Set command back to original value in case anyone asks.
        if ($this->getSimulated()) {
            $this->setCommandLine($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';
    }
}