Class: Grape::API

Inherits:
Object
  • Object
show all
Extended by:
ActiveSupport::Autoload
Includes:
DSL::API
Defined in:
lib/grape/api.rb,
lib/grape.rb,
lib/grape/api/helpers.rb,
lib/grape/validations/validators/coerce.rb

Overview

The API class is the primary entry point for creating Grape APIs. Users should subclass this class in order to build an API.

Defined Under Namespace

Modules: Helpers

Constant Summary collapse

LOCK =

A class-level lock to ensure the API is not compiled by multiple threads simultaneously within the same process.

Mutex.new
Boolean = 
Virtus::Attribute::Boolean

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from DSL::Configuration

desc_container, stacked_hash_to_hash

Constructor Details

#initialize ⇒ API

Builds the routes from the defined endpoints, effectively compiling this API into a usable form.



102
103
104
105
106
107
108
109
110
 
# File 'lib/grape/api.rb', line 102

def initialize
  @route_set = Rack::Mount::RouteSet.new
  add_head_not_allowed_methods_and_options_methods
  self.class.endpoints.each do |endpoint|
    endpoint.mount_in(@route_set)
  end

  @route_set.freeze
end

Class Attribute Details

.instance ⇒ Object (readonly)

Returns the value of attribute instance.



8
9
10
 
# File 'lib/grape/api.rb', line 8

def instance
  @instance
end

Class Method Details

.call(env) ⇒ Object

This is the interface point between Rack and Grape; it accepts a request from Rack and ultimately returns an array of three values: the status, the headers, and the body. See [the rack specification] (www.rubydoc.info/github/rack/rack/master/file/SPEC) for more.



37
38
39
40
 
# File 'lib/grape/api.rb', line 37

def call(env)
  LOCK.synchronize { compile } unless instance
  call!(env)
end

.call!(env) ⇒ Object

A non-synchronized version of ::call.



43
44
45
 
# File 'lib/grape/api.rb', line 43

def call!(env)
  instance.call(env)
end

.cascade(value = nil) ⇒ Object

Some requests may return a HTTP 404 error if grape cannot find a matching route. In this case, Rack::Mount adds a X-Cascade header to the response and sets it to ‘pass’, indicating to grape’s parents they should keep looking for a matching route on other resources.

In some applications (e.g. mounting grape on rails), one might need to trap errors from reaching upstream. This is effectivelly done by unsetting X-Cascade. Default :cascade is true.



58
59
60
61
62
63
64
 
# File 'lib/grape/api.rb', line 58

def cascade(value = nil)
  if value.nil?
    inheritable_setting.namespace_inheritable.keys.include?(:cascade) ? !!namespace_inheritable(:cascade) : true
  else
    namespace_inheritable(:cascade, value)
  end
end

.change! ⇒ Object

Wipe the compiled API so we can recompile after changes were made.



29
30
31
 
# File 'lib/grape/api.rb', line 29

def change!
  @instance = nil
end

.compile ⇒ Object

Parses the API’s definition and compiles it into an instance of Grape::API.



24
25
26
 
# File 'lib/grape/api.rb', line 24

def compile
  @instance ||= new
end

.reset! ⇒ Object

Clears all defined routes, endpoints, etc., on this API.



15
16
17
18
19
20
 
# File 'lib/grape/api.rb', line 15

def reset!
  @route_set = Rack::Mount::RouteSet.new
  @endpoints = []
  @routes = nil
  reset_validations!
end

.scope(_name = nil, &block) ⇒ Object

Create a scope without affecting the URL.

make the code more readable.

Parameters:

  • _name (Symbol) (defaults to: nil) —

    Purely placebo, just allows to name the scope to



51
52
53
54
55
 
# File 'lib/grape/api.rb', line 51

def scope(_name = nil, &block)
  within_namespace do
    nest(block)
  end
end

Instance Method Details

#call(env) ⇒ Object

Handle a request. See Rack documentation for what ‘env` is.



113
114
115
116
117
 
# File 'lib/grape/api.rb', line 113

def call(env)
  result = @route_set.call(env)
  result[1].delete(Grape::Http::Headers::X_CASCADE) unless cascade?
  result
end

#cascade? ⇒ Boolean

Some requests may return a HTTP 404 error if grape cannot find a matching route. In this case, Rack::Mount adds a X-Cascade header to the response and sets it to ‘pass’, indicating to grape’s parents they should keep looking for a matching route on other resources.

In some applications (e.g. mounting grape on rails), one might need to trap errors from reaching upstream. This is effectivelly done by unsetting X-Cascade. Default :cascade is true.

Returns:



127
128
129
130
131
 
# File 'lib/grape/api.rb', line 127

def cascade?
  return !!self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.keys.include?(:cascade)
  return !!self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options) && self.class.namespace_inheritable(:version_options).key?(:cascade)
  true
end