Manager::parse() - Code Metrics - thephpleague/climate - Measure and Improve Code Quality continuously with Scrutinizer

Manager::parse() A
last analyzed 2021-01-10 21:21 UTC

↳ Parent: Manager

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	1
cts	1
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

namespace League\CLImate\Argument;

use League\CLImate\CLImate;
use League\CLImate\Exceptions\InvalidArgumentException;

class Manager
{
    /**
     * An array of arguments passed to the program.
     *
     * @var Argument[] $arguments
     */
    protected $arguments = [];

    /**
     * A program's description.
     *
     * @var string $description
     */
    protected $description;

    /**
     * Filter class to find various types of arguments
     *
     * @var \League\CLImate\Argument\Filter $filter
     */
    protected $filter;

    /**
     * Summary builder class
     *
     * @var \League\CLImate\Argument\Summary $summary
     */
    protected $summary;

    /**
     * Argument parser class
     *
     * @var \League\CLImate\Argument\Parser $parser
     */
    protected $parser;

    public function __construct()
    {
        $this->filter  = new Filter();
        $this->summary = new Summary();
        $this->parser  = new Parser();
    }

    /**
     * Add an argument.
     *
     * @param Argument|string|array $argument
     * @param $options
     *
     * @return void
     * @throws InvalidArgumentException if $argument isn't an array or Argument object.
     */
    public function add($argument, array $options = [])
    {
        if (is_array($argument)) {
            $this->addMany($argument);
            return;
        }

        if (is_string($argument)) {
            $argument = Argument::createFromArray($argument, $options);
        }

        if (!$argument instanceof Argument) {
            throw new InvalidArgumentException('Please provide an argument name or object.');
        }

        $this->arguments[$argument->name()] = $argument;
    }

    /**
     * Add multiple arguments to a CLImate script.
     *
     * @param array $arguments
     */
    protected function addMany(array $arguments = [])
    {
        foreach ($arguments as $name => $options) {
            $this->add($name, $options);
        }
    }

    /**
     * Determine if an argument exists.
     *
     * @param string $name
     * @return bool
     */
    public function exists($name)
    {
        return isset($this->arguments[$name]);
    }

    /**
     * Retrieve an argument's value.
     *
     * @param string $name
     * @return string|int|float|bool|null
     */
    public function get($name)
    {
        return isset($this->arguments[$name]) ? $this->arguments[$name]->value() : null;
    }

    /**
     * Retrieve an argument's all values as an array.
     *
     * @param string $name
     * @return string[]|int[]|float[]|bool[]
     */
    public function getArray($name)
    {
        return isset($this->arguments[$name]) ? $this->arguments[$name]->values() : [];
    }

    /**
     * Retrieve all arguments.
     *
     * @return Argument[]
     */
    public function all()
    {
        return $this->arguments;
    }

