Module: Grape::DSL::RequestResponse::ClassMethods

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'



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

def content_type(key, val)
  namespace_stackable(:content_types, key.to_sym => val)
end

#content_typesObject

All available content types.



70
71
72
73
# File 'lib/grape/dsl/request_response.rb', line 70

def content_types
  c_types = Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:content_types))
  Grape::ContentTypes.content_types_for c_types
end

#default_error_formatter(new_formatter_name = nil) ⇒ Object

Specify a default error formatter.



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

def default_error_formatter(new_formatter_name = nil)
  if new_formatter_name
    new_formatter = Grape::ErrorFormatter::Base.formatter_for(new_formatter_name, {})
    namespace_inheritable(:default_error_formatter, new_formatter)
  else
    namespace_inheritable(:default_error_formatter)
  end
end

#default_error_status(new_status = nil) ⇒ Object

Specify the default status code for errors.



76
77
78
# File 'lib/grape/dsl/request_response.rb', line 76

def default_error_status(new_status = nil)
  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).



13
14
15
# File 'lib/grape/dsl/request_response.rb', line 13

def default_format(new_format = nil)
  namespace_inheritable(:default_format, new_format.nil? ? nil : new_format.to_sym)
end

#error_formatter(format, options) ⇒ Object



53
54
55
56
57
58
59
60
61
# File 'lib/grape/dsl/request_response.rb', line 53

def error_formatter(format, options)
  if options.is_a?(Hash) && options.key?(:with)
    formatter = options[:with]
  else
    formatter = options
  end

  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.



19
20
21
22
23
24
25
26
27
28
29
30
31
# File 'lib/grape/dsl/request_response.rb', line 19

def format(new_format = nil)
  if new_format
    namespace_inheritable(:format, new_format.to_sym)
    # define the default error formatters
    namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter::Base.formatter_for(new_format, {}))
    # define a single mime type
    mime_type = content_types[new_format.to_sym]
    fail Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
    namespace_stackable(:content_types, new_format.to_sym => mime_type)
  else
    namespace_inheritable(:format)
  end
end

#formatter(content_type, new_formatter) ⇒ Object

Specify a custom formatter for a content-type.



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

def formatter(content_type, new_formatter)
  namespace_stackable(:formatters, content_type.to_sym => new_formatter)
end

#parser(content_type, new_parser) ⇒ Object

Specify a custom parser for a content-type.



39
40
41
# File 'lib/grape/dsl/request_response.rb', line 39

def parser(content_type, new_parser)
  namespace_stackable(:parsers, content_type.to_sym => new_parser)
end

#represent(model_class, options) ⇒ 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

Options Hash (options):

  • :with (Class)

    The entity class that will represent the model.



148
149
150
151
# File 'lib/grape/dsl/request_response.rb', line 148

def represent(model_class, options)
  fail Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
  namespace_stackable(:representations, model_class => options[:with])
end

#rescue_from(*exception_classes, options = {}) ⇒ Object

Allows you to rescue certain exceptions that occur to return a grape error rather than raising all the way to the server level.

Examples:

Rescue from custom exceptions

class ExampleAPI < Grape::API
  class CustomError < StandardError; end

  rescue_from CustomError
end

Options Hash (options):

  • :backtrace (Boolean)

    Include a backtrace in the rescue response.

  • :rescue_subclasses (Boolean)

    Also rescue subclasses of exception classes



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
# File 'lib/grape/dsl/request_response.rb', line 100

def rescue_from(*args, &block)
  if args.last.is_a?(Proc)
    handler = args.pop
  elsif block_given?
    handler = block
  end

  options = args.last.is_a?(Hash) ? args.pop : {}
  handler ||= proc { options[:with] } if options.key?(:with)

  if args.include?(:all)
    namespace_inheritable(:rescue_all, true)
    namespace_inheritable :all_rescue_handler, handler
  else
    handler_type =
        case options[:rescue_subclasses]
        when nil, true
          :rescue_handlers
        else
          :base_only_rescue_handlers
        end

    namespace_stackable handler_type, Hash[args.map { |arg| [arg, handler] }]
  end

  namespace_stackable(:rescue_options, options)
end