Class: Grape::API

Inherits:
Object
  • Object
show all
Extended by:
ActiveSupport::Autoload
Defined in:
lib/grape/api.rb,
lib/grape.rb,
lib/grape/api/helpers.rb,
lib/grape/api/instance.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 Classes: Instance

Constant Summary collapse

NON_OVERRIDABLE =

Class methods that we want to call on the API rather than on the API object

%I[define_singleton_method instance_variable_set inspect class is_a? ! kind_of?
respond_to? respond_to_missing? const_defined? const_missing parent
parent_name name equal? to_s parents anonymous?].freeze
Boolean = 
Virtus::Attribute::Boolean

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.base_instance ⇒ Object

Returns the value of attribute base_instance.



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

def base_instance
  @base_instance
end

.instances ⇒ Object

Returns the value of attribute instances.



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

def instances
  @instances
end

Class Method Details

.const_missing(*args) ⇒ Object

Alleviates problems with autoloading by tring to search for the constant



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

def const_missing(*args)
  if base_instance.const_defined?(*args)
    base_instance.const_get(*args)
  elsif parent && parent.const_defined?(*args)
    parent.const_get(*args)
  else
    super
  end
end

.inherited(api, base_instance_parent = Grape::API::Instance) ⇒ Object

When inherited, will create a list of all instances (times the API was mounted) It will listen to the setup required to mount that endpoint, and replicate it on any new instance



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

def inherited(api, base_instance_parent = Grape::API::Instance)
  api.initial_setup(base_instance_parent)
  api.override_all_methods!
  make_inheritable(api)
end

.initial_setup(base_instance_parent) ⇒ Object

Initialize the instance variables on the remountable class, and the base_instance an instance that will be used to create the set up but will not be mounted



25
26
27
28
29
30
 
# File 'lib/grape/api.rb', line 25

def initial_setup(base_instance_parent)
  @instances = []
  @setup = []
  @base_parent = base_instance_parent
  @base_instance = mount_instance
end

.make_inheritable(api) ⇒ Object

Allows an API to itself be inheritable:



42
43
44
45
46
47
48
 
# File 'lib/grape/api.rb', line 42

def make_inheritable(api)
  # When a child API inherits from a parent API.
  def api.inherited(child_api)
    # The instances of the child API inherit from the instances of the parent API
    Grape::API.inherited(child_api, base_instance)
  end
end

.method_missing(method, *args, &block) ⇒ Object 



89
90
91
92
93
94
95
96
 
# File 'lib/grape/api.rb', line 89

def method_missing(method, *args, &block)
  # If there's a missing method, it may be defined on the base_instance instead.
  if respond_to_missing?(method)
    base_instance.send(method, *args, &block)
  else
    super
  end
end

.mount_instance(opts = {}) ⇒ Object

The remountable class can have a configuration hash to provide some dynamic class-level variables. For instance, a descripcion could be done using: ‘desc configuration` if it may vary depending on where the endpoint is mounted. Use with care, if you find yourself using configuration too much, you may actually want to provide a new API rather than remount it.



65
66
67
68
69
70
71
 
# File 'lib/grape/api.rb', line 65

def mount_instance(opts = {})
  instance = Class.new(@base_parent)
  instance.configuration = opts[:configuration] || {}
  instance.base = self
  replay_setup_on(instance)
  instance
end

.override_all_methods! ⇒ Object

Redefines all methods so that are forwarded to add_setup and be recorded



33
34
35
36
37
38
39
 
# File 'lib/grape/api.rb', line 33

def override_all_methods!
  (base_instance.methods - NON_OVERRIDABLE).each do |method_override|
    define_singleton_method(method_override) do |*args, &block|
      add_setup(method_override, *args, &block)
    end
  end
end

.replay_setup_on(instance) ⇒ Object

Replays the set up to produce an API as defined in this class, can be called on classes that inherit from Grape::API



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

def replay_setup_on(instance)
  @setup.each do |setup_stage|
    instance.send(setup_stage[:method], *setup_stage[:args], &setup_stage[:block])
  end
end

.respond_to?(method, include_private = false) ⇒ Boolean

Returns:



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

def respond_to?(method, include_private = false)
  super(method, include_private) || base_instance.respond_to?(method, include_private)
end

.respond_to_missing?(method, include_private = false) ⇒ Boolean

Returns:



85
86
87
 
# File 'lib/grape/api.rb', line 85

def respond_to_missing?(method, include_private = false)
  base_instance.respond_to?(method, include_private)
end