ComposerScriptRunner::verifyExtras() - Code Metrics - dbtlr/php-env-builder - Measure and Improve Code Quality continuously with Scrutinizer

ComposerScriptRunner::verifyExtras() A
last analyzed 2021-04-05 15:07 UTC

↳ Parent: ComposerScriptRunner

Complexity

Conditions	5
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	5

Importance

Changes

Metric	Value
dl	0
loc	21
ccs	11
cts	11
cp	1
rs	9.2728
c	0
b	0
f	0
cc	5
nc	4
nop	1
crap	5

<?php

namespace Dbtlr\PHPEnvBuilder;

use Composer\Script\Event;
use Composer\Factory;
use Dbtlr\PHPEnvBuilder\Exception\AskException;
use Dbtlr\PHPEnvBuilder\Exception\ConfigurationException;
use Dbtlr\PHPEnvBuilder\IOHandler\ComposerIOHandler;

class ComposerScriptRunner
{
    /** @var array */
    protected $config = [];

    /** @var Builder */
    protected $builder;

    /** @var Event */
    protected $event;

    /** @var string */
    protected $basePath;

    /**
     * ComposerScriptRunner constructor.
     *
     * @throws ConfigurationException
     * @param Event $event
     * @param Builder|null $builder
     */
    public function __construct(Event $event, Builder $builder = null)
    {
        $this->event = $event;
        $this->builder = $builder;

        $this->populateConfig();

        if (!$this->builder) {
            $this->createBuilder();
        }
    }

    /**
     * Set a particular config value.
     *
     * @param string $key
     * @param mixed $value
     */
    public function set(string $key, $value)
    {
        $this->config[$key] = $value;
    }

    /**
     * Get the requested config var.
     *
     * @param string $key
     * @return mixed|null
     */
    public function get(string $key)
    {
        return isset($this->config[$key]) ? $this->config[$key] : null;
    }

    /**
     * @return string
     */
    public function getBasePath()
    {
        if (!isset($this->basePath)) {
            $this->basePath = realpath(dirname(Factory::getComposerFile()));
        }

        return $this->basePath;
    }

    /**
     * @param string $basePath
     */
    public function setBasePath(string $basePath)
    {
        $this->basePath = $basePath;
    }

    /**
     * Get the full path to the env file.
     *
     * @return mixed|null|string
     */
    public function getEnvFile()
    {
        $basePath = $this->getBasePath();
        $envFile = $this->get('envFile');
        $startsWith = substr($envFile, 0, 1);
        if (!$startsWith !== '/' && $startsWith !== '~' && $startsWith !== '\\') {
            $envFile = $basePath . DIRECTORY_SEPARATOR . $envFile;
        }

        return $envFile;
    }

    /**
     * @throws \InvalidArgumentException
     */
    protected function populateConfig()
    {
        $extras = $this->event->getComposer()->getPackage()->getExtra();

        $this->verifyExtras($extras);

        $config = $extras['php-env-builder'];

        $this->set('envFile', isset($config['envFile']) ? $config['envFile'] : '.env');
        $this->set('clobber', isset($config['clobber']) ? $config['clobber'] : false);
        $this->set('verbose', isset($config['verbose']) ? $config['verbose'] : false);
        $this->set('loadEnv', isset($config['loadEnv']) ? $config['loadEnv'] : false);
        $this->set('questions', $config['questions']);
    }

    /**
     * Verify that the extras a formatted properly and throw an exception if not.
     *
     * @throws \InvalidArgumentException
     * @param array $extras
     */
    protected function verifyExtras(array $extras)
    {
        if (!isset($extras['php-env-builder'])) {
            throw new \InvalidArgumentException(
                'The parameter handler needs to be configured through the ' .
                'extra.php-env-builder setting.'
            );
        }

        if (!is_array($extras['php-env-builder'])) {
            throw new \InvalidArgumentException(
                'The extra.php-env-builder setting must be an array or a configuration object.'
            );
        }

        if (!isset($extras['php-env-builder']['questions']) || !is_array($extras['php-env-builder']['questions'])) {
            throw new \InvalidArgumentException(
                'The extra.php-env-builder.questions setting must be an array of questions.'
            );
        }
    }

    /**
     * @throws ConfigurationException
     */
    protected function createBuilder()
    {
        $this->builder = new Builder(
            $this->getEnvFile(),
            [
                'verbose' => $this->get('verbose'),
                'loadEnv' => $this->get('loadEnv')
            ]
        );

        $this->builder->setIOHandler(new ComposerIOHandler($this->event->getIO()));
    }

    /**
     * Override the Builder.
     *
     * @param Builder $builder
     */
    public function setBuilder(Builder $builder)
    {
        $this->builder = $builder;
    }

