module Grape::DSL::InsideRoute
Public Class Methods
Source
# File lib/grape/dsl/inside_route.rb, line 20 def self.post_filter_methods(type) @post_filter_modules ||= { before: PostBeforeFilter } @post_filter_modules[type] end
@param type [Symbol] The type of filter for which evaluation has been
completed
@return [Module] A module containing method overrides suitable for the
position in the filter evaluation sequence denoted by +type+. This defaults to an empty module if no overrides are defined for the given filter +type+.
Public Instance Methods
Source
# File lib/grape/dsl/inside_route.rb, line 445 def api_format(format) env[Grape::Env::API_FORMAT] = format end
Source
# File lib/grape/dsl/inside_route.rb, line 270 def body(value = nil) if value @body = value elsif value == false @body = '' status 204 else instance_variable_defined?(:@body) ? @body : nil end end
Allows you to define the response body as something other than the return value.
@example
get '/body' do body "Body" "Not the Body" end GET /body # => "Body"
Source
# File lib/grape/dsl/inside_route.rb, line 158 def configuration options[:for].configuration.evaluate end
Source
# File lib/grape/dsl/inside_route.rb, line 252 def content_type(val = nil) if val header(Rack::CONTENT_TYPE, val) else header[Rack::CONTENT_TYPE] end end
Set response content-type
Source
# File lib/grape/dsl/inside_route.rb, line 149 def declared(*) raise MethodNotYetAvailable, '#declared is not available prior to parameter validation.' end
A filtering method that will return a hash consisting only of keys that have been declared by a ‘params` statement against the current/target endpoint or parent namespaces.
@see +PostBeforeFilter#declared+
@param params [Hash] The initial hash to filter. Usually this will just be ‘params` @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces` options. `:include_parent_namespaces` defaults to true, hence must be set to false if you want only to return params declared against the current/target endpoint.
Source
# File lib/grape/dsl/inside_route.rb, line 412 def entity_class_for_obj(object, options) entity_class = options.delete(:with) if entity_class.nil? # entity class not explicitly defined, auto-detect from relation#klass or first object in the collection object_class = if object.respond_to?(:klass) object.klass else object.respond_to?(:first) ? object.first.class : object.class end object_class.ancestors.each do |potential| entity_class ||= (namespace_stackable_with_hash(:representations) || {})[potential] end entity_class ||= object_class.const_get(:Entity) if object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent) end entity_class end
Attempt to locate the Entity class for a given object, if not given explicitly. This is done by looking for the presence of Klass::Entity, where Klass is the class of the ‘object` parameter, or one of its ancestors. @param object [Object] the object to locate the Entity class for @param options [Hash] @option options :with [Class] the explicit entity class to use @return [Class] the located Entity class, or nil if none is found
Source
# File lib/grape/dsl/inside_route.rb, line 435 def entity_representation_for(entity_class, object, options) embeds = { env: env } embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION) entity_class.represent(object, **embeds, **options) end
@return the representation of the given object as done through
the given entity_class.
Source
# File lib/grape/dsl/inside_route.rb, line 170 def error!(message, status = nil, additional_headers = nil, backtrace = nil, original_exception = nil) status = self.status(status || namespace_inheritable(:default_error_status)) headers = additional_headers.present? ? header.merge(additional_headers) : header throw :error, message: message, status: status, headers: headers, backtrace: backtrace, original_exception: original_exception end
End the request and display an error to the end user with the specified message.
@param message [String] The message to display. @param status [Integer] The HTTP Status Code. Defaults to default_error_status, 500 if not set. @param additional_headers [Hash] Addtional headers for the response. @param backtrace [Array<String>] The backtrace of the exception that caused the error. @param original_exception [Exception] The original exception that caused the error.
Source
# File lib/grape/dsl/inside_route.rb, line 441 def http_version env.fetch('HTTP_VERSION') { env[Rack::SERVER_PROTOCOL] } end
Source
# File lib/grape/dsl/inside_route.rb, line 362 def present(*args) options = args.count > 1 ? args.extract_options! : {} key, object = if args.count == 2 && args.first.is_a?(Symbol) args else [nil, args.first] end entity_class = entity_class_for_obj(object, options) root = options.delete(:root) representation = if entity_class entity_representation_for(entity_class, object, options) else object end representation = { root => representation } if root if key representation = (body || {}).merge(key => representation) elsif entity_class.present? && body raise ArgumentError, "Representation of type #{representation.class} cannot be merged." unless representation.respond_to?(:merge) representation = body.merge(representation) end body representation end
Allows you to make use of Grape
Entities by setting the response body to the serializable hash of the entity provided in the ‘:with` option. This has the added benefit of automatically passing along environment and version information to the serialization, making it very easy to do conditional exposures. See Entity docs for more info.
@example
get '/users/:id' do present User.find(params[:id]), with: API::Entities::User, admin: current_user.admin? end
Source
# File lib/grape/dsl/inside_route.rb, line 193 def rack_response(message, status = 200, headers = { Rack::CONTENT_TYPE => content_type }) Grape.deprecator.warn('The rack_response method has been deprecated, use error! instead.') message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == 'text/html' Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), headers) end
Creates a Rack response based on the provided message, status, and headers. The content type in the headers is set to the default content type unless provided. The message is HTML-escaped if the content type is ‘text/html’.
@param message [String] The content of the response. @param status [Integer] The HTTP status code. @params headers [Hash] (optional) Headers
for the response
(default: {Rack::CONTENT_TYPE => content_type}).
Returns: A Rack::Response object containing the specified message, status, and headers.
Source
# File lib/grape/dsl/inside_route.rb, line 204 def redirect(url, permanent: false, body: nil) body_message = body if permanent status 301 body_message ||= "This resource has been moved permanently to #{url}." elsif http_version == 'HTTP/1.1' && !request.get? status 303 body_message ||= "An alternate resource is located at #{url}." else status 302 body_message ||= "This resource has been moved temporarily to #{url}." end header 'Location', url content_type 'text/plain' body body_message end
Redirect to a new url.
@param url [String] The url to be redirect. @param permanent [Boolean] default false. @param body default a short message including the URL.
Source
# File lib/grape/dsl/inside_route.rb, line 290 def return_no_content status 204 body false end
Allows you to explicitly return no content.
@example
delete :id do return_no_content "not returned" end DELETE /12 # => 204 No Content, ""
Source
# File lib/grape/dsl/inside_route.rb, line 400 def route env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info] end
Returns route information for the current request.
@example
desc "Returns the route description." get '/' do route.description end
Source
# File lib/grape/dsl/inside_route.rb, line 303 def sendfile(value = nil) if value.is_a?(String) file_body = Grape::ServeStream::FileBody.new(value) @stream = Grape::ServeStream::StreamResponse.new(file_body) elsif !value.is_a?(NilClass) raise ArgumentError, 'Argument must be a file path' else stream end end
Allows you to send a file to the client via sendfile.
@example
get '/file' do sendfile FileStreamer.new(...) end GET /file # => "contents of file"
Source
# File lib/grape/dsl/inside_route.rb, line 224 def status(status = nil) case status when Symbol raise ArgumentError, "Status code :#{status} is invalid." unless Rack::Utils::SYMBOL_TO_STATUS_CODE.key?(status) @status = Rack::Utils.status_code(status) when Integer @status = status when nil return @status if instance_variable_defined?(:@status) && @status if request.post? 201 elsif request.delete? if instance_variable_defined?(:@body) && @body.present? 200 else 204 end else 200 end else raise ArgumentError, 'Status code must be Integer or Symbol.' end end
Set or retrieve the HTTP status code.
@param status [Integer] The HTTP Status Code to return for this request.
Source
# File lib/grape/dsl/inside_route.rb, line 329 def stream(value = nil) return if value.nil? && @stream.nil? header Rack::CONTENT_LENGTH, nil header 'Transfer-Encoding', nil header Rack::CACHE_CONTROL, 'no-cache' # Skips ETag generation (reading the response up front) if value.is_a?(String) file_body = Grape::ServeStream::FileBody.new(value) @stream = Grape::ServeStream::StreamResponse.new(file_body) elsif value.respond_to?(:each) @stream = Grape::ServeStream::StreamResponse.new(value) elsif !value.is_a?(NilClass) raise ArgumentError, 'Stream object must respond to :each.' else @stream end end
Allows you to define the response as a streamable object.
If Content-Length and Transfer-Encoding are blank (among other conditions), Rack assumes this response can be streamed in chunks.
@example
get '/stream' do stream FileStreamer.new(...) end GET /stream # => "chunked contents of file"
See:
Source
# File lib/grape/dsl/inside_route.rb, line 154 def version env[Grape::Env::API_VERSION] end
The API
version as specified in the URL.