A17\Twill\Commands\CapsuleInstall

Complexity

Total Complexity

55

Size/Duplication

Total Lines	401
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	1

29 Methods

Rating	Name	Duplication	Size	Complexity
A	isFullUrl()	0	3	1
A	makeCapsuleName()	0	5	1
A	repositoryExists()	0	19	3
A	getService()	0	3	1
A	cleanTempFile()	0	16	3
A	installCapsule()	0	20	6
A	renameToCapsule()	0	7	1
A	unzipShellCommandExists()	0	5	1
A	getTempFileName()	0	5	1
A	getUnzippedPath()	0	7	1
A	makeDir()	0	4	2
A	canInstallCapsule()	0	18	3
A	getBranch()	0	3	1
A	__construct()	0	5	1
A	uncompress()	0	17	3
A	checkParameters()	0	15	4
A	handle()	0	13	2
A	configureInstaller()	0	31	3
A	unzipWithShell()	0	9	1
A	download()	0	14	3
A	getCapsuleDirectory()	0	3	1
A	getCapsulePrefix()	0	3	1
A	getModule()	0	3	1
A	displayConfigurationSummary()	0	27	1
A	getRepositoryPrefix()	0	9	2
A	unzipWithExtension()	0	23	4
A	getRepositoryUrlPrefix()	0	3	1
A	directoryExists()	0	3	1
A	getZipAddress()	0	6	1

<?php

namespace A17\Twill\Commands;

use Exception;
use GuzzleHttp\Client;
use A17\Twill\Models\User;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Hash;
use A17\Twill\Services\Capsules\Manager;

class CapsuleInstall extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'twill:capsule:install
                               {capsule : Capsule name (posts) in plural, Github repository (area17/capsule-posts) or full URL of the Capsule git repository}
                               {--require : Require as a Composer package. Can receive maitainer updates.}
                               {--copy : Copy Capsule code. Cannot receive updates.}
                               {--branch=stable : Repository branch}
                               {--prefix=twill-capsule : Capsule repository name prefix}
                               {--service=github.com : Service URL (defaults to Github)}';

    /**
     * The console command description.
     *
     * @var string
     */

    protected $description = 'Install a Twill Capsule';

    protected $repositoryUri;

    protected $capsule;

    protected $capsuleName;

    protected $repositoryUrl;

    /**
     * Create a new console command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();

        $this->manager = new Manager();

The property manager does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }

    /**
     * @return string
     */
    private function getUnzippedPath(): string
    {
        return $this->capsule['base_path'] .
            '/' .
            $this->capsuleName .
            '-' .
            $this->getBranch();
    }

    /**
     * Create super admin account.
     *
     * @return void
     */
    public function handle()
    {
        if (!$this->checkParameters()) {
            return 255;
        }

        $this->configureInstaller();

        $this->displayConfigurationSummary();

        $this->installCapsule();

        return 0;
    }

    protected function checkParameters()
    {
        if (!$this->option('require') && !$this->option('copy')) {
            $this->error('Missing mandatory strategy: --require or --copy.');

            return false;
        }

        if ($this->option('require')) {
            $this->error('Require strategy not implemented yet.');

            return false;
        }

        return true;
    }

    protected function configureInstaller()
    {
        $capsule = $this->argument('capsule');

        if ($this->isFullUrl($capsule)) {
            $url = $capsule;

            $capsule = $this->extractRepositoryFromUrl($capsule);

The method extractRepositoryFromUrl() does not exist on A17\Twill\Commands\CapsuleInstall. Since you implemented __call, consider adding a @method annotation.

Are you sure the assignment to $capsule is correct as $this->extractRepositoryFromUrl($capsule) targeting A17\Twill\Commands\CapsuleInstall::__call() seems to always return null.

        } else {
            $capsule = Str::snake(Str::kebab($capsule));

It seems like $capsule can also be of type array; however, parameter $value of Illuminate\Support\Str::kebab() does only seem to accept string, maybe add an additional type check?

            if (!Str::contains($capsule, '/')) {
                $capsule = $this->getRepositoryPrefix() . "-$capsule";
            }

            $url = $this->getRepositoryUrlPrefix() . "/$capsule";
        }

        $this->repositoryUri = $capsule;

        $this->capsuleName = Str::afterLast($capsule, '/');

        $this->repositoryUrl = $url;

        $this->name = $this->makeCapsuleName($capsule);

        $this->namespace = Str::studly($this->name);

The property namespace does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->capsule = $this->manager->makeCapsule([
            'name' => $this->namespace,
            'enabled' => true,
        ]);
    }

    protected function isFullUrl($capsule)

