Reallyli\LaravelDeployer\DeployFile

Complexity

Total Complexity

24

Size/Duplication

Total Lines	191
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__toString()	0	18	2
A	get()	0	4	1
A	updateStrategy()	0	8	2
A	store()	0	13	2
A	renderDefault()	0	6	1
A	renderInclude()	0	8	1
A	renderStrategies()	0	16	1
A	renderOptions()	0	10	1
A	renderHosts()	0	16	2
A	renderLocalhost()	0	6	2
A	renderHooks()	0	17	3
A	renderHostOptions()	0	20	5

<?php

namespace Reallyli\LaravelDeployer;

use Illuminate\Filesystem\Filesystem;
use Reallyli\LaravelDeployer\Concerns\DeployBuilder;
use Reallyli\LaravelDeployer\Concerns\RendersCode;

class DeployFile
{
    use RendersCode;
    use DeployBuilder;

    const REPLACEMENT_KEYS = [
        'include',
        'default',
        'options',
        'hosts',
        'localhost',
        'strategies',
        'hooks',
    ];

    const SPECIAL_HOST_KEYS = [
        'become',
        'hostname',
        'roles',
        'stage',
        'user',
        'port',
        'configFile',
        'identityFile',
        'forwardAgent',
        'multiplexing',
    ];

    protected $data;
    protected $filesystem;

    public function __construct($data = [])
    {
        $this->data = collect($data);
        $this->filesystem = app(Filesystem::class);
    }

    public function __toString()
    {
        $ds = DIRECTORY_SEPARATOR;
        $stub = $this->filesystem->get(__DIR__."{$ds}stubs{$ds}deploy.stub");

        foreach (static::REPLACEMENT_KEYS as $key) {
            $value = call_user_func([$this, 'render'.ucfirst($key)]);
            $stub = preg_replace('/{{'.$key.'}}/', $value, $stub);
        }

        // Trim empty lines at the end of file.
        $stub = preg_replace('/\n+$/', '', $stub);

        // Ensure stub has no more than two consecutive empty lines.
        $stub = preg_replace('/\n{3,}/', "\n\n", $stub);

        return $stub;
    }

    public function get($key)
    {
        return collect($this->data->get($key, []));
    }

    public function updateStrategy($strategy)
    {
        if (is_string($strategy)) {
            $this->data->put('default', $strategy);
        }

        return $this;
    }

    public function store()
    {
        $path = $this->getDeployFileFullPath();
        $dir = dirname($path);

        if (! is_dir($dir)) {
            mkdir($dir, 0777, true);
        }

        $this->filesystem->put($path, (string) $this);

        return $path;
    }

    protected function renderDefault()
    {
        $default = $this->data->get('default', 'basic');

        return "set('strategy', '$default');";
    }

    protected function renderInclude()
    {
        return $this->get('include')
            ->map(function ($include) {
                return "require '$include';";
            })
            ->implode("\n");
    }

    protected function renderStrategies()
    {
        return $this->get('strategies')
            ->map(function ($tasks) {
                return collect($tasks)->map(function ($task) {
                    return "    '$task',";
                })->implode("\n");
            })
            ->map(function ($tasks, $strategy) {
                $title = title_case(str_replace('_', ' ', $strategy)).' Strategy';
                $slug = snake_case($strategy);

                return "desc('$title');\ntask('strategy:$slug', [\n$tasks\n]);";
            })
            ->implode("\n\n");
    }

    protected function renderOptions()
    {
        return $this->get('options')
            ->map(function ($value, $key) {
                $value = $this->render($value, 0, false);

                return "set('$key', $value);";
            })
            ->implode("\n");
    }

    protected function renderHosts()
    {
        return $this->get('hosts')
            ->map(function ($options) {
                return $this->renderHostOptions($options);
            })
            ->map(function ($options, $hostname) {
                $multipleHostName = explode(',', $hostname);
                if (count($multipleHostName) > 1) {
                    $hostname = implode("','", $multipleHostName);
                }

                return "host('$hostname')$options;";
            })
            ->implode("\n\n");
    }

    protected function renderLocalhost()
    {
        $options = $this->renderHostOptions($this->get('localhost'));

        return empty($options) ? '' : "localhost()$options;";
    }

    protected function renderHooks()
    {
        return $this->get('hooks')
            ->flatMap(function ($tasks, $hook) {
                return collect($tasks)->map(function ($task) use ($hook) {
                    switch ($hook) {
                        case 'success':
                            return "after('success', '$task');";
                        case 'fail':
                            return "after('deploy:failed', '$task');";
                        default:
                            return "after('hook:$hook', '$task');";
                    }
                });
            })
            ->implode("\n");
    }

    protected function renderHostOptions($options)
    {
        $options = collect($options)->map(function ($value, $key) {
            if ($key === 'sshOptions' && is_array($value)) {
                return collect($value)->map(function ($sshValue, $sshKey) {
                    $sshValue = $this->render($sshValue, 1, false);

                    return "    ->addSshOption('$sshKey', $sshValue)";
                })->implode("\n");
            }

            $value = $this->render($value, 1, false);

            return in_array($key, static::SPECIAL_HOST_KEYS)
                ? "    ->$key($value)"
                : "    ->set('$key', $value)";
        })->implode("\n");

        return empty($options) ? '' : "\n$options";
    }
}