Multidimensional\Subdomains\Shell\SubdomainsInstallShell

Complexity

Total Complexity

36

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	main()	0	21	4
A	_runProgram()	0	8	2
A	_displayCurrentUniqueSubdomains()	0	8	2
A	_inputSubdomain()	0	18	4
A	_uniqueSubdomains()	0	8	2
A	_writeConfig()	0	5	1
A	_displayFinal()	0	9	2
A	_finalCheck()	0	7	2
A	_getSubdomains()	0	8	1
A	_modifyArray()	0	11	2
A	_displayCurrentSubdomains()	0	13	3
A	_inputYesNo()	0	4	1
A	_deleteSubdomain()	0	13	4
A	_validateSubdomain()	0	8	3
A	_countSubdomains()	0	8	3

<?php
/**
 * CakePHP Plugin : CakePHP Subdomain Routing
 * Copyright (c) Multidimension.al (http://multidimension.al)
 * Github : https://github.com/multidimension-al/cakephp-subdomains
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE file
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright (c) Multidimension.al (http://multidimension.al)
 * @link      https://github.com/multidimension-al/cakephp-subdomains Github
 * @license   http://www.opensource.org/licenses/mit-license.php MIT License
 */

namespace Multidimensional\Subdomains\Shell;

use Cake\Console\Shell;
use Cake\Core\Configure;
use Multidimensional\Subdomains\Middleware\SubdomainMiddleware;

class SubdomainsInstallShell extends Shell
{

    /**
     * @return void
     */
    public function main()
    {
        $this->clear();

        $this->helper('Multidimensional/Subdomains.Header')->output();

        $subdomains = $this->_getSubdomains();
        $continue = $this->_runProgram($subdomains);

        if ($continue) {
            do {
                $this->_inputSubdomain($subdomains);
                $this->_displayCurrentUniqueSubdomains($subdomains);
                $this->_deleteSubdomain($subdomains);
                $this->_writeConfig($subdomains);
                $this->_finalCheck($subdomains);
            } while (!$this->_countSubdomains($subdomains) && $this->_inputYesNo('Start over?'));
        }

        $this->_displayFinal($subdomains);
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return bool
     */
    private function _runProgram($subdomains)

function _runProgram() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        if ($this->_countSubdomains($subdomains)) {
            return $this->_inputYesNo('Update configuration?');
        } else {
            return $this->_inputYesNo('Install subdomains plugin?');
        }
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _displayCurrentUniqueSubdomains(&$subdomains)
    {
        if ($this->_countSubdomains($subdomains)) {
            $subdomains = $this->_uniqueSubdomains($subdomains);
            $subdomains = $this->_modifyArray($subdomains);
            $this->_displayCurrentSubdomains($subdomains);
        }
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _inputSubdomain(&$subdomains)
    {
        $valid = true;
        $this->out();

        while (!$valid || $this->_inputYesNo('Add a subdomain?')) {
            $this->out();
            $subdomain = strtolower($this->in('Subdomain:'));
            $valid = $this->_validateSubdomain($subdomain);
            $this->out();

            if ($valid) {
                $subdomains[] = $subdomain;
            } else {
                $this->err('Invalid subdomain.');
            }
        };
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return array $subdomains
     */
    private function _uniqueSubdomains($subdomains)
    {
        if ($this->_countSubdomains($subdomains)) {
            return array_values(array_unique($subdomains));
        } else {
            return $subdomains;
        }
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _writeConfig($subdomains)
    {
        Configure::write('Multidimensional/Subdomains.Subdomains', array_values($subdomains));
        Configure::dump('subdomains', 'default', ['Multidimensional/Subdomains']);
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _displayFinal($subdomains)
    {
        $this->out();
        if ($this->_countSubdomains($subdomains)) {
            $this->out('Configuration saved!', 2);
        } else {
            $this->err('Plugin not currently active.', 2);
        }
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _finalCheck($subdomains)
    {
        if (!$this->_countSubdomains($subdomains)) {
            $this->out();
            $this->err('No subdomains configured.', 2);
        }
    }

    /**
     * @return SubdomainMiddleware

Should the return type not be array? Also, consider making the array more specific, something like array<String>, or String[].

     */
    private function _getSubdomains()
    {
        $subdomainMiddleware = new SubdomainMiddleware();
        $subdomains = $subdomainMiddleware->getSubdomains();
        $defaultSubdomains = $subdomainMiddleware->defaultSubdomains;

        return array_diff($subdomains, $defaultSubdomains);
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return array
     */
    private function _modifyArray(array $subdomains)
    {
        if ($this->_countSubdomains($subdomains)) {
            return array_combine(
                range(1, count($subdomains)),
                array_values($subdomains)
            );
        } else {
            return $subdomains;
        }
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _displayCurrentSubdomains(array $subdomains)
    {
        if ($this->_countSubdomains($subdomains)) {
            $this->out();
            $this->out('Current subdomains:', 2);

            foreach ($subdomains as $key => $value) {
                $this->out(' ' . ($key) . '. ' . $value);
            }

            $this->out();
        }
    }

    /**
     * @param string $string

Missing parameter comment

     * @return bool
     */
    private function _inputYesNo($string)

function _inputYesNo() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        return strtolower($this->in($string, ['y', 'n'])) === 'y';
    }

    /**
     * @param array $subdomains

Missing parameter comment

     * @return void
     */
    private function _deleteSubdomain(&$subdomains)
    {
        while ($this->_countSubdomains($subdomains) && $this->_inputYesNo('Delete a subdomain?')) {
            $this->out();
            $key = (int)$this->in('Enter number to delete:', array_keys($subdomains));

            if (isset($subdomains[$key])) {
                $this->out();
                $this->out('Deleted: ' . $subdomains[$key], 2);
                unset($subdomains[$key]);
            }
        }
    }

    /**
     * @param  string|null $subdomain

Missing parameter comment

     * @return string|null

Should the return type not be false|integer?

     */
    private function _validateSubdomain($subdomain)
    {
        if (is_null($subdomain) || empty($subdomain)) {
            return false;
        }

        return preg_match('/^[A-Za-z0-9]{1}(?:[A-Za-z0-9\-]{0,61}[A-Za-z0-9]{1})?$/', $subdomain);
    }

    /**
     * @param  array $subdomains

Missing parameter comment

     * @return int
     */
    private function _countSubdomains($subdomains)
    {
        if (!isset($subdomains) || !is_array($subdomains)) {
            return 0;
        }

        return count($subdomains);
    }
}