module Grape::DSL::Routing::ClassMethods

Attributes

endpoints[R]

Public Instance Methods

do_not_route_head!() click to toggle source

Do not route HEAD requests to GET requests automatically.

# File lib/grape/dsl/routing.rb, line 73
def do_not_route_head!
  namespace_inheritable(:do_not_route_head, true)
end
do_not_route_options!() click to toggle source

Do not automatically route OPTIONS.

# File lib/grape/dsl/routing.rb, line 78
def do_not_route_options!
  namespace_inheritable(:do_not_route_options, true)
end
group(space = nil, options = {}, &block)
Alias for: namespace
mount(mounts, *opts) click to toggle source
# File lib/grape/dsl/routing.rb, line 82
def mount(mounts, *opts)
  mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
  mounts.each_pair do |app, path|
    if app.respond_to?(:mount_instance)
      opts_with = opts.any? ? opts.shift[:with] : {}
      mount({ app.mount_instance(configuration: opts_with) => path })
      next
    end
    in_setting = inheritable_setting

    if app.respond_to?(:inheritable_setting, true)
      mount_path = Grape::Router.normalize_path(path)
      app.top_level_setting.namespace_stackable[:mount_path] = mount_path

      app.inherit_settings(inheritable_setting)

      in_setting = app.top_level_setting

      app.change!
      change!
    end

    endpoints << Grape::Endpoint.new(
      in_setting,
      method: :any,
      path: path,
      app: app,
      route_options: { anchor: false },
      forward_match: !app.respond_to?(:inheritable_setting),
      for: self
    )
  end
end
namespace(space = nil, options = {}, &block) click to toggle source

Declare a “namespace”, which prefixes all subordinate routes with its name. Any endpoints within a namespace, group, resource or segment, etc., will share their parent context as well as any configuration done in the namespace context.

@example

namespace :foo do
  get 'bar' do
    # defines the endpoint: GET /foo/bar
  end
end
# File lib/grape/dsl/routing.rb, line 166
def namespace(space = nil, options = {}, &block)
  @namespace_description = nil unless instance_variable_defined?(:@namespace_description) && @namespace_description

  if space || block
    within_namespace do
      previous_namespace_description = @namespace_description
      @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {})
      nest(block) do
        namespace_stackable(:namespace, Namespace.new(space, **options)) if space
      end
      @namespace_description = previous_namespace_description
    end
  else
    Namespace.joined_space_path(namespace_stackable(:namespace))
  end
end
Also aliased as: group, resource, resources, segment
prefix(prefix = nil) click to toggle source

Define a root URL prefix for your entire API.

# File lib/grape/dsl/routing.rb, line 58
def prefix(prefix = nil)
  namespace_inheritable(:root_prefix, prefix)
end
reset_endpoints!() click to toggle source
# File lib/grape/dsl/routing.rb, line 199
def reset_endpoints!
  @endpoints = []
end
reset_routes!() click to toggle source

Remove all defined routes.

# File lib/grape/dsl/routing.rb, line 194
def reset_routes!
  endpoints.each(&:reset_routes!)
  @routes = nil
end
resource(space = nil, options = {}, &block)
Alias for: namespace
resources(space = nil, options = {}, &block)
Alias for: namespace
route(methods, paths = ['/'], route_options = {}, &block) click to toggle source

Defines a route that will be recognized by the Grape API.

@param methods [HTTP Verb] One or more HTTP verbs that are accepted by this route. Set to `:any` if you want any verb to be accepted. @param paths [String] One or more strings representing the URL segment(s) for this route.

@example Defining a basic route.

class MyAPI < Grape::API
  route(:any, '/hello') do
    {hello: 'world'}
  end
end
# File lib/grape/dsl/routing.rb, line 128
def route(methods, paths = ['/'], route_options = {}, &block)
  methods = '*' if methods == :any
  endpoint_options = {
    method: methods,
    path: paths,
    for: self,
    route_options: {
      params: namespace_stackable_with_hash(:params) || {}
    }.deep_merge(route_setting(:description) || {}).deep_merge(route_options || {})
  }

  new_endpoint = Grape::Endpoint.new(inheritable_setting, endpoint_options, &block)
  endpoints << new_endpoint unless endpoints.any? { |e| e.equals?(new_endpoint) }

  route_end
  reset_validations!
end
route_param(param, options = {}, &block) click to toggle source

This method allows you to quickly define a parameter route segment in your API.

@param param [Symbol] The name of the parameter you wish to declare. @option options [Regexp] You may supply a regular expression that the declared parameter must meet.

# File lib/grape/dsl/routing.rb, line 208
def route_param(param, options = {}, &block)
  options = options.dup

  options[:requirements] = {
    param.to_sym => options[:requirements]
  } if options[:requirements].is_a?(Regexp)

  Grape::Validations::ParamsScope.new(api: self) do
    requires param, type: options[:type]
  end if options.key?(:type)

  namespace(":#{param}", options, &block)
end
routes() click to toggle source

An array of API routes.

# File lib/grape/dsl/routing.rb, line 189
def routes
  @routes ||= prepare_routes
end
scope(_name = nil, &block) click to toggle source

Create a scope without affecting the URL.

@param _name [Symbol] Purely placebo, just allows to name the scope to make the code more readable.

# File lib/grape/dsl/routing.rb, line 66
def scope(_name = nil, &block)
  within_namespace do
    nest(block)
  end
end
segment(space = nil, options = {}, &block)
Alias for: namespace
version(*args, &block) click to toggle source

Specify an API version.

@example API with legacy support.

class MyAPI < Grape::API
  version 'v2'

  get '/main' do
    {some: 'data'}
  end

  version 'v1' do
    get '/main' do
      {legacy: 'data'}
    end
  end
end
# File lib/grape/dsl/routing.rb, line 31
def version(*args, &block)
  if args.any?
    options = args.extract_options!
    options = options.reverse_merge(using: :path)
    requested_versions = args.flatten

    raise Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)

    @versions = versions | requested_versions

    if block
      within_namespace do
        namespace_inheritable(:version, requested_versions)
        namespace_inheritable(:version_options, options)

        instance_eval(&block)
      end
    else
      namespace_inheritable(:version, requested_versions)
      namespace_inheritable(:version_options, options)
    end
  end

  @versions.last if instance_variable_defined?(:@versions) && @versions
end
versions() click to toggle source

@return array of defined versions

# File lib/grape/dsl/routing.rb, line 223
def versions
  @versions ||= []
end