    /**
     * Build the config based on a composer's package.json file.
     *
     * @throws ConfigurationException
     * @throws AskException
     * @param Event $event
     * @param Builder $builder
     */
    public static function build(Event $event, Builder $builder = null)
    {
        $runner = new ComposerScriptRunner($event, $builder);
        $runner->run();
    }

    /**
     * Run the builder
     *
     * @throws AskException
     */
    public function run()
    {
        if ($this->shouldCancelOnClobber()) {
            return;
        }

        $this->askQuestions($this->get('questions'));

        $this->builder->run();
        $this->builder->write();
    }

    /**
     * Run through each of the questions and ask each one.
     *
     * @param array $questons
     */
    protected function askQuestions(array $questons)
    {
        foreach ($questons as $question) {
            $this->verifyQuestion($question);

            $name = $question['name'];
            $prompt = $question['prompt'];
            $default = isset($question['default']) ? $question['default'] : '';
            $required = isset($question['required']) ?  (bool) $question['required'] : false;

            $this->builder->ask($name, $prompt, $default, $required);
        }
    }

    /**
     * Verify that the question has the minimum fields.
     *
     * @throws \InvalidArgumentException
     * @param array $question
     */
    protected function verifyQuestion(array $question)
    {
        if (!isset($question['name'])) {
            throw new \InvalidArgumentException(
                'The extra.php-env-builder.questions require all questions have a `name` property.'
            );
        }

        if (!isset($question['prompt'])) {
            throw new \InvalidArgumentException(
                'The extra.php-env-builder.questions require all questions have a `prompt` property.'
            );
        }
    }

    /**
     * If we're clobbering and we're not supposed to, should we cancel?
     *
     * @return bool
     */
    protected function shouldCancelOnClobber()
    {
        $fullPath = $this->getEnvFile();
        if (!$this->get('clobber') && file_exists($fullPath)) {
            $this->event->getIO()->write(sprintf('Env file `%s` already exists, skipping...', $fullPath));
            return true;
        }

        return false;
    }
}


