Class: Grape::API::Instance

Inherits:
Object
  • Object
show all
Extended by:
Middleware::Auth::DSL
Includes:
DSL::API
Defined in:
lib/grape/api/instance.rb,
lib/grape/api.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

Boolean = 
Grape::API::Boolean
LOCK =

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

Mutex.new

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Middleware::Auth::DSL

auth, http_basic, http_digest

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.



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

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.key?(: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 # rubocop:disable Naming/MemoizedInstanceVariableName
end

.compile! ⇒ Object 



81
82
83
84
85
 
# 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
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



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

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&.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
169
170
171
172
 
# File 'lib/grape/api/instance.rb', line 164

def call(env)
  status, headers, response = @router.call(env)
  unless cascade?
    headers = Grape::Util::Header.new.merge(headers)
    headers.delete('X-Cascade')
  end

  [status, headers, response]
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:



182
183
184
185
186
187
 
# File 'lib/grape/api/instance.rb', line 182

def cascade?
  return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.key?(:cascade)
  return self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options)&.key?(:cascade)

  true
end