Module: Grape::DSL::RequestResponse

Included in:
API::Instance
Defined in:
lib/grape/dsl/request_response.rb

Instance Method Summary collapse

Instance Method Details

#content_type(key, val) ⇒ Object

Specify additional content-types, e.g.:

content_type :xls, 'application/vnd.ms-excel'



54
55
56
 
# File 'lib/grape/dsl/request_response.rb', line 54

def content_type(key, val)
  inheritable_setting.namespace_stackable[:content_types] = { key.to_sym => val }
end

#content_types ⇒ Object

All available content types.



59
60
61
62
 
# File 'lib/grape/dsl/request_response.rb', line 59

def content_types
  c_types = inheritable_setting.namespace_stackable_with_hash(:content_types)
  Grape::ContentTypes.content_types_for c_types
end

#default_error_formatter(new_formatter_name = nil) ⇒ Object

Specify a default error formatter.



40
41
42
43
44
45
 
# File 'lib/grape/dsl/request_response.rb', line 40

def default_error_formatter(new_formatter_name = nil)
  return inheritable_setting.namespace_inheritable[:default_error_formatter] if new_formatter_name.nil?

  new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name)
  inheritable_setting.namespace_inheritable[:default_error_formatter] = new_formatter
end

#default_error_status(new_status = nil) ⇒ Object

Specify the default status code for errors.



65
66
67
68
69
 
# File 'lib/grape/dsl/request_response.rb', line 65

def default_error_status(new_status = nil)
  return inheritable_setting.namespace_inheritable[:default_error_status] if new_status.nil?

  inheritable_setting.namespace_inheritable[:default_error_status] = new_status
end

#default_format(new_format = nil) ⇒ Object

Specify the default format for the API’s serializers. May be ‘:json` or `:txt` (default).



8
9
10
11
12
 
# File 'lib/grape/dsl/request_response.rb', line 8

def default_format(new_format = nil)
  return inheritable_setting.namespace_inheritable[:default_format] if new_format.nil?

  inheritable_setting.namespace_inheritable[:default_format] = new_format.to_sym
end

#error_formatter(format, options = nil, with: nil) ⇒ Object 



47
48
49
50
 
# File 'lib/grape/dsl/request_response.rb', line 47

def error_formatter(format, options = nil, with: nil)
  formatter = with || options
  inheritable_setting.namespace_stackable[:error_formatters] = { format.to_sym => formatter }
end

#format(new_format = nil) ⇒ Object

Specify the format for the API’s serializers. May be ‘:json`, `:xml`, `:txt`, etc.

Raises:



16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/grape/dsl/request_response.rb', line 16

def format(new_format = nil)
  return inheritable_setting.namespace_inheritable[:format] if new_format.nil?

  symbolic_new_format = new_format.to_sym
  inheritable_setting.namespace_inheritable[:format] = symbolic_new_format
  inheritable_setting.namespace_inheritable[:default_error_formatter] = Grape::ErrorFormatter.formatter_for(symbolic_new_format)

  content_type = content_types[symbolic_new_format]
  raise Grape::Exceptions::MissingMimeType.new(new_format) unless content_type

  inheritable_setting.namespace_stackable[:content_types] = { symbolic_new_format => content_type }
end

#formatter(content_type, new_formatter) ⇒ Object

Specify a custom formatter for a content-type.



30
31
32
 
# File 'lib/grape/dsl/request_response.rb', line 30

def formatter(content_type, new_formatter)
  inheritable_setting.namespace_stackable[:formatters] = { content_type.to_sym => new_formatter }
end

#parser(content_type, new_parser) ⇒ Object

Specify a custom parser for a content-type.



35
36
37
 
# File 'lib/grape/dsl/request_response.rb', line 35

def parser(content_type, new_parser)
  inheritable_setting.namespace_stackable[:parsers] = { content_type.to_sym => new_parser }
end

#represent(model_class, with:) ⇒ Object

Allows you to specify a default representation entity for a class. This allows you to map your models to their respective entities once and then simply call ‘present` with the model.

Note that Grape will automatically go up the class ancestry to try to find a representing entity, so if you, for example, define an entity to represent ‘Object` then all presented objects will bubble up and utilize the entity provided on that `represent` call.

Examples:

class ExampleAPI < Grape::API
  represent User, with: Entity::User

  get '/me' do
    present current_user # with: Entity::User is assumed
  end
end

Parameters:

  • model_class (Class) —

    The model class that will be represented.

  • options (Hash) —

    a customizable set of options

Raises:



150
151
152
153
154
 
# File 'lib/grape/dsl/request_response.rb', line 150

def represent(model_class, with:)
  raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless with.is_a?(Class)

  inheritable_setting.namespace_stackable[:representations] = { model_class => with }
end

#rescue_from(*exception_classes, **options) ⇒ Object

Parameters:

  • exception_classes (Array) —

    A list of classes that you want to rescue, or one of the meta selectors :all, :grape_exceptions, :internal_grape_exceptions. Meta selectors must be used alone; mixing with exception classes raises ArgumentError.

  • block (Block) —

    Execution block to handle the given exception.

  • with (Proc) —

    Execution proc to handle the given exception as an alternative to passing a block.

  • rescue_subclasses (Boolean) —

    Also rescue subclasses of exception classes; defaults to true.

  • backtrace (Boolean) —

    Include the rescued exception’s backtrace in the rescue response body.

  • original_exception (Boolean) —

    Include inspect of the rescued exception in the rescue response body.

Raises:

  • (ArgumentError) 


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/grape/dsl/request_response.rb', line 99

def rescue_from(*args, with: nil, rescue_subclasses: true, backtrace: false, original_exception: false, &block)
  handler = extract_handler(args, with:, block:)
  meta_selector = (args & META_RESCUE_SELECTORS).first
  raise ArgumentError, "rescue_from #{meta_selector.inspect} does not accept additional arguments" if meta_selector && args.size > 1

  namespace_inheritable = nil
  arg = nil

  if args.one?
    arg = args.first
    namespace_inheritable = inheritable_setting.namespace_inheritable
  end

  case arg
  when :all
    namespace_inheritable[:rescue_all] = true
    namespace_inheritable[:all_rescue_handler] = handler
  when :grape_exceptions
    namespace_inheritable[:rescue_all] = true
    namespace_inheritable[:rescue_grape_exceptions] = true
    namespace_inheritable[:grape_exceptions_rescue_handler] = handler
  when :internal_grape_exceptions
    namespace_inheritable[:internal_grape_exceptions_rescue_handler] = handler
  else
    handler_type = rescue_subclasses ? :rescue_handlers : :base_only_rescue_handlers
    inheritable_setting.namespace_reverse_stackable[handler_type] = args.to_h { |klass| [klass, handler] }
  end

  inheritable_setting.namespace_stackable[:rescue_options] = RescueOptions.new(backtrace:, original_exception:)
end