Deployer\Task\Task

Complexity

Total Complexity

22

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Coupling/Cohesion

Components	6
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	1	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	run()	0	20	4
A	getName()	0	4	1
A	getDescription()	0	4	1
A	desc()	0	5	1
A	once()	0	5	1
A	isOnce()	0	4	1
A	onlyOn()	0	5	2
A	onlyForStage()	0	5	2
A	getOnlyOn()	0	4	1
A	getOnlyForStage()	0	4	1
A	runForStages()	0	8	2
A	runOnServer()	0	8	2
A	isPrivate()	0	4	1
A	setPrivate()	0	5	1

<?php
/* (c) Anton Medvedev <anton@medv.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Deployer\Task;

class Task
{
    /**
     * @var string
     */
    private $name;

    /**
     * Task code.
     * @var callable
     */
    private $callback;

    /**
     * Task description.
     * @var string
     */
    private $description;

    /**
     * Should run this task only once and locally?
     * @var bool
     */
    private $once = false;

    /**
     * List of stages in which this task should be executed.
     * @var array  Key contains stage names.
     */
    private $onlyForStage = [];

    /**
     * List of servers names there this task should be executed.
     * @var array  Key contains server names.
     */
    private $onlyOn = [];

    /**
     * Make task internal and not visible in CLI.
     * @var bool
     */
    private $private = false;

    /**
     * @param string $name Tasks name
     * @param \Closure $callback Task code.
     */
    public function __construct($name, \Closure $callback)
    {
        $this->name = $name;
        $this->callback = $callback;
    }

    /**
     * Run task.
     *
     * @param Context $context
     */
    public function run(Context $context)
    {
        Context::push($context);
        $env = $context->getEnvironment();

        // Save cd's working_path path.
        if ($env !== null) {
            $workingPath = $env->get('working_path', false);
        }

        // Call tasks.
        call_user_func($this->callback);

        // Restore cd's working_path path.
        if ($env !== null && isset($workingPath)) {
            $env->set('working_path', $workingPath);
        }

        Context::pop();
    }

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

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

    /**
     * Set task description.
     * @param string $description
     * @return $this
     */
    public function desc($description)
    {
        $this->description = $description;
        return $this;
    }

    /**
     * Set this task local and run only once.
     * @return $this
     */
    public function once()
    {
        $this->once = true;
        return $this;
    }

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

    /**
     * @param array|string $servers
     * @return $this
     */
    public function onlyOn($servers = [])
    {
        $this->onlyOn = array_flip(is_array($servers) ? $servers : func_get_args());
        return $this;
    }

    /**
     * Indicate for which stages this task should be run.
     *
     * @param array|string $stages
     * @return $this
     */
    public function onlyForStage($stages = [])
    {
        $this->onlyForStage = array_flip(is_array($stages) ? $stages: func_get_args());
        return $this;
    }

    /**
     * @return array
     */
    public function getOnlyOn()
    {
        return $this->onlyOn;
    }

    /**
     * @return array
     */
    public function getOnlyForStage()
    {
        return $this->onlyForStage;
    }

    /**
     * Decide to run or not to run for these stages.
     * @param $stages
     * @return bool
     */
    public function runForStages($stages)
    {
        if (empty($this->onlyForStage)) {
            return true;
        } else {
            return count(array_intersect($stages, array_keys($this->onlyForStage))) > 0;
        }
    }

    /**
     * Decide to run or not to run on this server.
     * @param string $serverName
     * @return bool
     */
    public function runOnServer($serverName)
    {
        if (empty($this->onlyOn)) {
            return true;
        } else {
            return array_key_exists($serverName, $this->onlyOn);
        }
    }

    /**
     * @return boolean
     */
    public function isPrivate()
    {
        return $this->private;
    }

    /**
     * Mark task as private.
     */
    public function setPrivate()
    {
        $this->private = true;
        return $this;
    }
}