Show a options HTTP method response

@method OPTIONS
173207
public function options()
    {
        $options = array();

        $resourceMetadata = $this->app->getResourceMetadata($this);

        foreach ($resourceMetadata->getMethods() as $method => $methodMetadata) {
            $options[] = strtoupper($method);
        }

        return new Response(200, $options, array(
            'Allow' => implode(',', $options)
        ));
    }
103574
def options(self):

		'''
		
		'''

		# http request
		response = self.repo.api.http_request('OPTIONS', self.uri)
		return response.headers
839570
def method_missing(*args)
      method = args.first.to_sym
      if con.respond_to? method
        results = con.send(method)
        display results.table(_headers_for(method))
      elsif options[:actions][method]
        eval_action(options[:actions][method], args)
      elsif options[:scripts][method]
        eval_script(options[:scripts][method], args)
      else
        Ftl.help
      end
    end
783105
function wrapOptions(method, model, options) {
  return function(err, res) {
    if (err) {
      if (options.error) {
        return options.error(res, err);
      }
      console.error('An error ocurred with no handler specified!', err);
      throw err;
    }

    if (options.success) {
      return options.success(res);
    } 
  };
}
404944
public function request($url, $method = 'GET', $options = []): ResponseInterface
    {
        $method = strtoupper($method);

        $options = array_merge(self::$defaults, $options, ['handler' => $this->getHandlerStack()]);

        $options = $this->fixJsonIssue($options);

        if (property_exists($this, 'baseUri') && !is_null($this->baseUri)) {
            $options['base_uri'] = $this->baseUri;
        }

        $response = $this->getHttpClient()->request($method, $url, $options);
        $response->getBody()->rewind();

        return $response;
    }
99462
def options(self, *args, **kwargs):
        '''
        
        '''
        # Allow X-Auth-Token in requests
        request_headers = self.request.headers.get('Access-Control-Request-Headers')
        allowed_headers = request_headers.split(',')

        # Filter allowed header here if needed.

        # Allow request headers
        self.set_header('Access-Control-Allow-Headers', ','.join(allowed_headers))

        # Allow X-Auth-Token in responses
        self.set_header('Access-Control-Expose-Headers', 'X-Auth-Token')

        # Allow all methods
        self.set_header('Access-Control-Allow-Methods', 'OPTIONS, GET, POST')

        self.set_status(204)
        self.finish()
1295839
function (options, callback) {
    var self = this,
        requestOptions = {
          path: _urlPrefix
    };

    if (typeof options === 'function') {
      callback = options;
      options = {};
    }

    self._request(requestOptions, function (err, body) {
      if (err) {
        return callback(err);
      }

      else if (!body || !body.loadBalancers) {
        return callback(new Error('Unexpected empty response'));
      }

      else {
        return callback(null, body.loadBalancers.map(function (loadBalancer) {
          return new lb.LoadBalancer(self, loadBalancer);
        }));
      }
    });
  }
900093
function(options) {
      options= options || {};

      var self = this;
      if (!self._previousSave) {
        self._previousSave = self._source.then(function(base64, type) {
          var data = {
            base64: base64,
            _ContentType: type
          };
          return Parse._request({
            route: "files",
            className: self._name,
            method: 'POST',
            data: data,
            useMasterKey: options.useMasterKey
          });

        }).then(function(response) {
          self._name = response.name;
          self._url = response.url;
          return self;
        });
      }
      return self._previousSave._thenRunCallbacks(options);
    }
647667
function (options) {

            if (typeof options === 'object') {

                // Add implementation-specific method prefix (dashboard or app)
                options.name = this.prefix + '.' + options.name;
                return this.transport.send(options);
            }  else {
                throw new Error('Transport options must be an object.');
            }
        }
943598
def get_options(server):
    """"""
    try:
        response = requests.options(
            server, allow_redirects=False, verify=False, timeout=5)
    except (requests.exceptions.ConnectionError,
            requests.exceptions.MissingSchema):
        return "Server {} is not available!".format(server)

    try:
        return {'allowed': response.headers['Allow']}
    except KeyError:
        return "Unable to get HTTP methods"
319432
def exposes(object, options = {})
      if Respondable.paginated?(object)
        paginated object, options
      elsif Respondable.collection?(object)
        collection object, options
      else
        if Respondable.invalid?(object)
          error! :invalid_resource, object.errors
        else
          resource object, options
        end
      end
    end
605982
def request(uri:, request_options: {}, parameters: {})
      opts = {
        uri: uri,
        request_options: request_options,
        parameters: @default_parameters.merge(parameters)
      }
      parse_response(http_service.perform_request(opts))
    end
159163
function parseOptions(options) {
        options = util.extend(true, {}, options || {});
        options.method = options.method || 'GET';
        options.headers = options.headers || [];
        options.data = options.data || '';
        options.withCredentials = !!options.withCredentials;

        if (typeof options.data !== 'string') {
            options.data = $.param(options.data);
            if (options.method !== 'GET') {
                options.data = options.data;
                options.headers.push(['Content-Type', 'application/x-www-form-urlencoded']);
            }
        }
        return options;
    }
1099002
def show(options={}, &block)
      super do |success, failure|
        success.json { render json: get_resource_version.as_json(json_config(:show)) }
      end
    end
1174883
function showCapabilities( options, callback){
    options.url  = 'https://'+options.host+':'+options.port+SUPERVISOR_PATH_SHOW_CAPABILITY;
    options.ca = ssl_files.readCaChain(options.caFile);
    options.key = ssl_files.readFileContent(options.keyFile);
    options.cert = ssl_files.readFileContent(options.certFile);

    request(options, function (error, response, body) {
        if (!error && (response.statusCode = 200)) {
            var caps = (JSON.parse(body));
            callback(null, caps);
        }else{
            console.log(error);
            callback(new Error("Error connecting to the supervisor"), null);
        }
    });
}
1057388
function xhrJson(method, url, options) {
		if (options && typeof options.data !== 'undefined') {
			options.data = JSON.stringify(options.data);
		}
		return xhr.apply(null, Array.prototype.slice.call(arguments)).then(function(result) {
			return JSON.parse(result.response || null);
		});
	}
757151
def do_request(method, url, options = {})
      begin
        response = self.class.send(method, api_url(url), options)
        check_response_codes(response)
        response.parsed_response
      rescue Timeout::Error
        raise Unavailable.new('Service Unavailable')
      end
    end