The parameter $capsule is not used and could be removed.

    {
        return false;
    }

    protected function getRepositoryUrlPrefix()
    {
        return 'https://' . $this->getService();
    }

    protected function getRepositoryPrefix()
    {
        $prefix = Config::get('twill.capsules.capsule_repository_prefix');

        if (filled($capsule = $this->getCapsulePrefix())) {
            $prefix .= '/' . $this->getCapsulePrefix();
        }

        return $prefix;
    }

    protected function getBranch()
    {
        return $this->option('branch');
    }

    protected function getZipAddress()
    {
        return sprintf(
            '%s/archive/refs/heads/%s.zip',
            $this->repositoryUrl,
            $this->getBranch()
        );
    }

    protected function makeCapsuleName($capsule)
    {
        $capsule = Str::afterLast($capsule, '/');

        return Str::after($capsule, $this->getCapsulePrefix() . '-');
    }

    protected function getCapsulePrefix()
    {
        return $this->option('prefix');
    }

    public function getService()
    {
        return $this->option('service');
    }

    protected function displayConfigurationSummary()
    {
        $this->info('Configuration summary');

        $this->info('---------------------');

        $this->info('Name prefix: ' . $this->getCapsulePrefix());

        $this->info("Capsule repository URI: {$this->repositoryUri}");

        $this->info("Capsule name: {$this->capsuleName}");

        $this->info("Name: {$this->name}");

        $this->info('Module: ' . $this->getModule());

        $this->info("Namespace: {$this->namespace}");

        $this->info('Service: ' . $this->getService());

        $this->info('Branch: ' . $this->getBranch());

        $this->info("Repository URL: {$this->repositoryUrl}");

        $this->info('Zip URL: ' . $this->getZipAddress());

        $this->info('Temporary file: ' . $this->getTempFileName());
    }

    protected function getModule()
    {
        return Str::camel($this->name);
    }

    protected function canInstallCapsule()
    {
        if ($this->manager->capsuleExists($this->getModule())) {
            $this->error('A capsule with this name already exists!');

            return false;
        }

        if ($this->directoryExists()) {
            $this->error(
                'Capsule directory already exists: ' .
                    $this->getCapsuleDirectory()
            );

            return false;
        }

        return true;
    }

    protected function installCapsule()
    {
        $installed =
            $this->canInstallCapsule() &&
            $this->download() &&
            $this->uncompress(
                $this->getTempFileName(),
                $this->capsule['base_path']
            ) &&
            $this->renameToCapsule();

        $this->comment('');

        if (!$installed) {
            $this->error('Your capsule was not installed.');
        } else {
            $this->comment('Your capsule was installed successfully!');
        }

        return $installed ? 0 : 255;
    }

    protected function getCapsuleDirectory()
    {
        return $this->capsule['root_path'];
    }

    protected function directoryExists()
    {
        return file_exists($this->getCapsuleDirectory());
    }

    protected function download()
    {
        if (!$this->cleanTempFile() || !$this->repositoryExists()) {
            return false;
        }

        $this->info('Downloading zip file...');

        file_put_contents(
            $this->getTempFileName(),
            fopen($this->getZipAddress(), 'r')
        );

        return true;
    }

    protected function cleanTempFile()
    {
        if (file_exists($this->getTempFileName())) {
            unlink($this->getTempFileName());

            if (file_exists($this->getTempFileName())) {
                $this->error(
                    'Unable to remove temporary file: ' .
                        $this->getTempFileName()
                );

                return false;
            }
        }

        return true;
    }

    protected function getTempFileName()
    {
        $this->makeDir($this->capsule['base_path']);

        return $this->capsule['base_path'] . '/install.zip';
    }

    protected function repositoryExists()
    {
        $guzzle = new Client();

        try {
            $statusCode = $guzzle
                ->request('GET', $this->repositoryUrl)
                ->getStatusCode();
        } catch (Exception $exception) {
            $statusCode = $exception->getCode();
        }

        if ($statusCode !== 200) {
            $this->error('Repository not found: ' . $this->repositoryUrl);

            return false;
        }

        return true;
    }

    protected function uncompress($zip, $directory)
    {
        $this->info('Unzipping file...');

        if (extension_loaded('zip')) {
            return $this->unzipWithExtension($zip, $directory);
        }

        if ($this->unzipShellCommandExists()) {
            return $this->unzipWithShell($zip, $directory);
        }

        $this->error(
            'Zip extension not installed and unzip command not found.'
        );

        return false;
    }

    protected function unzipShellCommandExists()
    {
        $return = shell_exec('which unzip');

        return !empty($return);
    }

    protected function unzipWithExtension($zip, $directory)
    {
        $this->info('Unzipping with PHP zip extension...');

        $unzip = new \ZipArchive();

        $success = $unzip->open($zip) && $unzip->extractTo("$directory/");

        try {
            $unzip->close();
        } catch (Exception $exception) {
            //
        }

        unlink($zip);

        if (!$success) {
            $this->error("Cound not read zip file: $zip");

            return false;
        }

        return true;
    }

    protected function unzipWithShell($zip, $directory)

The parameter $zip is not used and could be removed.

The parameter $directory is not used and could be removed.

    {
        $this->info('Unzipping with unzip shell command...');

        chdir($this->capsule['base_path']);

        shell_exec('unzip install.zip');

        return file_exists($this->getUnzippedPath());
    }

    public function renameToCapsule()
    {
        $destination = $this->capsule['psr4_path'];

        rename($this->getUnzippedPath(), $destination);

        return file_exists($destination);
    }

    public function makeDir($path)
    {
        if (!file_exists($path)) {
            mkdir($path, 0775, true);
        }
    }
}