Class: Grape::API::Instance

Inherits:
Object
  • Object
show all
Includes:
DSL::API
Defined in:
lib/grape/api/instance.rb,
lib/grape/validations/validators/coerce.rb

Overview

The API Instance class, is the engine behind Grape::API. Each class that inherits from this will represent a different API instance

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Instance

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



152
153
154
155
156
157
158
159
160
161
 
# File 'lib/grape/api/instance.rb', line 152

def initialize
  @router = Router.new
  add_head_not_allowed_methods_and_options_methods
  self.class.endpoints.each do |endpoint|
    endpoint.mount_in(@router)
  end

  @router.compile!
  @router.freeze
end

Class Attribute Details

.base ⇒ Object

Returns the value of attribute base.



12
13
14
 
# File 'lib/grape/api/instance.rb', line 12

def base
  @base
end

.configuration ⇒ Object

Returns the value of attribute configuration.



13
14
15
 
# File 'lib/grape/api/instance.rb', line 13

def configuration
  @configuration
end

.instance ⇒ Object (readonly)

Returns the value of attribute instance.



11
12
13
 
# File 'lib/grape/api/instance.rb', line 11

def instance
  @instance
end

Instance Attribute Details

#router ⇒ Object (readonly)

Returns the value of attribute router.



148
149
150
 
# File 'lib/grape/api/instance.rb', line 148

def router
  @router
end

Class Method Details

.base_instance? ⇒ Boolean

Returns:



32
33
34
 
# File 'lib/grape/api/instance.rb', line 32

def base_instance?
  self == base.base_instance
end

.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.



62
63
64
65
 
# File 'lib/grape/api/instance.rb', line 62

def call(env)
  compile!
  call!(env)
end

.call!(env) ⇒ Object

A non-synchronized version of ::call.



68
69
70
 
# File 'lib/grape/api/instance.rb', line 68

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, Grape::Router 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.



73
74
75
76
77
78
79
 
# File 'lib/grape/api/instance.rb', line 73

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

.change! ⇒ Object

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



54
55
56
 
# File 'lib/grape/api/instance.rb', line 54

def change!
  @instance = nil
end

.compile ⇒ Object

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



49
50
51
 
# File 'lib/grape/api/instance.rb', line 49

def compile
  @instance ||= new
end

.compile! ⇒ Object 



81
82
83
84
 
# File 'lib/grape/api/instance.rb', line 81

def compile!
  return if instance
  LOCK.synchronize { compile unless instance }
end

.given(conditional_option, &block) ⇒ Object 



15
16
17
 
# File 'lib/grape/api/instance.rb', line 15

def given(conditional_option, &block)
  evaluate_as_instance_with_configuration(block, lazy: true) if conditional_option && block_given?
end

.mounted(&block) ⇒ Object 



19
20
21
 
# File 'lib/grape/api/instance.rb', line 19

def mounted(&block)
  evaluate_as_instance_with_configuration(block, lazy: true)
end

.recognize_path(path) ⇒ Object

see Grape::Router#recognize_path



87
88
89
90
 
# File 'lib/grape/api/instance.rb', line 87

def recognize_path(path)
  compile!
  instance.router.recognize_path(path)
end

.reset! ⇒ Object

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



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

def reset!
  reset_endpoints!
  reset_routes!
  reset_validations!
end

.to_s ⇒ Object 



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

def to_s
  (base && base.to_s) || super
end

Instance Method Details

#call(env) ⇒ Object

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



164
165
166
167
168
 
# File 'lib/grape/api/instance.rb', line 164

def call(env)
  result = @router.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, Grape::Router 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:



178
179
180
181
182
 
# File 'lib/grape/api/instance.rb', line 178

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