    /**
     * Determine if an argument has been defined on the command line.
     *
     * This can be useful for making sure an argument is present on the command
     * line before parse()'ing them into argument objects.
     *
     * @param string $name
     * @param array $argv
     *
     * @return bool
     */
    public function defined($name, array $argv = null)
    {
        // The argument isn't defined if it's not defined by the calling code.
        if (!$this->exists($name)) {
            return false;
        }

        $argument = $this->arguments[$name];
        $command_arguments = $this->parser->arguments($argv);

        foreach ($command_arguments as $command_argument) {
            if ($this->isArgument($argument, $command_argument)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Check if the defined argument matches the command argument.
     *
     * @param Argument $argument
     * @param string $command_argument
     *
     * @return bool
     */
    protected function isArgument($argument, $command_argument)
    {
        $possibilities = [
            $argument->prefix()     => "-{$argument->prefix()}",
            $argument->longPrefix() => "--{$argument->longPrefix()}",
        ];

        foreach ($possibilities as $key => $search) {
            if ($key && strpos($command_argument, $search) === 0) {
                return true;
            }
        }

        return false;
    }

    /**
     * Retrieve all arguments as key/value pairs.
     *
     * @return array
     */
    public function toArray()
    {
        $return = [];

        foreach ($this->all() as $name => $argument) {
            $return[$name] = $argument->value();
        }

        return $return;
    }

    /**
     * Set a program's description.
     *
     * @param string $description
     */
    public function description($description)
    {
        $this->description = trim($description);
    }

    /**
     * Output a script's usage statement.
     *
     * @param CLImate $climate
     * @param array $argv
     */
    public function usage(CLImate $climate, array $argv = null)
    {
        $this->summary
                ->setClimate($climate)
                ->setDescription($this->description)
                ->setCommand($this->parser->command($argv))
                ->setFilter($this->filter, $this->all())
                ->output();
    }

    /**
     * Parse command line arguments into CLImate arguments.
     *
     * @param array $argv
     */
    public function parse(array $argv = null)
    {
        $this->parser->setFilter($this->filter, $this->all());

        $this->parser->parse($argv);
    }

    /**
     * Get the trailing arguments
     *
     * @return string|null
     */
    public function trailing()
    {
        return $this->parser->trailing();
    }

    /**
     * Get the trailing arguments as an array
     *
     * @return array|null
     */
    public function trailingArray()
    {
        return $this->parser->trailingArray();
    }
}


1		<?php
2
3		namespace League\CLImate\Argument;
4
5		use League\CLImate\CLImate;
6		use League\CLImate\Exceptions\InvalidArgumentException;
7
8		class Manager
9		{
10		/**
11		* An array of arguments passed to the program.
12		*
13		* @var Argument[] $arguments
14		*/
15		protected $arguments = [];
16
17		/**
18		* A program's description.
19		*
20		* @var string $description
21		*/
22		protected $description;
23
24		/**
25		* Filter class to find various types of arguments
26		*
27		* @var \League\CLImate\Argument\Filter $filter
28		*/
29		protected $filter;
30
31		/**
32		* Summary builder class
33		*
34		* @var \League\CLImate\Argument\Summary $summary
35		*/
36		protected $summary;
37
38		/**
39		* Argument parser class
40		*
41		* @var \League\CLImate\Argument\Parser $parser
42		*/
43		protected $parser;
44	948
45		public function __construct()
46	948	{
47	948	$this->filter = new Filter();
48	948	$this->summary = new Summary();
49	948	$this->parser = new Parser();
50		}
51
52		/**
53		* Add an argument.
54		*
55		* @param Argument\|string\|array $argument
56		* @param $options
57		*
58	28	* @return void
59		* @throws InvalidArgumentException if $argument isn't an array or Argument object.
60	28	*/
61	24	public function add($argument, array $options = [])
62	24	{
63		if (is_array($argument)) {
64		$this->addMany($argument);
65	28	return;
66	24	}
67	24
68		if (is_string($argument)) {
69	28	$argument = Argument::createFromArray($argument, $options);
70	4	}
71
72		if (!$argument instanceof Argument) {
73	24	throw new InvalidArgumentException('Please provide an argument name or object.');
74	24	}
75
76		$this->arguments[$argument->name()] = $argument;
77		}
78
79		/**
80		* Add multiple arguments to a CLImate script.
81	24	*
82		* @param array $arguments
83	24	*/
84	24	protected function addMany(array $arguments = [])
85	24	{
86	24	foreach ($arguments as $name => $options) {
87		$this->add($name, $options);
88		}
89		}
90
91		/**
92		* Determine if an argument exists.
93		*
94	8	* @param string $name
95		* @return bool
96	8	*/
97		public function exists($name)
98		{
99		return isset($this->arguments[$name]);
100		}
101
102		/**
103		* Retrieve an argument's value.
104		*
105	8	* @param string $name
106		* @return string\|int\|float\|bool\|null
107	8	*/
108		public function get($name)
109		{
110		return isset($this->arguments[$name]) ? $this->arguments[$name]->value() : null;
111		}
112
113		/**
114		* Retrieve an argument's all values as an array.
115	20	*
116		* @param string $name
117	20	* @return string[]\|int[]\|float[]\|bool[]
118		*/
119		public function getArray($name)
120		{
121		return isset($this->arguments[$name]) ? $this->arguments[$name]->values() : [];
122		}
123
124		/**
125		* Retrieve all arguments.
126		*
127		* @return Argument[]
128		*/
129		public function all()
130		{
131	8	return $this->arguments;
132		}
133
134	8	/**
135	8	* Determine if an argument has been defined on the command line.
136		*
137		* This can be useful for making sure an argument is present on the command
138	8	* line before parse()'ing them into argument objects.
139	8	*
140		* @param string $name
141	8	* @param array $argv
142	8	*
143	8	* @return bool
144		*/
145	8	public function defined($name, array $argv = null)
146		{
147	8	// The argument isn't defined if it's not defined by the calling code.
148		if (!$this->exists($name)) {
149		return false;
150		}
151
152		$argument = $this->arguments[$name];
153		$command_arguments = $this->parser->arguments($argv);
154
155		foreach ($command_arguments as $command_argument) {
156		if ($this->isArgument($argument, $command_argument)) {
157		return true;
158	8	}
159		}
160
161	8	return false;
162	8	}
163	8
164		/**
165	8	* Check if the defined argument matches the command argument.
166	8	*
167	8	* @param Argument $argument
168		* @param string $command_argument
169	8	*
170		* @return bool
171	8	*/
172		protected function isArgument($argument, $command_argument)
173		{
174		$possibilities = [
175		$argument->prefix() => "-{$argument->prefix()}",
176		$argument->longPrefix() => "--{$argument->longPrefix()}",
177		];
178
179	8	foreach ($possibilities as $key => $search) {
180		if ($key && strpos($command_argument, $search) === 0) {
181	8	return true;
182		}
183	8	}
184	8
185	8	return false;
186		}
187	8
188		/**
189		* Retrieve all arguments as key/value pairs.
190		*
191		* @return array
192		*/
193		public function toArray()
194		{
195	4	$return = [];
196
197	4	foreach ($this->all() as $name => $argument) {
198	4	$return[$name] = $argument->value();
199		}
200
201		return $return;
202		}
203
204		/**
205		* Set a program's description.
206	4	*
207		* @param string $description
208	4	*/
209	4	public function description($description)
210	4	{
211	4	$this->description = trim($description);
212	4	}
213	4
214	4	/**
215		* Output a script's usage statement.
216		*
217		* @param CLImate $climate
218		* @param array $argv
219		*/
220		public function usage(CLImate $climate, array $argv = null)
221		{
222	16	$this->summary
223		->setClimate($climate)
224	16	->setDescription($this->description)
225		->setCommand($this->parser->command($argv))
226	16	->setFilter($this->filter, $this->all())
227	12	->output();
228		}
229
230		/**
231		* Parse command line arguments into CLImate arguments.
232		*
233		* @param array $argv
234	4	*/
235		public function parse(array $argv = null)
236	4	{
237		$this->parser->setFilter($this->filter, $this->all());
238
239		$this->parser->parse($argv);
240		}
241
242		/**
243		* Get the trailing arguments
244		*
245		* @return string\|null
246		*/
247		public function trailing()
248		{
249		return $this->parser->trailing();
250		}
251
252		/**
253		* Get the trailing arguments as an array
254		*
255		* @return array\|null
256		*/
257		public function trailingArray()
258		{
259		return $this->parser->trailingArray();
260		}
261		}
262

thephpleague / climate

Manager::parse() A last analyzed 2021-01-10 21:21 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Manager::parse() A
last analyzed 2021-01-10 21:21 UTC