ArrayInput::__construct() - Code Metrics - Inspection of "Generate checkstyle output from jshint" - phpmyadmin/error-reporting-server - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 84dee3...084275 )

by Michal

created 2016-01-27 11:14 UTC

ArrayInput::__construct() A

↳ Parent: ArrayInput

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	6
rs	9.4285
cc	1
eloc	3
nc	1
nop	2

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Console\Input;

use Symfony\Component\Console\Exception\InvalidArgumentException;
use Symfony\Component\Console\Exception\InvalidOptionException;

/**
 * ArrayInput represents an input provided as an array.
 *
 * Usage:
 *
 *     $input = new ArrayInput(array('name' => 'foo', '--bar' => 'foobar'));
 *
 * @author Fabien Potencier <[email protected]>
 */
class ArrayInput extends Input
{
    private $parameters;

    /**
     * Constructor.
     *
     * @param array           $parameters An array of parameters
     * @param InputDefinition $definition A InputDefinition instance
     */
    public function __construct(array $parameters, InputDefinition $definition = null)
    {
        $this->parameters = $parameters;

        parent::__construct($definition);
    }

    /**
     * Returns the first argument from the raw parameters (not parsed).
     *
     * @return string The value of the first argument or null otherwise
     */
    public function getFirstArgument()
    {
        foreach ($this->parameters as $key => $value) {
            if ($key && '-' === $key[0]) {
                continue;
            }

            return $value;
        }
    }

