Get an option from the Command.

@param string $option
@param bool   $loose

@return string
428394
public function getOption($option, $loose = false)
    {
        // Verbosity levels
        if ($this->hasCommand() && $option === 'verbose') {
            return $this->command->getVerbosity() > OutputInterface::VERBOSITY_NORMAL;
        }

        // Gather options
        $options = isset($this->options) ? $this->options : [];

        // If we have a command and a matching option, get it
        if ($this->hasCommand()) {
            if (!$loose) {
                return $this->command->option($option);
            }

            $options = array_merge($options, (array) $this->command->option());
        }

        return Arr::get($options, $option);
    }
1102413
final protected function getOptions($option = null)
    {
        if (null !== $option) {
            if (array_key_exists($option, self::$_options)) {
                return self::$_options[$option];
            } else {
                return false;
            }
        }

        return self::$_options;
    }
212218
private function formatOption(Option $option) : string
    {
        $text = "[--{$option->getName()}";

        if ($option->valueIsOptional()) {
            $text .= '=' . $option->getDefaultValue();
        }

        if ($option->getShortName() !== null) {
            $text .= "|-{$option->getShortName()}";
        }

        $text .= ']';

        return $text;
    }
996699
function getOption( $option )
    {
        if ( !in_array( $option, $this->Options ) )
        {
            throw new Exception( "Option $option not supported" );
        }

        switch( $option )
        {
            case 'timeout':
                return $this->Timeout;
            case 'login':
                return $this->Login;
            case 'password':
                return $this->Password;
            case 'authType':
                return $this->AuthType;
            case 'requestCompression':
                return $this->RequestCompression;
            case 'method':
                return $this->Verb;
            case 'acceptedCompression':
                return $this->AcceptedCompression;
            case 'proxyHost':
                return $this->Proxy;
            case 'proxyPort':
                return $this->ProxyPort;
            case 'proxyUser':
                return $this->ProxyLogin;
            case 'proxyPassword':
                return $this->ProxyPassword;
            case 'proxyAuthType':
                return $this->ProxyAuthType;
            case 'forceCURL':
                return $this->ForceCURL;
            case 'debug':
                return $this->Debug;
            case 'SSLVerifyHost':
                return $this->SSLVerifyHost;
            case 'SSLVerifyPeer':
                return $this->SSLVerifyPeer;
            case 'SSLCAInfo':
                return $this->SSLCAInfo;
        }
    }
330928
protected function getPreferedTarget($option)
    {
        $prefer = [
            'source' => false,
            'dist'   => false,
        ];

        switch ($option) {
            case 'source':
                $prefer['source'] = true;
                break;
            case 'dist':
                $prefer['dist'] = true;
                break;
            case 'auto':
            default:
                break;
        }

        return $prefer;
    }
157960
public function getUrl($option)
    {
        if ($this->isActive($option)) {
            $params = $this->request->all();

            unset($params[$this->getKey()]);

            return '?'.http_build_query($params);
        }

        return '?'.http_build_query([$this->key => $option] + $this->request->all());
    }
848865
function open_fp($option = 'r')
    {

        if (empty($option) || !is_string($option)) return false;

        switch (true) {
            case (strpos($option, 'r') !== false) :
                $mode = LOCK_SH;
                break;
            case (strpos($option, 'a') !== false || strpos($option, 'w') !== false) :
                $mode = LOCK_EX;
                break;
            default :
                $mode = LOCK_EX;
                break;
        }
        $this->readable = true;

        if (($this->fp = fopen($this->file, $option)) !== false) {
            $this->lock($mode);
            // sets the fopen option based on it reduces
            // reopening of a file
            $this->_option = (string)$option;

            return true;
        }

        return false;
    }
1355372
public static function option($bundle, $option, $default = null)
		{
			$bundle = static::get($bundle);

			if (is_null($bundle)) {
				return value($default);
			}

			return arrayGet($bundle, $option, $default);
		}
50807
public function pathinfo($option = null)
    {
        if (null === $option) {
            return pathinfo($this->_filePath);
        }
        return pathinfo($this->_filePath, $option);
    }
1008777
private function _argument($option, $index = null)
    {
        if (isset($index) && !is_numeric($index))
            throw new \Exception('Attempted to reference argument with a string name');
        return $this->_option($option, $index);
    }
468691
public function getOption($option)
    {
        return isset($this->getOptions()[$option]) ? $this->getOptions()[$option] : null;
    }
902771
public function get( $option, $slug ) {

		if ( $this->is_active() ) {

			$this->prepare( $slug );

			$slug = $this->slug;

			if ( isset( $this->plugin[ $slug ][ $option ] ) ) {
				return $this->plugin[ $slug ][ $option ];
			} elseif ( '*' == $option && isset( $this->plugin[ $slug ] ) ) {
				return $this->plugin[ $slug ];
			}

			return false;
		}
	}
1192789
final protected function get($option)
    {
        if (array_key_exists($key = "$option", $this->options)) {
            return $this->options[$key];
        }

        if (array_key_exists($key, $this->defaults)) {
            return $this->defaults[$key];
        }
    }
1111260
public function getCurlOption($option)
    {
        return isset($this->curlOptions[$option]) ? $this->curlOptions[$option] : null;
    }
307028
public function getInfo($option)
    {
        if (array_key_exists($option, $this->infos)) {
            return $this->infos[$option];
        }

        throw new \DomainException("Option {$option} not found.");
    }
534263
public function pull($options = "") {
        try {
            $output = $this->cmd(sprintf('pull %s', $options));
            return $output;
        } catch (Exception $ex) {
            $output['error'] = $ex;
            return $output;
        }
    }
435406
public function getBinCommand(string $command, bool $forceUnix = false): string
    {
        return $this->externalCommandLocator->locate($command, $forceUnix);
    }