1		<?php
2
3		namespace Dbtlr\PHPEnvBuilder;
4
5		use Composer\Script\Event;
6		use Composer\Factory;
7		use Dbtlr\PHPEnvBuilder\Exception\AskException;
8		use Dbtlr\PHPEnvBuilder\Exception\ConfigurationException;
9		use Dbtlr\PHPEnvBuilder\IOHandler\ComposerIOHandler;
10
11		class ComposerScriptRunner
12		{
13		/** @var array */
14		protected $config = [];
15
16		/** @var Builder */
17		protected $builder;
18
19		/** @var Event */
20		protected $event;
21
22		/** @var string */
23		protected $basePath;
24
25		/**
26		* ComposerScriptRunner constructor.
27		*
28		* @throws ConfigurationException
29		* @param Event $event
30		* @param Builder\|null $builder
31		*/
32	22	public function __construct(Event $event, Builder $builder = null)
33		{
34	22	$this->event = $event;
35	22	$this->builder = $builder;
36
37	22	$this->populateConfig();
38
39	16	if (!$this->builder) {
40	14	$this->createBuilder();
41		}
42	16	}
43
44		/**
45		* Set a particular config value.
46		*
47		* @param string $key
48		* @param mixed $value
49		*/
50	16	public function set(string $key, $value)
51		{
52	16	$this->config[$key] = $value;
53	16	}
54
55		/**
56		* Get the requested config var.
57		*
58		* @param string $key
59		* @return mixed\|null
60		*/
61	16	public function get(string $key)
62		{
63	16	return isset($this->config[$key]) ? $this->config[$key] : null;
64		}
65
66		/**
67		* @return string
68		*/
69	16	public function getBasePath()
70		{
71	16	if (!isset($this->basePath)) {
72	16	$this->basePath = realpath(dirname(Factory::getComposerFile()));
73		}
74
75	16	return $this->basePath;
76		}
77
78		/**
79		* @param string $basePath
80		*/
81	14	public function setBasePath(string $basePath)
82		{
83	14	$this->basePath = $basePath;
84	14	}
85
86		/**
87		* Get the full path to the env file.
88		*
89		* @return mixed\|null\|string
90		*/
91	16	public function getEnvFile()
92		{
93	16	$basePath = $this->getBasePath();
94	16	$envFile = $this->get('envFile');
95	16	$startsWith = substr($envFile, 0, 1);
96	16	if (!$startsWith !== '/' && $startsWith !== '~' && $startsWith !== '\\') {
97	16	$envFile = $basePath . DIRECTORY_SEPARATOR . $envFile;
98		}
99
100	16	return $envFile;
101		}
102
103		/**
104		* @throws \InvalidArgumentException
105		*/
106	22	protected function populateConfig()
107		{
108	22	$extras = $this->event->getComposer()->getPackage()->getExtra();
109
110	22	$this->verifyExtras($extras);
111
112	16	$config = $extras['php-env-builder'];
113
114	16	$this->set('envFile', isset($config['envFile']) ? $config['envFile'] : '.env');
115	16	$this->set('clobber', isset($config['clobber']) ? $config['clobber'] : false);
116	16	$this->set('verbose', isset($config['verbose']) ? $config['verbose'] : false);
117	16	$this->set('loadEnv', isset($config['loadEnv']) ? $config['loadEnv'] : false);
118	16	$this->set('questions', $config['questions']);
119	16	}
120
121		/**
122		* Verify that the extras a formatted properly and throw an exception if not.
123		*
124		* @throws \InvalidArgumentException
125		* @param array $extras
126		*/
127	22	protected function verifyExtras(array $extras)
128		{
129	22	if (!isset($extras['php-env-builder'])) {
130	2	throw new \InvalidArgumentException(
131		'The parameter handler needs to be configured through the ' .
132	2	'extra.php-env-builder setting.'
133		);
134		}
135
136	20	if (!is_array($extras['php-env-builder'])) {
137	2	throw new \InvalidArgumentException(
138	2	'The extra.php-env-builder setting must be an array or a configuration object.'
139		);
140		}
141
142	18	if (!isset($extras['php-env-builder']['questions']) \|\| !is_array($extras['php-env-builder']['questions'])) {
143	2	throw new \InvalidArgumentException(
144	2	'The extra.php-env-builder.questions setting must be an array of questions.'
145		);
146		}
147	16	}
148
149		/**
150		* @throws ConfigurationException
151		*/
152	14	protected function createBuilder()
153		{
154	14	$this->builder = new Builder(
155	14	$this->getEnvFile(),
156		[
157	14	'verbose' => $this->get('verbose'),
158	14	'loadEnv' => $this->get('loadEnv')
159		]
160		);
161
162	14	$this->builder->setIOHandler(new ComposerIOHandler($this->event->getIO()));
163	14	}
164
165		/**
166		* Override the Builder.
167		*
168		* @param Builder $builder
169		*/
170	14	public function setBuilder(Builder $builder)
171		{
172	14	$this->builder = $builder;
173	14	}
174
175		/**
176		* Build the config based on a composer's package.json file.
177		*
178		* @throws ConfigurationException
179		* @throws AskException
180		* @param Event $event
181		* @param Builder $builder
182		*/
183	2	public static function build(Event $event, Builder $builder = null)
184		{
185	2	$runner = new ComposerScriptRunner($event, $builder);
186	2	$runner->run();
187	2	}
188
189		/**
190		* Run the builder
191		*
192		* @throws AskException
193		*/
194	12	public function run()
195		{
196	12	if ($this->shouldCancelOnClobber()) {
197	2	return;
198		}
199
200	10	$this->askQuestions($this->get('questions'));
201
202	6	$this->builder->run();
203	6	$this->builder->write();
204	6	}
205
206		/**
207		* Run through each of the questions and ask each one.
208		*
209		* @param array $questons
210		*/
211	10	protected function askQuestions(array $questons)
212		{
213	10	foreach ($questons as $question) {
214	10	$this->verifyQuestion($question);
215
216	6	$name = $question['name'];
217	6	$prompt = $question['prompt'];
218	6	$default = isset($question['default']) ? $question['default'] : '';
219	6	$required = isset($question['required']) ? (bool) $question['required'] : false;
220
221	6	$this->builder->ask($name, $prompt, $default, $required);
222		}
223	6	}
224
225		/**
226		* Verify that the question has the minimum fields.
227		*
228		* @throws \InvalidArgumentException
229		* @param array $question
230		*/
231	10	protected function verifyQuestion(array $question)
232		{
233	10	if (!isset($question['name'])) {
234	2	throw new \InvalidArgumentException(
235	2	'The extra.php-env-builder.questions require all questions have a `name` property.'
236		);
237		}
238
239	8	if (!isset($question['prompt'])) {
240	2	throw new \InvalidArgumentException(
241	2	'The extra.php-env-builder.questions require all questions have a `prompt` property.'
242		);
243		}
244	6	}
245
246		/**
247		* If we're clobbering and we're not supposed to, should we cancel?
248		*
249		* @return bool
250		*/
251	12	protected function shouldCancelOnClobber()
252		{
253	12	$fullPath = $this->getEnvFile();
254	12	if (!$this->get('clobber') && file_exists($fullPath)) {
255	2	$this->event->getIO()->write(sprintf('Env file `%s` already exists, skipping...', $fullPath));
256	2	return true;
257		}
258
259	10	return false;
260		}
261		}
262

dbtlr / php-env-builder

GitHub Access Token became invalid

ComposerScriptRunner::verifyExtras() A last analyzed 2021-04-05 15:07 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ComposerScriptRunner::verifyExtras() A
last analyzed 2021-04-05 15:07 UTC