    /**
     * Returns true if the raw parameters (not parsed) contain a value.
     *
     * This method is to be used to introspect the input parameters
     * before they have been validated. It must be used carefully.
     *
     * @param string|array $values     The values to look for in the raw parameters (can be an array)
     * @param bool         $onlyParams Only check real parameters, skip those following an end of options (--) signal
     *
     * @return bool true if the value is contained in the raw parameters
     */
    public function hasParameterOption($values, $onlyParams = false)
    {
        $values = (array) $values;

        foreach ($this->parameters as $k => $v) {
            if (!is_int($k)) {
                $v = $k;
            }

            if ($onlyParams && $v === '--') {
                return false;
            }

            if (in_array($v, $values)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Returns the value of a raw option (not parsed).
     *
     * This method is to be used to introspect the input parameters
     * before they have been validated. It must be used carefully.
     *
     * @param string|array $values     The value(s) to look for in the raw parameters (can be an array)
     * @param mixed        $default    The default value to return if no result is found
     * @param bool         $onlyParams Only check real parameters, skip those following an end of options (--) signal
     *
     * @return mixed The option value
     */
    public function getParameterOption($values, $default = false, $onlyParams = false)
    {
        $values = (array) $values;

        foreach ($this->parameters as $k => $v) {
            if ($onlyParams && ($k === '--' || (is_int($k) && $v === '--'))) {
                return false;
            }

            if (is_int($k)) {
                if (in_array($v, $values)) {
                    return true;
                }
            } elseif (in_array($k, $values)) {
                return $v;
            }
        }

        return $default;
    }

    /**
     * Returns a stringified representation of the args passed to the command.
     *
     * @return string
     */
    public function __toString()
    {
        $params = array();
        foreach ($this->parameters as $param => $val) {
            if ($param && '-' === $param[0]) {
                $params[] = $param.('' != $val ? '='.$this->escapeToken($val) : '');
            } else {
                $params[] = $this->escapeToken($val);
            }
        }

        return implode(' ', $params);
    }

    /**
     * Processes command line arguments.
     */
    protected function parse()
    {
        foreach ($this->parameters as $key => $value) {
            if ($key === '--') {
                return;
            }
            if (0 === strpos($key, '--')) {
                $this->addLongOption(substr($key, 2), $value);
            } elseif ('-' === $key[0]) {
                $this->addShortOption(substr($key, 1), $value);
            } else {
                $this->addArgument($key, $value);
            }
        }
    }

    /**
     * Adds a short option value.
     *
     * @param string $shortcut The short option key
     * @param mixed  $value    The value for the option
     *
     * @throws InvalidOptionException When option given doesn't exist
     */
    private function addShortOption($shortcut, $value)
    {
        if (!$this->definition->hasShortcut($shortcut)) {
            throw new InvalidOptionException(sprintf('The "-%s" option does not exist.', $shortcut));
        }

        $this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
    }

    /**
     * Adds a long option value.
     *
     * @param string $name  The long option key
     * @param mixed  $value The value for the option
     *
     * @throws InvalidOptionException When option given doesn't exist
     * @throws InvalidOptionException When a required value is missing
     */
    private function addLongOption($name, $value)
    {
        if (!$this->definition->hasOption($name)) {
            throw new InvalidOptionException(sprintf('The "--%s" option does not exist.', $name));
        }

        $option = $this->definition->getOption($name);

        if (null === $value) {
            if ($option->isValueRequired()) {
                throw new InvalidOptionException(sprintf('The "--%s" option requires a value.', $name));
            }

            $value = $option->isValueOptional() ? $option->getDefault() : true;
        }

        $this->options[$name] = $value;
    }

    /**
     * Adds an argument value.
     *
     * @param string $name  The argument name
     * @param mixed  $value The value for the argument
     *
     * @throws InvalidArgumentException When argument given doesn't exist
     */
    private function addArgument($name, $value)
    {
        if (!$this->definition->hasArgument($name)) {
            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
        }

        $this->arguments[$name] = $value;
    }
}


1		<?php
2
3		/*
4		* This file is part of the Symfony package.
5		*
6		* (c) Fabien Potencier <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Symfony\Component\Console\Input;
13
14		use Symfony\Component\Console\Exception\InvalidArgumentException;
15		use Symfony\Component\Console\Exception\InvalidOptionException;
16
17		/**
18		* ArrayInput represents an input provided as an array.
19		*
20		* Usage:
21		*
22		* $input = new ArrayInput(array('name' => 'foo', '--bar' => 'foobar'));
23		*
24		* @author Fabien Potencier <[email protected]>
25		*/
26		class ArrayInput extends Input
27		{
28		private $parameters;
29
30		/**
31		* Constructor.
32		*
33		* @param array $parameters An array of parameters
34		* @param InputDefinition $definition A InputDefinition instance
35		*/
36		public function __construct(array $parameters, InputDefinition $definition = null)
37		{
38		$this->parameters = $parameters;
39
40		parent::__construct($definition);
41		}
42
43		/**
44		* Returns the first argument from the raw parameters (not parsed).
45		*
46		* @return string The value of the first argument or null otherwise
47		*/
48		public function getFirstArgument()
49		{
50		foreach ($this->parameters as $key => $value) {
51		if ($key && '-' === $key[0]) {
52		continue;
53		}
54
55		return $value;
56		}
57		}
58
59		/**
60		* Returns true if the raw parameters (not parsed) contain a value.
61		*
62		* This method is to be used to introspect the input parameters
63		* before they have been validated. It must be used carefully.
64		*
65		* @param string\|array $values The values to look for in the raw parameters (can be an array)
66		* @param bool $onlyParams Only check real parameters, skip those following an end of options (--) signal
67		*
68		* @return bool true if the value is contained in the raw parameters
69		*/
70		public function hasParameterOption($values, $onlyParams = false)
71		{
72		$values = (array) $values;
73
74		foreach ($this->parameters as $k => $v) {
75		if (!is_int($k)) {
76		$v = $k;
77		}
78
79		if ($onlyParams && $v === '--') {
80		return false;
81		}
82
83		if (in_array($v, $values)) {
84		return true;
85		}
86		}
87
88		return false;
89		}
90
91		/**
92		* Returns the value of a raw option (not parsed).
93		*
94		* This method is to be used to introspect the input parameters
95		* before they have been validated. It must be used carefully.
96		*
97		* @param string\|array $values The value(s) to look for in the raw parameters (can be an array)
98		* @param mixed $default The default value to return if no result is found
99		* @param bool $onlyParams Only check real parameters, skip those following an end of options (--) signal
100		*
101		* @return mixed The option value
102		*/
103		public function getParameterOption($values, $default = false, $onlyParams = false)
104		{
105		$values = (array) $values;
106
107		foreach ($this->parameters as $k => $v) {
108		if ($onlyParams && ($k === '--' \|\| (is_int($k) && $v === '--'))) {
109		return false;
110		}
111
112		if (is_int($k)) {
113		if (in_array($v, $values)) {
114		return true;
115		}
116		} elseif (in_array($k, $values)) {
117		return $v;
118		}
119		}
120
121		return $default;
122		}
123
124		/**
125		* Returns a stringified representation of the args passed to the command.
126		*
127		* @return string
128		*/
129		public function __toString()
130		{
131		$params = array();
132		foreach ($this->parameters as $param => $val) {
133		if ($param && '-' === $param[0]) {
134		$params[] = $param.('' != $val ? '='.$this->escapeToken($val) : '');
135		} else {
136		$params[] = $this->escapeToken($val);
137		}
138		}
139
140		return implode(' ', $params);
141		}
142
143		/**
144		* Processes command line arguments.
145		*/
146		protected function parse()
147		{
148		foreach ($this->parameters as $key => $value) {
149		if ($key === '--') {
150		return;
151		}
152		if (0 === strpos($key, '--')) {
153		$this->addLongOption(substr($key, 2), $value);
154		} elseif ('-' === $key[0]) {
155		$this->addShortOption(substr($key, 1), $value);
156		} else {
157		$this->addArgument($key, $value);
158		}
159		}
160		}
161
162		/**
163		* Adds a short option value.
164		*
165		* @param string $shortcut The short option key
166		* @param mixed $value The value for the option
167		*
168		* @throws InvalidOptionException When option given doesn't exist
169		*/
170	View Code Duplication	private function addShortOption($shortcut, $value)
171		{
172		if (!$this->definition->hasShortcut($shortcut)) {
173		throw new InvalidOptionException(sprintf('The "-%s" option does not exist.', $shortcut));
174		}
175
176		$this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
177		}
178
179		/**
180		* Adds a long option value.
181		*
182		* @param string $name The long option key
183		* @param mixed $value The value for the option
184		*
185		* @throws InvalidOptionException When option given doesn't exist
186		* @throws InvalidOptionException When a required value is missing
187		*/
188		private function addLongOption($name, $value)
189		{
190		if (!$this->definition->hasOption($name)) {
191		throw new InvalidOptionException(sprintf('The "--%s" option does not exist.', $name));
192		}
193
194		$option = $this->definition->getOption($name);
195
196		if (null === $value) {
197		if ($option->isValueRequired()) {
198		throw new InvalidOptionException(sprintf('The "--%s" option requires a value.', $name));
199		}
200
201		$value = $option->isValueOptional() ? $option->getDefault() : true;
202		}
203
204		$this->options[$name] = $value;
205		}
206
207		/**
208		* Adds an argument value.
209		*
210		* @param string $name The argument name
211		* @param mixed $value The value for the argument
212		*
213		* @throws InvalidArgumentException When argument given doesn't exist
214		*/
215	View Code Duplication	private function addArgument($name, $value)
216		{
217		if (!$this->definition->hasArgument($name)) {
218		throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
219		}
220
221		$this->arguments[$name] = $value;
222		}
223		}
224

phpmyadmin / error-reporting-server

Push — master ( 84dee3...084275 )

ArrayInput::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like