Consolidation\SiteProcess\SiteProcess

Complexity

Total Complexity

13

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	setWorkingDirectory()	0	5	1
A	useSiteRoot()	0	8	2
A	processArgs()	0	25	2
A	getTransport()	0	8	2
A	getCommandLine()	0	9	2
A	start()	0	5	1
A	wait()	0	5	1
A	interpolate()	0	10	1

<?php
namespace Consolidation\SiteProcess;

use Consolidation\SiteAlias\AliasRecord;
use Consolidation\SiteProcess\Util\ArgumentProcessor;
use Consolidation\SiteProcess\Transport\LocalTransport;
use Consolidation\SiteProcess\Transport\SshTransport;
use Consolidation\Config\Util\Interpolator;

/**
 * A wrapper around Symfony Process that uses site aliases
 * (https://github.com/consolidation/site-alias)
 *
 * - Interpolate arguments using values from the alias
 *   e.g. `$process = new SiteProcess($alias, ['git', '-C', '{{root}}']);`
 * - Make remote calls via ssh as if they were local.
 */
class SiteProcess extends ProcessBase
{
    /** @var AliasRecord */
    protected $siteAlias;
    /** @var string */
    protected $args;
    /** @var string */
    protected $options;
    /** @var string */
    protected $optionsPassedAsArgs;
    /** @var string */
    protected $cd;

    /**
     * Process arguments and options per the site alias and build the
     * actual command to run.
     */
    public function __construct(AliasRecord $siteAlias, $args, $options = [], $optionsPassedAsArgs = [])
    {
        $this->siteAlias = $siteAlias;
        $this->args = $args;
        $this->options = $options;

It seems like $options of type array is incompatible with the declared type string of property $options.

        $this->optionsPassedAsArgs = $optionsPassedAsArgs;

It seems like $optionsPassedAsArgs of type array is incompatible with the declared type string of property $optionsPassedAsArgs.

        parent::__construct([]);
    }

    /**
     * @inheritdoc
     */
    public function setWorkingDirectory($cwd)
    {
        $this->cd = $cwd;
        return parent::setWorkingDirectory($cwd);
    }

    public function useSiteRoot()
    {
        if (!$this->siteAlias->hasRoot()) {
            return $this;
        }

        return $this->setWorkingDirectory($this->siteAlias->root());
    }

    /**
     * Take all of our individual arguments and process them for use.
     */
    protected function processArgs()
    {
        $transport = static::getTransport($this->siteAlias);
        $transport->configure($this);

        $processor = new ArgumentProcessor();
        $selectedArgs = $processor->selectArgs(
            $this->siteAlias,
            $this->args,

$this->args is of type string, but the function expects a array.

            $this->options,

$this->options is of type string, but the function expects a array.

            $this->optionsPassedAsArgs

$this->optionsPassedAsArgs is of type string, but the function expects a array.

        );

        // Ask the transport to drop in a 'cd' if needed.
        if ($this->cd) {
            $selectedArgs = $transport->addChdir($this->cd, $selectedArgs);
        }

        // Do any necessary interpolation on the selected arguments.
        $processedArgs = $this->interpolate($selectedArgs);

        // Wrap the command with 'ssh' or some other transport if this is
        // a remote command; otherwise, leave it as-is.
        return $transport->wrap($processedArgs);
    }

    /**
     * TODO: Could we perhaps support variable transport mechanisms?
     */
    protected static function getTransport(AliasRecord $siteAlias)
    {
        if ($siteAlias->isLocal()) {
            return new LocalTransport();
        }

        return new SshTransport($siteAlias);
    }

    /**
     * @inheritDoc
     */
    public function getCommandLine()
    {
        $commandLine = parent::getCommandLine();
        if (empty($commandLine)) {
            $this->setCommandLine($this->processArgs());
            $commandLine = parent::getCommandLine();
        }
        return $commandLine;
    }

    /**
     * @inheritDoc
     */
    public function start(callable $callback = null)
    {
        $cmd = $this->getCommandLine();

$cmd is not used, you could remove the assignment.

        parent::start($callback);
    }

    /**
     * @inheritDoc
     */
    public function wait(callable $callback = null)
    {
        $return = parent::wait($callback);
        return $return;
    }

    /**
     * interpolate examines each of the arguments in the provided argument list
     * and replaces any token found therein with the value for that key as
     * pulled from the given site alias.
     *
     * Example: "git -C {{root}} status"
     *
     * The token "{{root}}" will be converted to a value via $siteAlias->get('root').
     * The result will replace the token.
     *
     * It is possible to use dot notation in the keys to access nested elements
     * within the site alias record.
     *
     * @param AliasRecord $siteAlias

There is no parameter named $siteAlias. Was it maybe removed?

     * @param type $args
     * @return type
     */
    protected function interpolate($args)
    {
        $interpolator = new Interpolator();
        return array_map(
            function ($arg) use ($interpolator) {
                return $interpolator->interpolate($this->siteAlias, $arg, false);
            },
            $args
        );
    }
}