Determine if the given options exclude a particular method.

@param  string  $method
@param  array  $options
@return bool
964896
public function methodExcludedByOptions($method, array $options)
	{
		return ( ! empty($options['only']) && ! in_array($method, (array) $options['only'])) ||
			( ! empty($options['except']) && in_array($method, (array) $options['except']));
	}
920787
public function has(string $index, array $options = []) : bool
    {
        $separator = isset($options['separator']) ?
            $options['separator'] :
            $this->getOption('separator', '.');
        $value = $this->getData();
        $keys = explode($separator, $index);

        foreach ($keys as $key) {
            if (!is_array($value) || !array_key_exists($key, $value)) {
                return false;
            }

            $value = $value[$key];
        }

        return true;
    }
364418
protected function required_options($required, $options = array())
  {
      $required = explode(',', $required);
      foreach ($required as $r) {
          if (!array_key_exists(trim($r), $options)) {
              throw new Exception($r.' parameter is required!');
              break;

              return false;
          }
      }

      return true;
  }
111355
public static function hasMethod($object, $method)
    {
        if (empty($object)) {
            return false;
        }
        if (method_exists($object, $method)) {
            return true;
        }
        return method_exists($object, 'hasMethod') && $object->hasMethod($method);
    }
67937
public function isMethodAllowed(string $method): bool
    {
        if (\in_array($method, $this->methods, true)) {
            return true;
        }

        if ($method === HttpMethod::HEAD) {
            return \in_array(HttpMethod::GET, $this->methods, true);
        }

        return false;
    }
298032
private function validateMethod($method)
    {
        $prefix = substr($method, 0, 3);

        if ($prefix === 'get' || $prefix === 'set' || $prefix === 'has') {
            return lcfirst(substr($method, 3));
        }

        $prefix = substr($prefix, 0, 2);

        if ($prefix === 'is') {
            return lcfirst(substr($method, 2));
        }
    }
1347579
public function only($method)
    {
        if (!is_array($method)) {
            $method = [ $method ];
        }

        $this->only += $method;

        return $this;
    }
1035307
protected function _validateMethod($method) {
        if (in_array(strtoupper($method), $this->_validMethods)) {
            return true;
        }
        $exception = new Garp_Content_Api_Rest_Exception('Method not allowed');
        $exception->setHttpStatusCode(405);
        throw $exception;
    }
835945
public function getRequestWithOptions($method, $uri, array $options = [])
    {
        $options = $this->parseOptions($options);

        return $this->getRequest(
            $method,
            $uri,
            $options['headers'],
            $options['body'],
            $options['version']
        );
    }
225935
public static function acceptsOptions( array $options )
    {
        $tl = strlen( static::TYPE );

        return isset( $options['type'] ) && (
            static::TYPE == $options['type'] || (
                strlen( $options['type'] ) > $tl &&
                ( static::TYPE . '.' ) == substr( $options['type'], 0, $tl + 1 )
            )
        );
    }
1120136
public function get($method, array $params, array $options = array())
    {
        $this->parseOptions($options);

        $params = array_merge($params, $this->apiKeys);

        $response = $this->httpAdapter->getContent(
            sprintf(self::API_ENDPOINT, $this->scheme, $this->outputFormat, $method .'?'. http_build_query($params)),
            $this->headers
        );

        return $this->responseHandler($response);
    }
970349
private static function haveOptionsBeenUpdated($key, array $options = [])
    {
        if (array_key_exists($key, self::$cache)) {
            return (self::$cache[$key] != $options);
        }
        return false;
    }
368378
public static function ban($object, $options = [])
	{
		$foreground = static::i('ban')->addCssClass('text-danger');
		return static::is($foreground, $object, $options);
	}
693775
public static function setDefaultMethod (string $method) : bool
    {       
        if ( ($method = self::isAuthMethod($method)) && $method !== self::CONDORCET_BASIC_CLASS ) :
            self::$_defaultMethod = $method;
            return true;
        else :
            return false;
        endif;
    }
1372792
public function isValidMethod($method)
    {
        $reflection = $this->getReflection()->getMethod($method);

        return ! $reflection->isAbstract()
                && $reflection->isPublic()
                && preg_match($this->methodRule, $method) > 0;
    }
280902
public function methodsContains($method) {
        if (is_string($method)) {
            $method = array($method);
        }
        $this->rule = "contains";
        $this->method = $method;
        return $this;
    }
676749
final public function check(array $options) {
        foreach ($options as $property => $value) {
            if ((is_array($value) && !in_array($this->$property, $value)) ||
                    (!is_array($value) && $this->$property !== $value))
                return false;
        }

        return true;
    }