grape
1.0.0
La uva es un marco API similar a un descanso para Ruby. Está diseñado para ejecutar en rack o complementar los marcos de aplicaciones web existentes, como Rails y Sinatra, proporcionando un DSL simple para desarrollar fácilmente API de descanso. Tiene soporte incorporado para convenciones comunes, incluidos múltiples formatos, restricción de subdominios/prefijo, negociación de contenido, versiones y mucho más.
Estás leyendo la documentación para el próximo lanzamiento de Grape, que debería ser 2.3.0. La versión estable actual es 2.2.0.
Disponible como parte de la suscripción de TidElift.
Los mantenedores de la uva están trabajando con TidElift para ofrecer soporte y mantenimiento comerciales. Ahorre tiempo, reduzca el riesgo y mejore la salud del código, al tiempo que paga a los mantenedores de la uva. Haga clic aquí para obtener más detalles.
Se requiere Ruby 2.7 o más nuevo.
La uva está disponible como gema, para instalarla en ejecución:
bundle add grape
Las API de uva son aplicaciones de bastidor que se crean mediante subclasificación Grape::API . A continuación se muestra un ejemplo simple que muestra algunas de las características más comunes de la uva en el contexto de recrear partes de la API de Twitter.
module Twitter
class API < Grape :: API
version 'v1' , using : :header , vendor : 'twitter'
format :json
prefix :api
helpers do
def current_user
@current_user ||= User . authorize! ( env )
end
def authenticate!
error! ( '401 Unauthorized' , 401 ) unless current_user
end
end
resource :statuses do
desc 'Return a public timeline.'
get :public_timeline do
Status . limit ( 20 )
end
desc 'Return a personal timeline.'
get :home_timeline do
authenticate!
current_user . statuses . limit ( 20 )
end
desc 'Return a status.'
params do
requires :id , type : Integer , desc : 'Status ID.'
end
route_param :id do
get do
Status . find ( params [ :id ] )
end
end
desc 'Create a status.'
params do
requires :status , type : String , desc : 'Your status.'
end
post do
authenticate!
Status . create! ( {
user : current_user ,
text : params [ :status ]
} )
end
desc 'Update a status.'
params do
requires :id , type : String , desc : 'Status ID.'
requires :status , type : String , desc : 'Your status.'
end
put ':id' do
authenticate!
current_user . statuses . find ( params [ :id ] ) . update ( {
user : current_user ,
text : params [ :status ]
} )
end
desc 'Delete a status.'
params do
requires :id , type : String , desc : 'Status ID.'
end
delete ':id' do
authenticate!
current_user . statuses . find ( params [ :id ] ) . destroy
end
end
end
end Grape's Deprecator se agregará a los deprecadores de su aplicación automáticamente como :grape , para que la configuración de su aplicación se pueda aplicar.
De forma predeterminada, Grape compilará las rutas en la primera ruta, ¡es posible que precarga las rutas utilizando la compile! método.
Twitter :: API . compile! Esto se puede agregar a su config.ru (si usa rackup), application.rb (si usa rieles) o cualquier archivo que cargue su servidor.
La muestra anterior crea una aplicación de rack que se puede ejecutar desde un archivo config.ru rackup
run Twitter :: API(Con la precarga que puede usar)
Twitter :: API . compile!
run Twitter :: APIY respondería a las siguientes rutas:
GET /api/statuses/public_timeline
GET /api/statuses/home_timeline
GET /api/statuses/:id
POST /api/statuses
PUT /api/statuses/:id
DELETE /api/statuses/:id
La uva también responderá automáticamente a la cabeza y las opciones para todos, y solo opciones para todas las demás rutas.
Si desea montar uva junto con otro marco de bastidor como Sinatra, puede hacerlo fácilmente usando Rack::Cascade :
# Example config.ru
require 'sinatra'
require 'grape'
class API < Grape :: API
get :hello do
{ hello : 'world' }
end
end
class Web < Sinatra :: Base
get '/' do
'Hello world.'
end
end
use Rack :: Session :: Cookie
run Rack :: Cascade . new [ Web , API ] Tenga en cuenta que el orden de cargar aplicaciones con asuntos de Rack::Cascade . La aplicación de uva debe ser la última si desea aumentar los errores 404 personalizados de la uva (¡como error!('Not Found',404) ). Si la aplicación de uva no dura y devuelve la respuesta 404 o 405, Cascade lo utiliza como señal para probar la siguiente aplicación. Esto puede conducir a un comportamiento indeseable que muestra la página 404 incorrecta de la aplicación incorrecta.
Coloque los archivos API en app/api . Rails espera un subdirectorio que coincida con el nombre del módulo Ruby y un nombre de archivo que coincida con el nombre de la clase. En nuestro ejemplo, la ubicación del nombre del archivo y el directorio para Twitter::API deben ser app/api/twitter/api.rb .
Modificar config/routes :
mount Twitter :: API => '/' El autoconsulador predeterminado de Rails es Zeitwerk . Por defecto, inflige api como Api en lugar de API . Para que nuestro ejemplo funcione, debe desenchufar las líneas en la parte inferior de config/initializers/inflections.rb , y agregar API como acrónimo:
ActiveSupport :: Inflector . inflections ( :en ) do | inflect |
inflect . acronym 'API'
endPuede montar múltiples implementaciones de API dentro de otra. Estas no tienen que ser versiones diferentes, pero pueden ser componentes de la misma API.
class Twitter :: API < Grape :: API
mount Twitter :: APIv1
mount Twitter :: APIv2
end También puede montar en una ruta, que es similar a usar prefix dentro de la API montada en sí.
class Twitter :: API < Grape :: API
mount Twitter :: APIv1 => '/v1'
end Las declaraciones como before/after/rescue_from se pueden colocar antes o después mount . En cualquier caso serán heredados.
class Twitter :: API < Grape :: API
before do
header 'X-Base-Header' , 'will be defined for all APIs that are mounted below'
end
rescue_from :all do
error! ( { "error" => "Internal Server Error" } , 500 )
end
mount Twitter :: Users
mount Twitter :: Search
after do
clean_cache!
end
rescue_from ZeroDivisionError do
error! ( { "error" => "Not found" } , 404 )
end
end Puede montar los mismos puntos finales en dos ubicaciones diferentes.
class Voting :: API < Grape :: API
namespace 'votes' do
get do
# Your logic
end
post do
# Your logic
end
end
end
class Post :: API < Grape :: API
mount Voting :: API
end
class Comment :: API < Grape :: API
mount Voting :: API
end Suponiendo que los puntos finales de publicaciones y comentarios se monten en /posts y /comments , ahora debería poder get /posts/votes , post /posts/votes , get /comments/votes y post /comments/votes .
Puede configurar puntos finales remontables para cambiar la forma en que se comportan de acuerdo con donde están montados.
class Voting :: API < Grape :: API
namespace 'votes' do
desc "Vote for your #{ configuration [ :votable ] } "
get do
# Your logic
end
end
end
class Post :: API < Grape :: API
mount Voting :: API , with : { votable : 'posts' }
end
class Comment :: API < Grape :: API
mount Voting :: API , with : { votable : 'comments' }
end Tenga en cuenta que si está pasando un hash como el primer parámetro para mount , deberá poner explícitamente () en torno a los parámetros:
# good
mount ( { :: Some :: Api => '/some/api' } , with : { condition : true } )
# bad
mount :: Some :: Api => '/some/api' , with : { condition : true } Puede acceder a configuration en la clase (para usar como atributos dinámicos), bloques internos (como el espacio de nombres)
Si desea que la lógica ocurra en una configuration , puede usar el ayudante given .
class ConditionalEndpoint :: API < Grape :: API
given configuration [ :some_setting ] do
get 'mount_this_endpoint_conditionally' do
configuration [ :configurable_response ]
end
end
end Si desea que se ejecute un bloque de lógica cada vez que se monta un punto final (dentro del cual puede acceder al hash configuration )
class ConditionalEndpoint :: API < Grape :: API
mounted do
YourLogger . info "This API was mounted at: #{ Time . now } "
get configuration [ :endpoint_name ] do
configuration [ :configurable_response ]
end
end
end Se pueden lograr resultados más complejos utilizando mounted como una expresión dentro de la cual la configuration ya está evaluada como un hash.
class ExpressionEndpointAPI < Grape :: API
get ( mounted { configuration [ :route_name ] || 'default_name' } ) do
# some logic
end
end class BasicAPI < Grape :: API
desc 'Statuses index' do
params : ( configuration [ :entity ] || API :: Entities :: Status ) . documentation
end
params do
requires :all , using : ( configuration [ :entity ] || API :: Entities :: Status ) . documentation
end
get '/statuses' do
statuses = Status . all
type = current_user . admin? ? :full : :default
present statuses , with : ( configuration [ :entity ] || API :: Entities :: Status ) , type : type
end
end
class V1 < Grape :: API
version 'v1'
mount BasicAPI , with : { entity : mounted { configuration [ :entity ] || API :: Entities :: Status } }
end
class V2 < Grape :: API
version 'v2'
mount BasicAPI , with : { entity : mounted { configuration [ :entity ] || API :: Entities :: V2 :: Status } }
end Tiene la opción de proporcionar varias versiones de su API estableciendo una clase Grape::API separada para cada versión ofrecida y luego integrándolas en una clase primaria Grape::API . Asegúrese de que las versiones más nuevas estén montadas antes que las más antiguas. El enfoque predeterminado para versiones dirige la solicitud al posterior rack middleware si no se encuentra una versión específica.
require 'v1'
require 'v2'
require 'v3'
class App < Grape :: API
mount V3
mount V2
mount V1
endPara mantener los mismos puntos finales de las versiones API anteriores sin reescribirlos, puede indicar múltiples versiones dentro de las versiones API anteriores.
class V1 < Grape :: API
version 'v1' , 'v2' , 'v3'
get '/foo' do
# your code for GET /foo
end
get '/other' do
# your code for GET /other
end
end
class V2 < Grape :: API
version 'v2' , 'v3'
get '/var' do
# your code for GET /var
end
end
class V3 < Grape :: API
version 'v3'
get '/foo' do
# your new code for GET /foo
end
endUsando el ejemplo proporcionado, los puntos finales posteriores serán accesibles en varias versiones:
GET /v1/foo
GET /v1/other
GET /v2/foo # => Same behavior as v1
GET /v2/other # => Same behavior as v1
GET /v2/var # => New endpoint not available in v1
GET /v3/foo # => Different behavior to v1 and v2
GET /v3/other # => Same behavior as v1 and v2
GET /v3/var # => Same behavior as v2 Hay cuatro estrategias en las que los clientes pueden alcanzar los puntos finales de su API :: :path , :header , :accept_version_header y :param . La estrategia predeterminada es :path .
version 'v1' , using : :pathUsando esta estrategia de versiones, los clientes deben pasar la versión deseada en la URL.
curl http://localhost:9292/v1/statuses/public_timeline
version 'v1' , using : :header , vendor : 'twitter'Actualmente, Grape solo admite tipos de medios versionados en el siguiente formato:
vnd.vendor-and-or-resource-v1234+format
Básicamente, todas las fichas entre la - y el + se interpretarán como la versión.
Usando esta estrategia de versiones, los clientes deben pasar la versión deseada en el cabezal HTTP Accept .
curl -H Accept:application/vnd.twitter-v1+json http://localhost:9292/statuses/public_timeline
Por defecto, la primera versión coincidente se usa cuando no se suministra encabezado Accept . Este comportamiento es similar al enrutamiento en los rieles. Para eludir este comportamiento predeterminado, uno podría usar la opción :strict . Cuando esta opción se establece en true , se devuelve un error 406 Not Acceptable cuando no se proporciona un encabezado Accept correcto.
Cuando se suministra un encabezado Accept no válido, se devuelve un error 406 Not Acceptable si la opción :cascade se establece en false . De lo contrario, Rack devuelve un error 404 Not Found si no coincide con otra ruta.
La uva evaluará la preferencia de calidad relativa incluida en los encabezados de aceptación y el valor predeterminado a una calidad de 1.0 cuando se omite. En el siguiente ejemplo, una API de uva que admite XML y JSON en ese orden devolverá JSON:
curl -H "Accept: text/xml;q=0.8, application/json;q=0.9" localhost:1234/resource
version 'v1' , using : :accept_version_header Usando esta estrategia de versiones, los clientes deben pasar la versión deseada en el encabezado HTTP Accept-Version .
curl -H "Accept-Version:v1" http://localhost:9292/statuses/public_timeline
Por defecto, la primera versión coincidente se usa cuando no se suministra encabezado Accept-Version . Este comportamiento es similar al enrutamiento en los rieles. Para eludir este comportamiento predeterminado, uno podría usar la opción :strict . Cuando esta opción se establece en true , se devuelve un error 406 Not Acceptable cuando no se proporciona un encabezado Accept correcto y la opción :cascade se establece en false . De lo contrario, Rack devuelve un error 404 Not Found si no coincide con otra ruta.
version 'v1' , using : :paramUsando esta estrategia de versiones, los clientes deben pasar la versión deseada como parámetro de solicitud, ya sea en la cadena de consulta de URL o en el cuerpo de solicitudes.
curl http://localhost:9292/statuses/public_timeline?apiver=v1
El nombre predeterminado para el parámetro de consulta es 'Apiver', pero se puede especificar utilizando la opción :parameter .
version 'v1' , using : :param , parameter : 'v' curl http://localhost:9292/statuses/public_timeline?v=v1
Puede agregar una descripción a los métodos y espacios de nombres API. La descripción sería utilizada por uva de uva para generar documentación compatible con Swagger.
Nota: El bloque de descripción es solo para documentación y no afectará el comportamiento de la API.
desc 'Returns your public timeline.' do
summary 'summary'
detail 'more details'
params API :: Entities :: Status . documentation
success API :: Entities :: Entity
failure [ [ 401 , 'Unauthorized' , 'Entities::Error' ] ]
default { code : 500 , message : 'InvalidRequest' , model : Entities :: Error }
named 'My named route'
headers XAuthToken : {
description : 'Validates your identity' ,
required : true
} ,
XOptionalHeader : {
description : 'Not really needed' ,
required : false
}
hidden false
deprecated false
is_array true
nickname 'nickname'
produces [ 'application/json' ]
consumes [ 'application/json' ]
tags [ 'tag1' , 'tag2' ]
end
get :public_timeline do
Status . limit ( 20 )
enddetail : una descripción más mejoradaparams : Defina parámetros directamente de una Entitysuccess : (antigua entidad) La Entity que se utilizará para presentar la respuesta de éxito para esta ruta.failure : (antiguo http_codes) Una definición de los códigos y entidades HTTP de falla utilizados.default : la definición y Entity utilizadas para presentar la respuesta predeterminada para esta ruta.named : un ayudante para darle un nombre a una ruta y encontrarla con este nombre en el hash de la documentaciónheaders : una definición de los encabezados usados Use Grape.configure para configurar la configuración global en el momento de la carga. Actualmente, las configuraciones configurables son:
param_builder : establece el constructor de parámetros, predeterminado a Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder .Para cambiar un valor de configuración, asegúrese de que en algún momento durante el tiempo de carga se ejecute el siguiente código.
Grape . configure do | config |
config . setting = value
end Por ejemplo, para el param_builder , el siguiente código podría ejecutarse en un inicializador:
Grape . configure do | config |
config . param_builder = Grape :: Extensions :: Hashie :: Mash :: ParamBuilder
endTambién puede configurar una sola API:
API . configure do | config |
config [ key ] = value
end Esto estará disponible dentro de la API con configuration , como si fuera la configuración de montaje.
Los parámetros de solicitud están disponibles a través del objeto de hash params . Esto incluye los parámetros GET , POST y PUT , junto con los parámetros con nombre que especifique en sus cadenas de ruta.
get :public_timeline do
Status . order ( params [ :sort_by ] )
end Los parámetros se poblan automáticamente desde el cuerpo de solicitud en POST y PUT para la entrada de formulario, los tipos de contenido JSON y XML.
La solicitud:
curl -d '{"text": "140 characters"}' 'http://localhost:9292/statuses' -H Content-Type:application/json -v
El punto final de uva:
post '/statuses' do
Status . create! ( text : params [ :text ] )
endLas publicaciones y puts multipart también son compatibles.
La solicitud:
curl --form image_file='@image.jpg;type=image/jpg' http://localhost:9292/upload
El punto final de uva:
post 'upload' do
# file in params[:image_file]
endEn el caso del conflicto entre cualquiera de:
GET , POST y PUT parámetrosPOST y PUTLos parámetros de cadena de ruta tendrán precedencia.
Por defecto, los parámetros están disponibles como ActiveSupport::HashWithIndifferentAccess . Esto se puede cambiar a, por ejemplo, Ruby Hash o Hashie::Mash para toda la API.
class API < Grape :: API
include Grape :: Extensions :: Hashie :: Mash :: ParamBuilder
params do
optional :color , type : String
end
get do
params . color # instead of params[:color]
end La clase también se puede anular en bloques de parámetros individuales utilizando build_with de la siguiente manera.
params do
build_with Grape :: Extensions :: Hash :: ParamBuilder
optional :color , type : String
end O globalmente con la configuración Grape.configure.param_builder .
En el ejemplo anterior, params["color"] devolverá nil ya que params es un Hash simple.
Los constructores de parámetros disponibles son Grape::Extensions::Hash::ParamBuilder , Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder y Grape::Extensions::Hashie::Mash::ParamBuilder .
La uva le permite acceder solo a los parámetros que han sido declarados por su bloque params . Va a:
Considere el siguiente punto final de la API:
format :json
post 'users/signup' do
{ 'declared_params' => declared ( params ) }
end Si no especifica ningún parámetro, declared devolverá un hash vacío.
Pedido
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "last_name": "last name"}} 'Respuesta
{
"declared_params" : {}
}
Una vez que agregamos los requisitos de parámetros, Grape comenzará a devolver solo los parámetros declarados.
format :json
params do
optional :user , type : Hash do
optional :first_name , type : String
optional :last_name , type : String
end
end
post 'users/signup' do
{ 'declared_params' => declared ( params ) }
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "last_name": "last name", "random": "never shown"}} 'Respuesta
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : " last name "
}
}
} Se incluirán los parámetros faltantes que se declaran Hash o Array .
format :json
params do
optional :user , type : Hash do
optional :first_name , type : String
optional :last_name , type : String
end
optional :widgets , type : Array
end
post 'users/signup' do
{ 'declared_params' => declared ( params ) }
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {} 'Respuesta
{
"declared_params" : {
"user" : {
"first_name" : null ,
"last_name" : null
},
"widgets" : []
}
} El hash devuelto es un ActiveSupport::HashWithIndifferentAccess .
El método #declared no está disponible before los filtros, ya que se evalúan antes de la coerción de parámetros.
Por defecto, declared(params) incluye parámetros que se definieron en todos los espacios de nombres principales. Si desea devolver solo los parámetros de su espacio de nombres actual, puede establecer la opción include_parent_namespaces en false .
format :json
namespace :parent do
params do
requires :parent_name , type : String
end
namespace ':parent_name' do
params do
requires :child_name , type : String
end
get ':child_name' do
{
'without_parent_namespaces' => declared ( params , include_parent_namespaces : false ) ,
'with_parent_namespaces' => declared ( params , include_parent_namespaces : true ) ,
}
end
end
endPedido
curl -X GET -H " Content-Type: application/json " localhost:9292/parent/foo/barRespuesta
{
"without_parent_namespaces" : {
"child_name" : " bar "
},
"with_parent_namespaces" : {
"parent_name" : " foo " ,
"child_name" : " bar "
},
} Por defecto declared(params) incluye parámetros que tienen valores nil . Si desea devolver solo los parámetros que no son nil , puede usar la opción include_missing . Por defecto, include_missing se establece en true . Considere la siguiente API:
format :json
params do
requires :user , type : Hash do
requires :first_name , type : String
optional :last_name , type : String
end
end
post 'users/signup' do
{ 'declared_params' => declared ( params , include_missing : false ) }
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "random": "never shown"}} 'Respuesta con incluir_missing: falso
{
"declared_params" : {
"user" : {
"first_name" : " first name "
}
}
}Respuesta con incluir_missing: verdadero
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : null
}
}
}También funciona en hashes anidados:
format :json
params do
requires :user , type : Hash do
requires :first_name , type : String
optional :last_name , type : String
requires :address , type : Hash do
requires :city , type : String
optional :region , type : String
end
end
end
post 'users/signup' do
{ 'declared_params' => declared ( params , include_missing : false ) }
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "random": "never shown", "address": { "city": "SF"}}} 'Respuesta con incluir_missing: falso
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"address" : {
"city" : " SF "
}
}
}
}Respuesta con incluir_missing: verdadero
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : null ,
"address" : {
"city" : " Zurich " ,
"region" : null
}
}
}
} Tenga en cuenta que un atributo con un valor nil no se considera faltante y también se devolverá cuando include_missing se establece en false :
Pedido
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "last_name": null, "address": { "city": "SF"}}} 'Respuesta con incluir_missing: falso
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : null ,
"address" : { "city" : " SF " }
}
}
} Por defecto declared(params) no given y devolverá todos los parámetros. Use evaluate_given para evaluar todos los bloques given y devolver solo los parámetros que satisfacen las condiciones given . Considere la siguiente API:
format :json
params do
optional :child_id , type : Integer
given :child_id do
requires :father_id , type : Integer
end
end
post 'child' do
{ 'declared_params' => declared ( params , evaluate_given : true ) }
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/child -d ' {"father_id": 1} 'Respuesta con evaluate_given: falso
{
"declared_params" : {
"child_id" : null ,
"father_id" : 1
}
}Respuesta con Evaluate_Given: Verdadero
{
"declared_params" : {
"child_id" : null
}
}También funciona en hashes anidados:
format :json
params do
requires :child , type : Hash do
optional :child_id , type : Integer
given :child_id do
requires :father_id , type : Integer
end
end
end
post 'child' do
{ 'declared_params' => declared ( params , evaluate_given : true ) }
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/child -d ' {"child": {"father_id": 1}} 'Respuesta con evaluate_given: falso
{
"declared_params" : {
"child" : {
"child_id" : null ,
"father_id" : 1
}
}
}Respuesta con Evaluate_Given: Verdadero
{
"declared_params" : {
"child" : {
"child_id" : null
}
}
} El uso de route_param tiene mayor precedencia sobre un parámetro regular definido con el mismo nombre:
params do
requires :foo , type : String
end
route_param :foo do
get do
{ value : params [ :foo ] }
end
endPedido
curl -X POST -H " Content-Type: application/json " localhost:9292/bar -d ' {"foo": "baz"} 'Respuesta
{
"value" : " bar "
} Puede definir validaciones y opciones de coerción para sus parámetros utilizando un bloque params .
params do
requires :id , type : Integer
optional :text , type : String , regexp : / A [a-z]+ z /
group :media , type : Hash do
requires :url
end
optional :audio , type : Hash do
requires :format , type : Symbol , values : [ :mp3 , :wav , :aac , :ogg ] , default : :mp3
end
mutually_exclusive :media , :audio
end
put ':id' do
# params[:id] is an Integer
endCuando se especifica un tipo, se realiza una validación implícita después de la coerción para garantizar que el tipo de salida sea el declarado.
Los parámetros opcionales pueden tener un valor predeterminado.
params do
optional :color , type : String , default : 'blue'
optional :random_number , type : Integer , default : -> { Random . rand ( 1 .. 100 ) }
optional :non_random_number , type : Integer , default : Random . rand ( 1 .. 100 )
end Los valores predeterminados se evalúan ansiosamente. Arriba :non_random_number se evaluará con el mismo número para cada llamada al punto final de este bloque params . Para que la evaluación predeterminada sea perezosamente con cada solicitud, use un Lambda, como :random_number arriba.
Tenga en cuenta que los valores predeterminados se pasarán a cualquier opción de validación especificada. El siguiente ejemplo siempre fallará si :color no se proporciona explícitamente.
params do
optional :color , type : String , default : 'blue' , values : [ 'red' , 'green' ]
endLa implementación correcta es garantizar que el valor predeterminado pase todas las validaciones.
params do
optional :color , type : String , default : 'blue' , values : [ 'blue' , 'red' , 'green' ]
end Puede usar el valor de un parámetro como el valor predeterminado de algún otro parámetro. En este caso, si no se proporciona el parámetro primary_color , tendrá el mismo valor que el color . Si ambos no se proporcionan, ambos tendrán un valor blue .
params do
optional :color , type : String , default : 'blue'
optional :primary_color , type : String , default : -> ( params ) { params [ :color ] }
endLos siguientes son todos tipos válidos, admitidos fuera de la caja por uva:
File de alias)Tenga en cuenta que el comportamiento difiere entre Ruby 2.4 y las versiones anteriores. En Ruby 2.4, los valores que consisten en números se convierten en entero, pero en versiones anteriores se tratará como fixnum.
params do
requires :integers , type : Hash do
requires :int , coerce : Integer
end
end
get '/int' do
params [ :integers ] [ :int ] . class
end
. ..
get '/int' integers : { int : '45' }
#=> Integer in ruby 2.4
#=> Fixnum in earlier ruby versions Además del conjunto predeterminado de tipos compatibles enumerados anteriormente, cualquier clase se puede usar como tipo siempre que se suministre un método de coerción explícita. Si el tipo implementa un método parse a nivel de clase, Grape lo usará automáticamente. Este método debe tomar un argumento de cadena y devolver una instancia del tipo correcto, o devolver una instancia de Grape::Types::InvalidValue que opcionalmente acepta un mensaje que se devuelve en la respuesta.
class Color
attr_reader :value
def initialize ( color )
@value = color
end
def self . parse ( value )
return new ( value ) if %w[ blue red green ] . include? ( value )
Grape :: Types :: InvalidValue . new ( 'Unsupported color' )
end
end
params do
requires :color , type : Color , default : Color . new ( 'blue' )
requires :more_colors , type : Array [ Color ] # Collections work
optional :unique_colors , type : Set [ Color ] # Duplicates discarded
end
get '/stuff' do
# params[:color] is already a Color.
params [ :color ] . value
end Alternativamente, se puede suministrar un método de coerción personalizado para cualquier tipo de parámetro utilizando coerce_with . Se puede dar cualquier clase u objeto que implementa un método parse o call , en ese orden de precedencia. El método debe aceptar un solo parámetro de cadena, y el valor de retorno debe coincidir con el type dado.
params do
requires :passwd , type : String , coerce_with : Base64 . method ( :decode64 )
requires :loud_color , type : Color , coerce_with : -> ( c ) { Color . parse ( c . downcase ) }
requires :obj , type : Hash , coerce_with : JSON do
requires :words , type : Array [ String ] , coerce_with : -> ( val ) { val . split ( / s +/ ) }
optional :time , type : Time , coerce_with : Chronic
end
end Tenga en cuenta que un valor nil llamará al método de coerción personalizada, mientras que un parámetro faltante no lo hará.
Ejemplo de uso de coerce_with con una lambda (también podría haberse utilizado una clase con un método parse ), analizará una cadena y devolverá una matriz de enteros, coincidiendo con el type de Array[Integer] .
params do
requires :values , type : Array [ Integer ] , coerce_with : -> ( val ) { val . split ( / s +/ ) . map ( & :to_i ) }
end Grape afirmará que los valores coaccionados coinciden con el type dado y rechazará la solicitud si no lo hacen. Para anular este comportamiento, ¿los tipos personalizados pueden implementar un parsed? Método que debe aceptar un solo argumento y devolver true si el valor pasa la validación de tipo.
class SecureUri
def self . parse ( value )
URI . parse value
end
def self . parsed? ( value )
value . is_a? URI :: HTTPS
end
end
params do
requires :secure_uri , type : SecureUri
end La uva utiliza el soporte incorporado de Rack::Request para los parámetros del archivo multipart. Dichos parámetros se pueden declarar con type: File :
params do
requires :avatar , type : File
end
post '/' do
params [ :avatar ] [ :filename ] # => 'avatar.png'
params [ :avatar ] [ :type ] # => 'image/png'
params [ :avatar ] [ :tempfile ] # => #<File>
endJSON de primera clase Grape admite parámetros complejos dados como cadenas formatadas en JSON utilizando el type: JSON . Los objetos JSON y las matrices de objetos se aceptan por igual, con reglas de validación anidada aplicadas a todos los objetos en cualquier caso:
params do
requires :json , type : JSON do
requires :int , type : Integer , values : [ 1 , 2 , 3 ]
end
end
get '/' do
params [ :json ] . inspect
end
client . get ( '/' , json : '{"int":1}' ) # => "{:int=>1}"
client . get ( '/' , json : '[{"int":"1"}]' ) # => "[{:int=>1}]"
client . get ( '/' , json : '{"int":4}' ) # => HTTP 400
client . get ( '/' , json : '[{"int":4}]' ) # => HTTP 400 Además, se puede utilizar type: Array[JSON] , lo que marca explícitamente el parámetro como una matriz de objetos. Si se suministra un solo objeto, se envolverá.
params do
requires :json , type : Array [ JSON ] do
requires :int , type : Integer
end
end
get '/' do
params [ :json ] . each { | obj | ... } # always works
end Para un control más estricto sobre el tipo de estructura JSON que se puede suministrar, use type: Array, coerce_with: JSON o type: Hash, coerce_with: JSON .
Los parámetros de tipo variante se pueden declarar utilizando la opción types en lugar de type :
params do
requires :status_code , types : [ Integer , String , Array [ Integer , String ] ]
end
get '/' do
params [ :status_code ] . inspect
end
client . get ( '/' , status_code : 'OK_GOOD' ) # => "OK_GOOD"
client . get ( '/' , status_code : 300 ) # => 300
client . get ( '/' , status_code : %w( 404 NOT FOUND ) ) # => [404, "NOT", "FOUND"] Como caso especial, también se pueden declarar colecciones de tipo variante-miembro, al pasar un Set o Array con más de un miembro a type :
params do
requires :status_codes , type : Array [ Integer , String ]
end
get '/' do
params [ :status_codes ] . inspect
end
client . get ( '/' , status_codes : %w( 1 two ) ) # => [1, "two"] Los parámetros se pueden anidar usando group o llamando requires u optional con un bloque. En el ejemplo anterior, esto significa params[:media][:url] se requiere junto con params[:id] , y params[:audio][:format] es necesario solo si params[:audio] está presente. Con un bloque, group , requires y optional un type de opción adicional que puede ser Array o Hash , y el valor predeterminado se mata a Array . Dependiendo del valor, los parámetros anidados se tratarán como valores de un hash o como valores de hashes en una matriz.
params do
optional :preferences , type : Array do
requires :key
requires :value
end
requires :name , type : Hash do
requires :first_name
requires :last_name
end
end Supongamos que algunos de sus parámetros solo son relevantes si se da otro parámetro; La uva le permite expresar esta relación a través del método given en su bloque de parámetros, como así:
params do
optional :shelf_id , type : Integer
given :shelf_id do
requires :bin_id , type : Integer
end
end ¿En el ejemplo anterior, la uva usará blank? para verificar si el parámetro shelf_id está presente.
given también toma un Proc con código personalizado. A continuación, la description de Param se requiere solo si el valor de category es igual foo :
params do
optional :category
given category : -> ( val ) { val == 'foo' } do
requires :description
end
endPuede cambiar el nombre de los parámetros:
params do
optional :category , as : :type
given type : -> ( val ) { val == 'foo' } do
requires :description
end
end Nota: Param in given debe ser el renombrado. En el ejemplo, debe ser type , no category .
Las opciones de parámetros se pueden agrupar. Puede ser útil si desea extraer validación o tipos comunes para varios parámetros. Dentro de estos grupos, los parámetros individuales pueden extender o anular selectivamente la configuración común, lo que le permite mantener los valores predeterminados en el nivel de grupo mientras aplica reglas específicas de parámetros cuando sea necesario.
El siguiente ejemplo presenta un caso típico cuando los parámetros comparten opciones comunes.
params do
requires :first_name , type : String , regexp : /w+/ , desc : 'First name' , documentation : { in : 'body' }
optional :middle_name , type : String , regexp : /w+/ , desc : 'Middle name' , documentation : { in : 'body' , x : { nullable : true } }
requires :last_name , type : String , regexp : /w+/ , desc : 'Last name' , documentation : { in : 'body' }
end La uva le permite presentar la misma lógica a través del método with el método en su bloque de parámetros, como así:
params do
with ( type : String , regexp : /w+/ , documentation : { in : 'body' } ) do
requires :first_name , desc : 'First name'
optional :middle_name , desc : 'Middle name' , documentation : { x : { nullable : true } }
requires :last_name , desc : 'Last name'
end
endPuede organizar la configuración en capas utilizando bloques `con 'anidados. Cada capa puede usar, agregar o cambiar la configuración de la capa encima. Esto ayuda a mantener los parámetros complejos organizados y consistentes, al tiempo que permite realizar personalizaciones específicas.
params do
with ( documentation : { in : 'body' } ) do # Applies documentation to all nested parameters
with ( type : String , regexp : / w +/ ) do # Applies type and validation to names
requires :first_name , desc : 'First name'
requires :last_name , desc : 'Last name'
end
optional :age , type : Integer , desc : 'Age' , documentation : { x : { nullable : true } } # Specific settings for 'age'
end
end Puede cambiar el nombre de los parámetros usando as , lo que puede ser útil al refactorizar las API existentes:
resource :users do
params do
requires :email_address , as : :email
requires :password
end
post do
User . create! ( declared ( params ) ) # User takes email and password
end
end El valor pasó a as será la clave al llamar a declared(params) .
allow_blank Los parámetros se pueden definir como allow_blank , asegurando que contengan un valor. Por defecto, requires que solo valida que se envió un parámetro en la solicitud, independientemente de su valor. Con allow_blank: false , valores vacíos o solo valores en blanco no son válidos.
allow_blank se puede combinar con las requires y optional . Si se requiere el parámetro, debe contener un valor. Si es opcional, es posible no enviarlo a la solicitud, pero si se envía, tiene que tener algún valor, y no una cadena vacía/solo espacios en blanco.
params do
requires :username , allow_blank : false
optional :first_name , allow_blank : false
end values Los parámetros se pueden restringir a un conjunto específico de valores con la opción :values .
params do
requires :status , type : Symbol , values : [ :not_started , :processing , :done ]
optional :numbers , type : Array [ Integer ] , default : 1 , values : [ 1 , 2 , 3 , 5 , 8 ]
end El suministro de un rango a la opción :values asegura que el parámetro esté (o los parámetros) incluido en ese rango (usando Range#include? ).
params do
requires :latitude , type : Float , values : - 90.0 ..+ 90.0
requires :longitude , type : Float , values : - 180.0 ..+ 180.0
optional :letters , type : Array [ String ] , values : 'a' .. 'z'
endNota Los rangos interminables también son compatibles con ActiveSupport> = 6.0, pero requieren que se proporcione el tipo.
params do
requires :minimum , type : Integer , values : 10 ..
optional :maximum , type : Integer , values : .. 10
end Tenga en cuenta que ambos puntos finales de rango tienen que ser un #kind_of? Su :type (si no proporciona la opción :type , se adivinará que es igual a la clase del primer punto final de la gama). Entonces lo siguiente no es válido:
params do
requires :invalid1 , type : Float , values : 0 .. 10 # 0.kind_of?(Float) => false
optional :invalid2 , values : 0 .. 10.0 # 10.0.kind_of?(0.class) => false
end La opción :values también se puede suministrar con un Proc , evaluarse perezosamente con cada solicitud. Si el Proc tiene aridad cero (es decir, no se requiere argumentos) se espera que devuelva una lista o un rango que luego se usará para validar el parámetro.
Por ejemplo, dado un modelo de estado, es posible que desee restringir por hashtags que ha definido previamente en el modelo HashTag .
params do
requires :hashtag , type : String , values : -> { Hashtag . all . map ( & :tag ) }
endAlternativamente, se puede utilizar un proceso con arity uno (es decir, tomar un argumento) para validar explícitamente cada valor de parámetro. En ese caso, se espera que el Proc devuelva un valor verdadero si el valor del parámetro es válido. El parámetro se considerará inválido si el Proc devuelve un valor de falsificación o si plantea un StandardError.
params do
requires :number , type : Integer , values : -> ( v ) { v . even? && v < 25 }
endSi bien los procesos son convenientes para casos individuales, considere usar validadores personalizados en los casos en que una validación se usa más de una vez.
Tenga en cuenta que se aplica el validador de Termod_Blank mientras se usa :values . En el siguiente ejemplo, la ausencia de :allow_blank no evita :state reciba valores en blanco porque :allow_blank predeterminado es true .
params do
requires :state , type : Symbol , values : [ :active , :inactive ]
end except_values Los parámetros pueden restringirse a tener un conjunto específico de valores con la opción :except_values .
El validador except_values se comporta de manera similar al validador values en que acepta una matriz, un rango o un proc. Sin embargo, a diferencia del validador values , except_values solo acepta procs con Arity Zero.
params do
requires :browser , except_values : [ 'ie6' , 'ie7' , 'ie8' ]
requires :port , except_values : { value : 0 .. 1024 , message : 'is not allowed' }
requires :hashtag , except_values : -> { Hashtag . FORBIDDEN_LIST }
end same_as Se puede dar una opción same_as para garantizar que los valores de los parámetros coincidan.
params do
requires :password
requires :password_confirmation , same_as : :password
end length Los parámetros con tipos que admiten el método #length se pueden restringir para tener una longitud específica con la opción :length .
El validador acepta :min o :max o ambas opciones o solo :is validar que el valor del parámetro está dentro de los límites dados.
params do
requires :code , type : String , length : { is : 2 }
requires :str , type : String , length : { min : 3 }
requires :list , type : [ Integer ] , length : { min : 3 , max : 5 }
requires :hash , type : Hash , length : { max : 5 }
end regexp Los parámetros pueden restringirse para que coincidan con una expresión regular específica con la opción :regexp . Si el valor no coincide con la expresión regular, se devolverá un error. Tenga en cuenta que esto es cierto tanto para requires como para los parámetros optional .
params do
requires :email , regexp : /.+@.+/
end El validador pasará si el parámetro se envió sin valor. Para asegurarse de que el parámetro contenga un valor, use allow_blank: false .
params do
requires :email , allow_blank : false , regexp : /.+@.+/
end mutually_exclusive Los parámetros se pueden definir como mutually_exclusive , asegurando que no estén presentes al mismo tiempo en una solicitud.
params do
optional :beer
optional :wine
mutually_exclusive :beer , :wine
endSe pueden definir múltiples conjuntos:
params do
optional :beer
optional :wine
mutually_exclusive :beer , :wine
optional :scotch
optional :aquavit
mutually_exclusive :scotch , :aquavit
endADVERTENCIA : Nunca defina conjuntos mutuamente excluyentes con los parámetros requeridos. Dos parámetros requeridos mutuamente excluyentes significarán que los parámetros nunca son válidos, lo que hace que el punto final sea inútil. Un par de parámetro requerido mutuamente excluyente con un parámetro opcional significará que este último nunca es válido.
exactly_one_ofLos parámetros se pueden definir como 'exactamente_one_of', asegurando que se seleccione exactamente un parámetro.
params do
optional :beer
optional :wine
exactly_one_of :beer , :wine
end Tenga en cuenta que usar :default con mutually_exclusive hará que múltiples parámetros tengan siempre un valor predeterminado y plantee una Grape::Exceptions::Validation mutuamente exclusiva excepción.
at_least_one_ofLos parámetros se pueden definir como 'AT_LEAST_ONE_OF', asegurando que se seleccione al menos un parámetro.
params do
optional :beer
optional :wine
optional :juice
at_least_one_of :beer , :wine , :juice
end all_or_none_ofLos parámetros se pueden definir como 'all_or_none_of', asegurando que todos o ninguno de los parámetros se seleccionen.
params do
optional :beer
optional :wine
optional :juice
all_or_none_of :beer , :wine , :juice
end mutually_exclusive , exactly_one_of , at_least_one_of , all_or_none_ofTodos estos métodos se pueden usar en cualquier nivel anidado.
params do
requires :food , type : Hash do
optional :meat
optional :fish
optional :rice
at_least_one_of :meat , :fish , :rice
end
group :drink , type : Hash do
optional :beer
optional :wine
optional :juice
exactly_one_of :beer , :wine , :juice
end
optional :dessert , type : Hash do
optional :cake
optional :icecream
mutually_exclusive :cake , :icecream
end
optional :recipe , type : Hash do
optional :oil
optional :meat
all_or_none_of :oil , :meat
end
endLos espacios de nombres permiten definiciones de parámetros y se aplican a cada método dentro del espacio de nombres.
namespace :statuses do
params do
requires :user_id , type : Integer , desc : 'A user ID.'
end
namespace ':user_id' do
desc "Retrieve a user's status."
params do
requires :status_id , type : Integer , desc : 'A status ID.'
end
get ':status_id' do
User . find ( params [ :user_id ] ) . statuses . find ( params [ :status_id ] )
end
end
end El método namespace tiene una serie de alias, que incluyen: group , resource , resources y segment . Use lo que lea mejor para su API.
Puede definir convenientemente un parámetro de ruta como un espacio de nombres usando route_param .
namespace :statuses do
route_param :id do
desc 'Returns all replies for a status.'
get 'replies' do
Status . find ( params [ :id ] ) . replies
end
desc 'Returns a status.'
get do
Status . find ( params [ :id ] )
end
end
end También puede definir un tipo de parámetro de ruta pasando a las opciones de route_param .
namespace :arithmetic do
route_param :n , type : Integer do
desc 'Returns in power'
get 'power' do
params [ :n ] ** params [ :n ]
end
end
end class AlphaNumeric < Grape :: Validations :: Validators :: Base
def validate_param! ( attr_name , params )
unless params [ attr_name ] =~ / A [[:alnum:]]+ z /
raise Grape :: Exceptions :: Validation . new params : [ @scope . full_name ( attr_name ) ] , message : 'must consist of alpha-numeric characters'
end
end
end params do
requires :text , alpha_numeric : true
endTambién puede crear clases personalizadas que tomen parámetros.
class Length < Grape :: Validations :: Validators :: Base
def validate_param! ( attr_name , params )
unless params [ attr_name ] . length <= @option
raise Grape :: Exceptions :: Validation . new params : [ @scope . full_name ( attr_name ) ] , message : "must be at the most #{ @option } characters long"
end
end
end params do
requires :text , length : 140
endTambién puede crear una validación personalizada que use una solicitud para validar el atributo. Por ejemplo, si desea tener parámetros disponibles solo para administradores, puede hacer lo siguiente.
class Admin < Grape :: Validations :: Validators :: Base
def validate ( request )
# return if the param we are checking was not in request
# @attrs is a list containing the attribute we are currently validating
# in our sample case this method once will get called with
# @attrs being [:admin_field] and once with @attrs being [:admin_false_field]
return unless request . params . key? ( @attrs . first )
# check if admin flag is set to true
return unless @option
# check if user is admin or not
# as an example get a token from request and check if it's admin or not
raise Grape :: Exceptions :: Validation . new params : @attrs , message : 'Can not set admin-only field.' unless request . headers [ 'X-Access-Token' ] == 'admin'
end
endY úselo en su definición de punto final como:
params do
optional :admin_field , type : String , admin : true
optional :non_admin_field , type : String
optional :admin_false_field , type : String , admin : false
endCada validación tendrá su propia instancia del validador, lo que significa que el validador puede tener un estado.
Se recopilan errores de validación y coerción y se plantea una excepción de tipo Grape::Exceptions::ValidationErrors . Si la excepción no se ha detenido, responderá con un estado de 400 y un mensaje de error. Los errores de validación se agrupan mediante el nombre del parámetro y se puede acceder a través de Grape::Exceptions::ValidationErrors#errors .
La respuesta predeterminada de una Grape::Exceptions::ValidationErrors es una cadena legalmente legible, como "cerveza, vino son mutuamente excluyentes", en el siguiente ejemplo.
params do
optional :beer
optional :wine
optional :juice
exactly_one_of :beer , :wine , :juice
end Puede rescatar un Grape::Exceptions::ValidationErrors y responder con una respuesta personalizada o convertir la respuesta en JSON bien formateado para una API JSON que separa los parámetros individuales y los mensajes de error correspondientes. El siguiente ejemplo rescue_from produce [{"params":["beer","wine"],"messages":["are mutually exclusive"]}] .
format :json
subject . rescue_from Grape :: Exceptions :: ValidationErrors do | e |
error! e , 400
end Grape::Exceptions::ValidationErrors#full_messages Devuelve los mensajes de validación como una matriz. Grape::Exceptions::ValidationErrors#message une los mensajes a una cadena.
Para responder con una variedad de mensajes de validación, puede usar Grape::Exceptions::ValidationErrors#full_messages .
format :json
subject . rescue_from Grape :: Exceptions :: ValidationErrors do | e |
error! ( { messages : e . full_messages } , 400 )
end Grape devuelve todos los errores de validación y coerción encontrados por defecto. Para omitir todas las verificaciones de validación posteriores cuando se encuentra un parámetro específico no válido, use fail_fast: true .
El siguiente ejemplo no verificará si :wine está presente a menos que encuentre :beer .
params do
required :beer , fail_fast : true
required :wine
end El resultado de los parámetros vacíos sería una sola Grape::Exceptions::ValidationErrors .
Del mismo modo, no se realizará ninguna prueba de expresión regular si :blah está en blanco en el siguiente ejemplo.
params do
required :blah , allow_blank : false , regexp : /blah/ , fail_fast : true
endGrape admite I18N para mensajes de error relacionados con los parámetros, pero retrasará al inglés si no se han proporcionado traducciones para la ubicación predeterminada. Ver en.yml para las teclas de mensaje.
En caso de que su aplicación aplique solo los locales disponibles y: EN no está incluido en sus lugares disponibles, la uva no puede volver al inglés y devolverá la clave de traducción para el mensaje de error. Para evitar este comportamiento, proporcione una traducción para su localidad predeterminada o Agregar: EN a sus locales disponibles.
Grape admite mensajes de validación personalizados para los mensajes de error relacionados con los parámetros y los mensajes de error relacionados con la coercina.
presence , allow_blank , values , regexp params do
requires :name , values : { value : 1 .. 10 , message : 'not in range from 1 to 10' } , allow_blank : { value : false , message : 'cannot be blank' } , regexp : { value : /^[a-z]+$/ , message : 'format is invalid' } , message : 'is required'
end same_as params do
requires :password
requires :password_confirmation , same_as : { value : :password , message : 'not match' }
end length params do
requires :code , type : String , length : { is : 2 , message : 'code is expected to be exactly 2 characters long' }
requires :str , type : String , length : { min : 5 , message : 'str is expected to be atleast 5 characters long' }
requires :list , type : [ Integer ] , length : { min : 2 , max : 3 , message : 'list is expected to have between 2 and 3 elements' }
end all_or_none_of params do
optional :beer
optional :wine
optional :juice
all_or_none_of :beer , :wine , :juice , message : "all params are required or none is required"
end mutually_exclusive params do
optional :beer
optional :wine
optional :juice
mutually_exclusive :beer , :wine , :juice , message : "are mutually exclusive cannot pass both params"
end exactly_one_of params do
optional :beer
optional :wine
optional :juice
exactly_one_of :beer , :wine , :juice , message : { exactly_one : "are missing, exactly one parameter is required" , mutual_exclusion : "are mutually exclusive, exactly one parameter is required" }
end at_least_one_of params do
optional :beer
optional :wine
optional :juice
at_least_one_of :beer , :wine , :juice , message : "are missing, please specify at least one param"
end Coerce params do
requires :int , type : { value : Integer , message : "type cast is invalid" }
end With Lambdas params do
requires :name , values : { value : -> { ( 1 .. 10 ) . to_a } , message : 'not in range from 1 to 10' }
end Pass symbols for i18n translationsPuede aprobar un símbolo si desea traducciones I18N para sus mensajes de validación personalizados.
params do
requires :name , message : :name_required
end # en.yml
en :
grape :
errors :
format : ! '%{attributes} %{message}'
messages :
name_required : 'must be present' También puede anular los nombres de los atributos.
# en.yml
en :
grape :
errors :
format : ! '%{attributes} %{message}'
messages :
name_required : 'must be present'
attributes :
name : 'Oops! Name'¡Producirá 'oops! El nombre debe estar presente '
No puede establecer una opción de mensaje personalizado para el valor predeterminado, ya que requiere interpolación %{option1}: %{value1} is incompatible with %{option2}: %{value2} . Puede cambiar el mensaje de error predeterminado para el valor predeterminado cambiando la tecla de mensaje incompatible_option_values dentro de EN.yml
params do
requires :name , values : { value : -> { ( 1 .. 10 ) . to_a } , message : 'not in range from 1 to 10' } , default : 5
enddry-validation o dry-schema Como alternativa a los params DSL descritos anteriormente, puede usar un esquema o un contrato dry-validation para describir los parámetros de un punto final. Esto puede ser especialmente útil si usa lo anterior ya en otras partes de su aplicación. Si no, deberá agregar dry-validation o dry-schema a su Gemfile .
Luego llame contract con un contrato o esquema definido anteriormente:
CreateOrdersSchema = Dry :: Schema . Params do
required ( :orders ) . array ( :hash ) do
required ( :name ) . filled ( :string )
optional ( :volume ) . maybe ( :integer , lt? : 9 )
end
end
# ...
contract CreateOrdersSchemao con un bloque, utilizando la sintaxis de la definición del esquema:
contract do
required ( :orders ) . array ( :hash ) do
required ( :name ) . filled ( :string )
optional ( :volume ) . maybe ( :integer , lt? : 9 )
end
end Este último definirá un esquema coaccionamiento ( Dry::Schema.Params ). Al usar el enfoque anterior, depende de usted decidir si la entrada necesitará coaccionar.
Los params y las declaraciones contract también se pueden usar juntas en la misma API, por ejemplo, para describir diferentes partes de un espacio de nombres anidado para un punto final.
Los encabezados de solicitud están disponibles a través de los headers ayudantes o desde env en su forma original.
get do
error! ( 'Unauthorized' , 401 ) unless headers [ 'Secret-Password' ] == 'swordfish'
end get do
error! ( 'Unauthorized' , 401 ) unless env [ 'HTTP_SECRET_PASSWORD' ] == 'swordfish'
end El ejemplo anterior puede haberse solicitado de la siguiente manera:
curl -H " secret_PassWord: swordfish " ...El nombre del encabezado habrá sido normalizado para usted.
header los nombres auxiliares se coaccionarán en una caja de kebab en descenso como secret-password si usa rack 3.header los nombres auxiliares se coaccionarán en un caso de kebab capitalizado como Secret-PassWord si usa rack <3.env aparecen en todos los mayores, en caso de serpiente, y prefiñas con 'http_' como HTTP_SECRET_PASSWORDEl nombre del encabezado se habrá normalizado según los estándares HTTP definidos en RFC2616 Sección 4.2, independientemente de lo que envíe un cliente.
Puede establecer un encabezado de respuesta con header dentro de una API.
header 'X-Robots-Tag' , 'noindex' ¡Al aumentar error! , pase encabezados adicionales como argumentos. ¡Los encabezados adicionales se fusionarán con encabezados establecidos antes error! llamar.
error! 'Unauthorized' , 401 , 'X-Error-Detail' => 'Invalid token.' Para definir las rutas, puede usar el método route o las abreviadas para los verbos HTTP. Para definir una ruta que acepte cualquier ruta establecida en :any . Las partes de la ruta que se denotan con un colon se interpretarán como parámetros de ruta.
route :get , 'status' do
end
# is the same as
get 'status' do
end
# is the same as
get :status do
end
# is NOT the same as
get ':status' do # this makes params[:status] available
end
# This will make both params[:status_id] and params[:id] available
get 'statuses/:status_id/reviews/:id' do
end Para declarar un espacio de nombres que prefija todas las rutas dentro, use el método namespace . group , resource , resources y segment son alias de este método. Cualquier punto final dentro compartirá su contexto principal, así como cualquier configuración realizada en el contexto del espacio de nombres.
El método route_param es un método conveniente para definir un segmento de ruta de parámetros. Si define un tipo, agregará una validación para este parámetro.
route_param :id , type : Integer do
get 'status' do
end
end
# is the same as
namespace ':id' do
params do
requires :id , type : Integer
end
get 'status' do
end
endOpcionalmente, puede definir los requisitos para los parámetros de ruta nombrados utilizando expresiones regulares en el espacio de nombres o punto final. La ruta coincidirá solo si se cumplen todos los requisitos.
get ':id' , requirements : { id : /[0-9]*/ } do
Status . find ( params [ :id ] )
end
namespace :outer , requirements : { id : /[0-9]*/ } do
get :id do
end
get ':id/edit' do
end
end Puede definir los métodos auxiliares que sus puntos finales pueden usar con la macro helpers dando un bloque o una variedad de módulos.
module StatusHelpers
def user_info ( user )
" #{ user } has statused #{ user . statuses } status(s)"
end
end
module HttpCodesHelpers
def unauthorized
401
end
end
class API < Grape :: API
# define helpers with a block
helpers do
def current_user
User . find ( params [ :user_id ] )
end
end
# or mix in an array of modules
helpers StatusHelpers , HttpCodesHelpers
before do
error! ( 'Access Denied' , unauthorized ) unless current_user
end
get 'info' do
# helpers available in your endpoint and filters
user_info ( current_user )
end
end Puede definir params reutilizables usando helpers .
class API < Grape :: API
helpers do
params :pagination do
optional :page , type : Integer
optional :per_page , type : Integer
end
end
desc 'Get collection'
params do
use :pagination # aliases: includes, use_scope
end
get do
Collection . page ( params [ :page ] ) . per ( params [ :per_page ] )
end
end También puede definir params reutilizables utilizando ayudantes compartidos.
module SharedParams
extend Grape :: API :: Helpers
params :period do
optional :start_date
optional :end_date
end
params :pagination do
optional :page , type : Integer
optional :per_page , type : Integer
end
end
class API < Grape :: API
helpers SharedParams
desc 'Get collection.'
params do
use :period , :pagination
end
get do
Collection
. from ( params [ :start_date ] )
. to ( params [ :end_date ] )
. page ( params [ :page ] )
. per ( params [ :per_page ] )
end
end Los ayudantes admiten bloques que pueden ayudar a establecer valores predeterminados. La siguiente API puede devolver una colección ordenada por id o created_at en orden asc o desc .
module SharedParams
extend Grape :: API :: Helpers
params :order do | options |
optional :order_by , type : Symbol , values : options [ :order_by ] , default : options [ :default_order_by ]
optional :order , type : Symbol , values : %i( asc desc ) , default : options [ :default_order ]
end
end
class API < Grape :: API
helpers SharedParams
desc 'Get a sorted collection.'
params do
use :order , order_by : %i( id created_at ) , default_order_by : :created_at , default_order : :asc
end
get do
Collection . send ( params [ :order ] , params [ :order_by ] )
end
end Si necesita métodos para generar rutas dentro de sus puntos finales, consulte la gema Grape-Rute-Helpers.
Puede adjuntar documentación adicional a params utilizando un hash documentation .
params do
optional :first_name , type : String , documentation : { example : 'Jim' }
requires :last_name , type : String , documentation : { example : 'Smith' }
endSi no se necesita documentación (por ejemplo, es una API interna), la documentación se puede deshabilitar.
class API < Grape :: API
do_not_document!
# endpoints...
endEn este caso, Grape no creará objetos relacionados con la documentación que se conservan en RAM para siempre.
Puede configurar, obtener y eliminar sus cookies muy simplemente usando el método cookies .
class API < Grape :: API
get 'status_count' do
cookies [ :status_count ] ||= 0
cookies [ :status_count ] += 1
{ status_count : cookies [ :status_count ] }
end
delete 'status_count' do
{ status_count : cookies . delete ( :status_count ) }
end
endUse una sintaxis basada en hash para establecer más de un valor.
cookies [ :status_count ] = {
value : 0 ,
expires : Time . tomorrow ,
domain : '.twitter.com' ,
path : '/'
}
cookies [ :status_count ] [ :value ] += 1 Elimine una galleta con delete .
cookies . delete :status_countEspecificar una ruta opcional.
cookies . delete :status_count , path : '/' Por defecto, Grape devuelve un 201 para POST -Requests, 204 para DELETE las requisitos que no devuelven ningún contenido y 200 código de estado para todas las demás solicitudes. Puede usar status para consultar y establecer el código de estado HTTP real
post do
status 202
if status == 200
# do some thing
end
endTambién puede usar uno de los símbolos de códigos de estado proporcionados por Rack Utils
post do
status :no_content
end You can redirect to a new url temporarily (302) or permanently (301).
redirect '/statuses' redirect '/statuses' , permanent : true You can recognize the endpoint matched with given path.
This API returns an instance of Grape::Endpoint .
class API < Grape :: API
get '/statuses' do
end
end
API . recognize_path '/statuses' Since version 2.1.0 , the recognize_path method takes into account the parameters type to determine which endpoint should match with given path.
class Books < Grape :: API
resource :books do
route_param :id , type : Integer do
# GET /books/:id
get do
#...
end
end
resource :share do
# POST /books/share
post do
# ....
end
end
end
end
API . recognize_path '/books/1' # => /books/:id
API . recognize_path '/books/share' # => /books/share
API . recognize_path '/books/other' # => nil When you add a GET route for a resource, a route for the HEAD method will also be added automatically. You can disable this behavior with do_not_route_head! .
class API < Grape :: API
do_not_route_head!
get '/example' do
# only responds to GET
end
end When you add a route for a resource, a route for the OPTIONS method will also be added. The response to an OPTIONS request will include an "Allow" header listing the supported methods. If the resource has before and after callbacks they will be executed, but no other callbacks will run.
class API < Grape :: API
get '/rt_count' do
{ rt_count : current_user . rt_count }
end
params do
requires :value , type : Integer , desc : 'Value to add to the rt count.'
end
put '/rt_count' do
current_user . rt_count += params [ :value ] . to_i
{ rt_count : current_user . rt_count }
end
end curl -v -X OPTIONS http://localhost:3000/rt_count
> OPTIONS /rt_count HTTP/1.1
>
< HTTP/1.1 204 No Content
< Allow: OPTIONS, GET, PUT You can disable this behavior with do_not_route_options! .
If a request for a resource is made with an unsupported HTTP method, an HTTP 405 (Method Not Allowed) response will be returned. If the resource has before callbacks they will be executed, but no other callbacks will run.
curl -X DELETE -v http://localhost:3000/rt_count/
> DELETE /rt_count/ HTTP/1.1
> Host: localhost:3000
>
< HTTP/1.1 405 Method Not Allowed
< Allow: OPTIONS, GET, PUT You can abort the execution of an API method by raising errors with error! .
error! 'Access Denied' , 401 Anything that responds to #to_s can be given as a first argument to error! .
error! :not_found , 404You can also return JSON formatted objects by raising error! and passing a hash instead of a message.
error! ( { error : 'unexpected error' , detail : 'missing widget' } , 500 ) You can set additional headers for the response. They will be merged with headers set before error! llamar.
error! ( 'Something went wrong' , 500 , 'X-Error-Detail' => 'Invalid token.' )You can present documented errors with a Grape entity using the the grape-entity gem.
module API
class Error < Grape :: Entity
expose :code
expose :message
end
end The following example specifies the entity to use in the http_codes definition.
desc 'My Route' do
failure [ [ 408 , 'Unauthorized' , API :: Error ] ]
end
error! ( { message : 'Unauthorized' } , 408 )The following example specifies the presented entity explicitly in the error message.
desc 'My Route' do
failure [ [ 408 , 'Unauthorized' ] ]
end
error! ( { message : 'Unauthorized' , with : API :: Error } , 408 ) By default Grape returns a 500 status code from error! . You can change this with default_error_status .
class API < Grape :: API
default_error_status 400
get '/example' do
error! 'This should have http status code 400'
end
endFor Grape to handle all the 404s for your API, it can be useful to use a catch-all. In its simplest form, it can be like:
route :any , '*path' do
error! # or something else
endIt is very crucial to define this endpoint at the very end of your API , as it literally accepts every request.
Grape can be told to rescue all StandardError exceptions and return them in the API format.
class Twitter :: API < Grape :: API
rescue_from :all
end This mimics default rescue behaviour when an exception type is not provided. Any other exception should be rescued explicitly, see below.
Grape can also rescue from all exceptions and still use the built-in exception handing. This will give the same behavior as rescue_from :all with the addition that Grape will use the exception handling defined by all Exception classes that inherit Grape::Exceptions::Base .
The intent of this setting is to provide a simple way to cover the most common exceptions and return any unexpected exceptions in the API format.
class Twitter :: API < Grape :: API
rescue_from :grape_exceptions
end If you want to customize the shape of grape exceptions returned to the user, to match your :all handler for example, you can pass a block to rescue_from :grape_exceptions .
rescue_from :grape_exceptions do | e |
error! ( e , e . status )
endYou can also rescue specific exceptions.
class Twitter :: API < Grape :: API
rescue_from ArgumentError , UserDefinedError
end In this case UserDefinedError must be inherited from StandardError .
Notice that you could combine these two approaches (rescuing custom errors takes precedence). For example, it's useful for handling all exceptions except Grape validation errors.
class Twitter :: API < Grape :: API
rescue_from Grape :: Exceptions :: ValidationErrors do | e |
error! ( e , 400 )
end
rescue_from :all
endThe error format will match the request format. See "Content-Types" below.
Custom error formatters for existing and additional types can be defined with a proc.
class Twitter :: API < Grape :: API
error_formatter :txt , -> ( message , backtrace , options , env , original_exception ) {
"error: #{ message } from #{ backtrace } "
}
endYou can also use a module or class.
module CustomFormatter
def self . call ( message , backtrace , options , env , original_exception )
{ message : message , backtrace : backtrace }
end
end
class Twitter :: API < Grape :: API
error_formatter :custom , CustomFormatter
end You can rescue all exceptions with a code block. The error! wrapper automatically sets the default error code and content-type.
class Twitter :: API < Grape :: API
rescue_from :all do | e |
error! ( "rescued from #{ e . class . name } " )
end
endOptionally, you can set the format, status code and headers.
class Twitter :: API < Grape :: API
format :json
rescue_from :all do | e |
error! ( { error : 'Server error.' } , 500 , { 'Content-Type' => 'text/error' } )
end
endYou can also rescue all exceptions with a code block and handle the Rack response at the lowest level.
class Twitter :: API < Grape :: API
rescue_from :all do | e |
Rack :: Response . new ( [ e . message ] , 500 , { 'Content-type' => 'text/error' } )
end
endOr rescue specific exceptions.
class Twitter :: API < Grape :: API
rescue_from ArgumentError do | e |
error! ( "ArgumentError: #{ e . message } " )
end
rescue_from NoMethodError do | e |
error! ( "NoMethodError: #{ e . message } " )
end
end By default, rescue_from will rescue the exceptions listed and all their subclasses.
Assume you have the following exception classes defined.
module APIErrors
class ParentError < StandardError ; end
class ChildError < ParentError ; end
end Then the following rescue_from clause will rescue exceptions of type APIErrors::ParentError and its subclasses (in this case APIErrors::ChildError ).
rescue_from APIErrors :: ParentError do | e |
error! ( {
error : " #{ e . class } error" ,
message : e . message
} , e . status )
end To only rescue the base exception class, set rescue_subclasses: false . The code below will rescue exceptions of type RuntimeError but not its subclasses.
rescue_from RuntimeError , rescue_subclasses : false do | e |
error! ( {
status : e . status ,
message : e . message ,
errors : e . errors
} , e . status )
end Helpers are also available inside rescue_from .
class Twitter :: API < Grape :: API
format :json
helpers do
def server_error!
error! ( { error : 'Server error.' } , 500 , { 'Content-Type' => 'text/error' } )
end
end
rescue_from :all do | e |
server_error!
end
end The rescue_from handler must return a Rack::Response object, call error! , or raise an exception (either the original exception or another custom one). The exception raised in rescue_from will be handled outside Grape. For example, if you mount Grape in Rails, the exception will be handle by Rails Action Controller.
Alternately, use the with option in rescue_from to specify a method or a proc .
class Twitter :: API < Grape :: API
format :json
helpers do
def server_error!
error! ( { error : 'Server error.' } , 500 , { 'Content-Type' => 'text/error' } )
end
end
rescue_from :all , with : :server_error!
rescue_from ArgumentError , with : -> { Rack :: Response . new ( 'rescued with a method' , 400 ) }
end Inside the rescue_from block, the environment of the original controller method( .self receiver) is accessible through the #context method.
class Twitter :: API < Grape :: API
rescue_from :all do | e |
user_id = context . params [ :user_id ]
error! ( "error for #{ user_id } " )
end
end You could put rescue_from clauses inside a namespace and they will take precedence over ones defined in the root scope:
class Twitter :: API < Grape :: API
rescue_from ArgumentError do | e |
error! ( "outer" )
end
namespace :statuses do
rescue_from ArgumentError do | e |
error! ( "inner" )
end
get do
raise ArgumentError . new
end
end
end Here 'inner' will be result of handling occurred ArgumentError .
Grape::Exceptions::InvalidVersionHeader , which is raised when the version in the request header doesn't match the currently evaluated version for the endpoint, will never be rescued from a rescue_from block (even a rescue_from :all ) This is because Grape relies on Rack to catch that error and try the next versioned-route for cases where there exist identical Grape endpoints with different versions.
Any exception that is not subclass of StandardError should be rescued explicitly. Usually it is not a case for an application logic as such errors point to problems in Ruby runtime. This is following standard recommendations for exceptions handling.
Grape::API provides a logger method which by default will return an instance of the Logger class from Ruby's standard library.
To log messages from within an endpoint, you need to define a helper to make the logger available in the endpoint context.
class API < Grape :: API
helpers do
def logger
API . logger
end
end
post '/statuses' do
logger . info " #{ current_user } has statused"
end
endTo change the logger level.
class API < Grape :: API
self . logger . level = Logger :: INFO
endYou can also set your own logger.
class MyLogger
def warning ( message )
puts "this is a warning: #{ message } "
end
end
class API < Grape :: API
logger MyLogger . new
helpers do
def logger
API . logger
end
end
get '/statuses' do
logger . warning " #{ current_user } has statused"
end
endFor similar to Rails request logging try the grape_logging or grape-middleware-logger gems.
Your API can declare which content-types to support by using content_type . If you do not specify any, Grape will support XML , JSON , BINARY , and TXT content-types. The default format is :txt ; you can change this with default_format . Essentially, the two APIs below are equivalent.
class Twitter :: API < Grape :: API
# no content_type declarations, so Grape uses the defaults
end
class Twitter :: API < Grape :: API
# the following declarations are equivalent to the defaults
content_type :xml , 'application/xml'
content_type :json , 'application/json'
content_type :binary , 'application/octet-stream'
content_type :txt , 'text/plain'
default_format :txt
end If you declare any content_type whatsoever, the Grape defaults will be overridden. For example, the following API will only support the :xml and :rss content-types, but not :txt , :json , or :binary . Importantly, this means the :txt default format is not supported! So, make sure to set a new default_format .
class Twitter :: API < Grape :: API
content_type :xml , 'application/xml'
content_type :rss , 'application/xml+rss'
default_format :xml
end Serialization takes place automatically. For example, you do not have to call to_json in each JSON API endpoint implementation. The response format (and thus the automatic serialization) is determined in the following order:
format parameter in the query string, if specified.format option, if specified.Accept header.default_format option.:txt .For example, consider the following API.
class MultipleFormatAPI < Grape :: API
content_type :xml , 'application/xml'
content_type :json , 'application/json'
default_format :json
get :hello do
{ hello : 'world' }
end
endGET /hello (with an Accept: */* header) does not have an extension or a format parameter, so it will respond with JSON (the default format).GET /hello.xml has a recognized extension, so it will respond with XML.GET /hello?format=xml has a recognized format parameter, so it will respond with XML.GET /hello.xml?format=json has a recognized extension (which takes precedence over the format parameter), so it will respond with XML.GET /hello.xls (with an Accept: */* header) has an extension, but that extension is not recognized, so it will respond with JSON (the default format).GET /hello.xls with an Accept: application/xml header has an unrecognized extension, but the Accept header corresponds to a recognized format, so it will respond with XML.GET /hello.xls with an Accept: text/plain header has an unrecognized extension and an unrecognized Accept header, so it will respond with JSON (the default format). You can override this process explicitly by calling api_format in the API itself. For example, the following API will let you upload arbitrary files and return their contents as an attachment with the correct MIME type.
class Twitter :: API < Grape :: API
post 'attachment' do
filename = params [ :file ] [ :filename ]
content_type MIME :: Types . type_for ( filename ) [ 0 ] . to_s
api_format :binary # there's no formatter for :binary, data will be returned "as is"
header 'Content-Disposition' , "attachment; filename*=UTF-8'' #{ CGI . escape ( filename ) } "
params [ :file ] [ :tempfile ] . read
end
end You can have your API only respond to a single format with format . If you use this, the API will not respond to file extensions other than specified in format . For example, consider the following API.
class SingleFormatAPI < Grape :: API
format :json
get :hello do
{ hello : 'world' }
end
endGET /hello will respond with JSON.GET /hello.json will respond with JSON.GET /hello.xml , GET /hello.foobar , or any other extension will respond with an HTTP 404 error code.GET /hello?format=xml will respond with an HTTP 406 error code, because the XML format specified by the request parameter is not supported.GET /hello with an Accept: application/xml header will still respond with JSON, since it could not negotiate a recognized content-type from the headers and JSON is the effective default. The formats apply to parsing, too. The following API will only respond to the JSON content-type and will not parse any other input than application/json , application/x-www-form-urlencoded , multipart/form-data , multipart/related and multipart/mixed . All other requests will fail with an HTTP 406 error code.
class Twitter :: API < Grape :: API
format :json
end When the content-type is omitted, Grape will return a 406 error code unless default_format is specified. The following API will try to parse any data without a content-type using a JSON parser.
class Twitter :: API < Grape :: API
format :json
default_format :json
end If you combine format with rescue_from :all , errors will be rendered using the same format. If you do not want this behavior, set the default error formatter with default_error_formatter .
class Twitter :: API < Grape :: API
format :json
content_type :txt , 'text/plain'
default_error_formatter :txt
endCustom formatters for existing and additional types can be defined with a proc.
class Twitter :: API < Grape :: API
content_type :xls , 'application/vnd.ms-excel'
formatter :xls , -> ( object , env ) { object . to_xls }
endYou can also use a module or class.
module XlsFormatter
def self . call ( object , env )
object . to_xls
end
end
class Twitter :: API < Grape :: API
content_type :xls , 'application/vnd.ms-excel'
formatter :xls , XlsFormatter
endBuilt-in formatters are the following.
:json : use object's to_json when available, otherwise call MultiJson.dump:xml : use object's to_xml when available, usually via MultiXml:txt : use object's to_txt when available, otherwise to_s:serializable_hash : use object's serializable_hash when available, otherwise fallback to :json:binary : data will be returned "as is"If a body is present in a request to an API, with a Content-Type header value that is of an unsupported type a "415 Unsupported Media Type" error code will be returned by Grape.
Response statuses that indicate no content as defined by Rack here will bypass serialization and the body entity - though there should be none - will not be modified.
Grape supports JSONP via Rack::JSONP, part of the rack-contrib gem. Add rack-contrib to your Gemfile .
require 'rack/contrib'
class API < Grape :: API
use Rack :: JSONP
format :json
get '/' do
'Hello World'
end
end Grape supports CORS via Rack::CORS, part of the rack-cors gem. Add rack-cors to your Gemfile , then use the middleware in your config.ru file.
require 'rack/cors'
use Rack :: Cors do
allow do
origins '*'
resource '*' , headers : :any , methods : :get
end
end
run Twitter :: API Content-type is set by the formatter. You can override the content-type of the response at runtime by setting the Content-Type header.
class API < Grape :: API
get '/home_timeline_js' do
content_type 'application/javascript'
"var statuses = ...;"
end
end Grape accepts and parses input data sent with the POST and PUT methods as described in the Parameters section above. It also supports custom data formats. You must declare additional content-types via content_type and optionally supply a parser via parser unless a parser is already available within Grape to enable a custom format. Such a parser can be a function or a class.
With a parser, parsed data is available "as-is" in env['api.request.body'] . Without a parser, data is available "as-is" and in env['api.request.input'] .
The following example is a trivial parser that will assign any input with the "text/custom" content-type to :value . The parameter will be available via params[:value] inside the API call.
module CustomParser
def self . call ( object , env )
{ value : object . to_s }
end
end content_type :txt , 'text/plain'
content_type :custom , 'text/custom'
parser :custom , CustomParser
put 'value' do
params [ :value ]
endYou can invoke the above API as follows.
curl -X PUT -d 'data' 'http://localhost:9292/value' -H Content-Type:text/custom -v
You can disable parsing for a content-type with nil . For example, parser :json, nil will disable JSON parsing altogether. The request data is then available as-is in env['api.request.body'] .
Grape uses JSON and ActiveSupport::XmlMini for JSON and XML parsing by default. It also detects and supports multi_json and multi_xml. Adding those gems to your Gemfile and requiring them will enable them and allow you to swap the JSON and XML back-ends.
Grape supports a range of ways to present your data with some help from a generic present method, which accepts two arguments: the object to be presented and the options associated with it. The options hash may include :with , which defines the entity to expose.
Add the grape-entity gem to your Gemfile. Please refer to the grape-entity documentation for more details.
The following example exposes statuses.
module API
module Entities
class Status < Grape :: Entity
expose :user_name
expose :text , documentation : { type : 'string' , desc : 'Status update text.' }
expose :ip , if : { type : :full }
expose :user_type , :user_id , if : -> ( status , options ) { status . user . public? }
expose :digest do | status , options |
Digest :: MD5 . hexdigest ( status . txt )
end
expose :replies , using : API :: Status , as : :replies
end
end
class Statuses < Grape :: API
version 'v1'
desc 'Statuses index' do
params : API :: Entities :: Status . documentation
end
get '/statuses' do
statuses = Status . all
type = current_user . admin? ? :full : :default
present statuses , with : API :: Entities :: Status , type : type
end
end
end You can use entity documentation directly in the params block with using: Entity.documentation .
module API
class Statuses < Grape :: API
version 'v1'
desc 'Create a status'
params do
requires :all , except : [ :ip ] , using : API :: Entities :: Status . documentation . except ( :id )
end
post '/status' do
Status . create! params
end
end
endYou can present with multiple entities using an optional Symbol argument.
get '/statuses' do
statuses = Status . all . page ( 1 ) . per ( 20 )
present :total_page , 10
present :per_page , 20
present :statuses , statuses , with : API :: Entities :: Status
endThe response will be
{
total_page: 10,
per_page: 20,
statuses: []
}
In addition to separately organizing entities, it may be useful to put them as namespaced classes underneath the model they represent.
class Status
def entity
Entity . new ( self )
end
class Entity < Grape :: Entity
expose :text , :user_id
end
end If you organize your entities this way, Grape will automatically detect the Entity class and use it to present your models. In this example, if you added present Status.new to your endpoint, Grape will automatically detect that there is a Status::Entity class and use that as the representative entity. This can still be overridden by using the :with option or an explicit represents call.
You can present hash with Grape::Presenters::Presenter to keep things consistent.
get '/users' do
present { id : 10 , name : :dgz } , with : Grape :: Presenters :: Presenter
endThe response will be
{
id : 10 ,
name : 'dgz'
}It has the same result with
get '/users' do
present :id , 10
present :name , :dgz
end You can use Roar to render HAL or Collection+JSON with the help of grape-roar, which defines a custom JSON formatter and enables presenting entities with Grape's present keyword.
You can use Rabl templates with the help of the grape-rabl gem, which defines a custom Grape Rabl formatter.
You can use Active Model Serializers serializers with the help of the grape-active_model_serializers gem, which defines a custom Grape AMS formatter.
In general, use the binary format to send raw data.
class API < Grape :: API
get '/file' do
content_type 'application/octet-stream'
File . binread 'file.bin'
end
end You can set the response body explicitly with body .
class API < Grape :: API
get '/' do
content_type 'text/plain'
body 'Hello World'
# return value ignored
end
end Use body false to return 204 No Content without any data or content-type.
If you want to empty the body with an HTTP status code other than 204 No Content , you can override the status code after specifying body false as follows
class API < Grape :: API
get '/' do
body false
status 304
end
end You can also set the response to a file with sendfile . This works with the Rack::Sendfile middleware to optimally send the file through your web server software.
class API < Grape :: API
get '/' do
sendfile '/path/to/file'
end
end To stream a file in chunks use stream
class API < Grape :: API
get '/' do
stream '/path/to/file'
end
end If you want to stream non-file data use the stream method and a Stream object. This is an object that responds to each and yields for each chunk to send to the client. Each chunk will be sent as it is yielded instead of waiting for all of the content to be available.
class MyStream
def each
yield 'part 1'
yield 'part 2'
yield 'part 3'
end
end
class API < Grape :: API
get '/' do
stream MyStream . new
end
end Grape has built-in Basic authentication (the given block is executed in the context of the current Endpoint ). Authentication applies to the current namespace and any children, but not parents.
http_basic do | username , password |
# verify user's password here
# IMPORTANT: make sure you use a comparison method which isn't prone to a timing attack
end Grape can use custom Middleware for authentication. How to implement these Middleware have a look at Rack::Auth::Basic or similar implementations.
For registering a Middleware you need the following options:
label - the name for your authenticator to use it laterMiddlewareClass - the MiddlewareClass to use for authenticationoption_lookup_proc - A Proc with one Argument to lookup the options at runtime (return value is an Array as Parameter for the Middleware).Ejemplo:
Grape :: Middleware :: Auth :: Strategies . add ( :my_auth , AuthMiddleware , -> ( options ) { [ options [ :realm ] ] } )
auth :my_auth , { realm : 'Test Api' } do | credentials |
# lookup the user's password here
{ 'user1' => 'password1' } [ username ]
endUse Doorkeeper, warden-oauth2 or rack-oauth2 for OAuth2 support.
You can access the controller params, headers, and helpers through the context with the #context method inside any auth middleware inherited from Grape::Middleware::Auth::Base .
Grape routes can be reflected at runtime. This can notably be useful for generating documentation.
Grape exposes arrays of API versions and compiled routes. Each route contains a prefix , version , namespace , method and params . You can add custom route settings to the route metadata with route_setting .
class TwitterAPI < Grape :: API
version 'v1'
desc 'Includes custom settings.'
route_setting :custom , key : 'value'
get do
end
endExamine the routes at runtime.
TwitterAPI :: versions # yields [ 'v1', 'v2' ]
TwitterAPI :: routes # yields an array of Grape::Route objects
TwitterAPI :: routes [ 0 ] . version # => 'v1'
TwitterAPI :: routes [ 0 ] . description # => 'Includes custom settings.'
TwitterAPI :: routes [ 0 ] . settings [ :custom ] # => { key: 'value' } Note that Route#route_xyz methods have been deprecated since 0.15.0 and removed since 2.0.1.
Please use Route#xyz instead.
Note that difference of Route#options and Route#settings .
The options can be referred from your route, it should be set by specifing key and value on verb methods such as get , post and put . The settings can also be referred from your route, but it should be set by specifing key and value on route_setting .
It's possible to retrieve the information about the current route from within an API call with route .
class MyAPI < Grape :: API
desc 'Returns a description of a parameter.'
params do
requires :id , type : Integer , desc : 'Identity.'
end
get 'params/:id' do
route . params [ params [ :id ] ] # yields the parameter description
end
end The current endpoint responding to the request is self within the API block or env['api.endpoint'] elsewhere. The endpoint has some interesting properties, such as source which gives you access to the original code block of the API implementation. This can be particularly useful for building a logger middleware.
class ApiLogger < Grape :: Middleware :: Base
def before
file = env [ 'api.endpoint' ] . source . source_location [ 0 ]
line = env [ 'api.endpoint' ] . source . source_location [ 1 ]
logger . debug "[api] #{ file } : #{ line } "
end
end Blocks can be executed before or after every API call, using before , after , before_validation and after_validation . If the API fails the after call will not be triggered, if you need code to execute for sure use the finally .
Before and after callbacks execute in the following order:
beforebefore_validationafter_validation (upon successful validation)after (upon successful validation and API call)finally (always)Steps 4, 5 and 6 only happen if validation succeeds.
If a request for a resource is made with an unsupported HTTP method (returning HTTP 405) only before callbacks will be executed. The remaining callbacks will be bypassed.
If a request for a resource is made that triggers the built-in OPTIONS handler, only before and after callbacks will be executed. The remaining callbacks will be bypassed.
For example, using a simple before block to set a header.
before do
header 'X-Robots-Tag' , 'noindex'
end You can ensure a block of code runs after every request (including failures) with finally :
finally do
# this code will run after every request (successful or failed)
endEspacios de nombres
Callbacks apply to each API call within and below the current namespace:
class MyAPI < Grape :: API
get '/' do
"root - #{ @blah } "
end
namespace :foo do
before do
@blah = 'blah'
end
get '/' do
"root - foo - #{ @blah } "
end
namespace :bar do
get '/' do
"root - foo - bar - #{ @blah } "
end
end
end
endThe behavior is then:
GET / # 'root - '
GET /foo # 'root - foo - blah'
GET /foo/bar # 'root - foo - bar - blah' Params on a namespace (or whichever alias you are using) will also be available when using before_validation or after_validation :
class MyAPI < Grape :: API
params do
requires :blah , type : Integer
end
resource ':blah' do
after_validation do
# if we reach this point validations will have passed
@blah = declared ( params , include_missing : false ) [ :blah ]
end
get '/' do
@blah . class
end
end
endThe behavior is then:
GET /123 # 'Integer'
GET /foo # 400 error - 'blah is invalid'Versioning
When a callback is defined within a version block, it's only called for the routes defined in that block.
class Test < Grape :: API
resource :foo do
version 'v1' , :using => :path do
before do
@output ||= 'v1-'
end
get '/' do
@output += 'hello'
end
end
version 'v2' , :using => :path do
before do
@output ||= 'v2-'
end
get '/' do
@output += 'hello'
end
end
end
endThe behavior is then:
GET /foo/v1 # 'v1-hello'
GET /foo/v2 # 'v2-hello'Altering Responses
Using present in any callback allows you to add data to a response:
class MyAPI < Grape :: API
format :json
after_validation do
present :name , params [ :name ] if params [ :name ]
end
get '/greeting' do
present :greeting , 'Hello!'
end
endThe behavior is then:
GET /greeting # {"greeting":"Hello!"}
GET /greeting ? name=Alan # {"name":"Alan","greeting":"Hello!"} Instead of altering a response, you can also terminate and rewrite it from any callback using error! , including after . This will cause all subsequent steps in the process to not be called. This includes the actual api call and any callbacks
Grape by default anchors all request paths, which means that the request URL should match from start to end to match, otherwise a 404 Not Found is returned. However, this is sometimes not what you want, because it is not always known upfront what can be expected from the call. This is because Rack-mount by default anchors requests to match from the start to the end, or not at all. Rails solves this problem by using a anchor: false option in your routes. In Grape this option can be used as well when a method is defined.
For instance when your API needs to get part of an URL, for instance:
class TwitterAPI < Grape :: API
namespace :statuses do
get '/(*:status)' , anchor : false do
end
end
end This will match all paths starting with '/statuses/'. There is one caveat though: the params[:status] parameter only holds the first part of the request url. Luckily this can be circumvented by using the described above syntax for path specification and using the PATH_INFO Rack environment variable, using env['PATH_INFO'] . This will hold everything that comes after the '/statuses/' part.
You can use instance variables to pass information across the various stages of a request. An instance variable set within a before validator is accessible within the endpoint's code and can also be utilized within the rescue_from handler.
class TwitterAPI < Grape :: API
before do
@var = 1
end
get '/' do
puts @var # => 1
raise
end
rescue_from :all do
puts @var # => 1
end
endThe values of instance variables cannot be shared among various endpoints within the same API. This limitation arises due to Grape generating a new instance for each request made. Consequently, instance variables set within an endpoint during one request differ from those set during a subsequent request, as they exist within separate instances.
class TwitterAPI < Grape :: API
get '/first' do
@var = 1
puts @var # => 1
end
get '/second' do
puts @var # => nil
end
end You can make a custom middleware by using Grape::Middleware::Base . It's inherited from some grape official middlewares in fact.
For example, you can write a middleware to log application exception.
class LoggingError < Grape :: Middleware :: Base
def after
return unless @app_response && @app_response [ 0 ] == 500
env [ 'rack.logger' ] . error ( "Raised error on #{ env [ 'PATH_INFO' ] } " )
end
endYour middleware can overwrite application response as follows, except error case.
class Overwriter < Grape :: Middleware :: Base
def after
[ 200 , { 'Content-Type' => 'text/plain' } , [ 'Overwritten.' ] ]
end
end You can add your custom middleware with use , that push the middleware onto the stack, and you can also control where the middleware is inserted using insert , insert_before and insert_after .
class CustomOverwriter < Grape :: Middleware :: Base
def after
[ 200 , { 'Content-Type' => 'text/plain' } , [ @options [ :message ] ] ]
end
end
class API < Grape :: API
use Overwriter
insert_before Overwriter , CustomOverwriter , message : 'Overwritten again.'
insert 0 , CustomOverwriter , message : 'Overwrites all other middleware.'
get '/' do
end
end You can access the controller params, headers, and helpers through the context with the #context method inside any middleware inherited from Grape::Middleware::Base .
Note that when you're using Grape mounted on Rails you don't have to use Rails middleware because it's already included into your middleware stack. You only have to implement the helpers to access the specific env variable.
If you are using a custom application that is inherited from Rails::Application and need to insert a new middleware among the ones initiated via Rails, you will need to register it manually in your custom application class.
class Company :: Application < Rails :: Application
config . middleware . insert_before ( Rack :: Attack , Middleware :: ApiLogger )
end By default you can access remote IP with request.ip . This is the remote IP address implemented by Rack. Sometimes it is desirable to get the remote IP Rails-style with ActionDispatch::RemoteIp .
Add gem 'actionpack' to your Gemfile and require 'action_dispatch/middleware/remote_ip.rb' . Use the middleware in your API and expose a client_ip helper. See this documentation for additional options.
class API < Grape :: API
use ActionDispatch :: RemoteIp
helpers do
def client_ip
env [ 'action_dispatch.remote_ip' ] . to_s
end
end
get :remote_ip do
{ ip : client_ip }
end
end Use rack-test and define your API as app .
You can test a Grape API with RSpec by making HTTP requests and examining the response.
describe Twitter :: API do
include Rack :: Test :: Methods
def app
Twitter :: API
end
context 'GET /api/statuses/public_timeline' do
it 'returns an empty array of statuses' do
get '/api/statuses/public_timeline'
expect ( last_response . status ) . to eq ( 200 )
expect ( JSON . parse ( last_response . body ) ) . to eq [ ]
end
end
context 'GET /api/statuses/:id' do
it 'returns a status by id' do
status = Status . create!
get "/api/statuses/ #{ status . id } "
expect ( last_response . body ) . to eq status . to_json
end
end
endThere's no standard way of sending arrays of objects via an HTTP GET, so POST JSON data and specify the correct content-type.
describe Twitter :: API do
context 'POST /api/statuses' do
it 'creates many statuses' do
statuses = [ { text : '...' } , { text : '...' } ]
post '/api/statuses' , statuses . to_json , 'CONTENT_TYPE' => 'application/json'
expect ( last_response . body ) . to eq 201
end
end
end You can test with other RSpec-based frameworks, including Airborne, which uses rack-test to make requests.
require 'airborne'
Airborne . configure do | config |
config . rack_app = Twitter :: API
end
describe Twitter :: API do
context 'GET /api/statuses/:id' do
it 'returns a status by id' do
status = Status . create!
get "/api/statuses/ #{ status . id } "
expect_json ( status . as_json )
end
end
end require 'test_helper'
class Twitter :: APITest < MiniTest :: Test
include Rack :: Test :: Methods
def app
Twitter :: API
end
def test_get_api_statuses_public_timeline_returns_an_empty_array_of_statuses
get '/api/statuses/public_timeline'
assert last_response . ok?
assert_equal [ ] , JSON . parse ( last_response . body )
end
def test_get_api_statuses_id_returns_a_status_by_id
status = Status . create!
get "/api/statuses/ #{ status . id } "
assert_equal status . to_json , last_response . body
end
end describe Twitter :: API do
context 'GET /api/statuses/public_timeline' do
it 'returns an empty array of statuses' do
get '/api/statuses/public_timeline'
expect ( response . status ) . to eq ( 200 )
expect ( JSON . parse ( response . body ) ) . to eq [ ]
end
end
context 'GET /api/statuses/:id' do
it 'returns a status by id' do
status = Status . create!
get "/api/statuses/ #{ status . id } "
expect ( response . body ) . to eq status . to_json
end
end
end In Rails, HTTP request tests would go into the spec/requests group. You may want your API code to go into app/api - you can match that layout under spec by adding the following in spec/rails_helper.rb .
RSpec . configure do | config |
config . include RSpec :: Rails :: RequestExampleGroup , type : :request , file_path : /spec / api/
end class Twitter :: APITest < ActiveSupport :: TestCase
include Rack :: Test :: Methods
def app
Rails . application
end
test 'GET /api/statuses/public_timeline returns an empty array of statuses' do
get '/api/statuses/public_timeline'
assert last_response . ok?
assert_equal [ ] , JSON . parse ( last_response . body )
end
test 'GET /api/statuses/:id returns a status by id' do
status = Status . create!
get "/api/statuses/ #{ status . id } "
assert_equal status . to_json , last_response . body
end
end Because helpers are mixed in based on the context when an endpoint is defined, it can be difficult to stub or mock them for testing. The Grape::Endpoint.before_each method can help by allowing you to define behavior on the endpoint that will run before every request.
describe 'an endpoint that needs helpers stubbed' do
before do
Grape :: Endpoint . before_each do | endpoint |
allow ( endpoint ) . to receive ( :helper_name ) . and_return ( 'desired_value' )
end
end
after do
Grape :: Endpoint . before_each nil
end
it 'stubs the helper' do
end
end Use grape-reload.
Add API paths to config/application.rb .
# Auto-load API and its subdirectories
config . paths . add File . join ( 'app' , 'api' ) , glob : File . join ( '**' , '*.rb' )
config . autoload_paths += Dir [ Rails . root . join ( 'app' , 'api' , '*' ) ] Create config/initializers/reload_api.rb .
if Rails . env . development?
ActiveSupport :: Dependencies . explicitly_unloadable_constants << 'Twitter::API'
api_files = Dir [ Rails . root . join ( 'app' , 'api' , '**' , '*.rb' ) ]
api_reloader = ActiveSupport :: FileUpdateChecker . new ( api_files ) do
Rails . application . reload_routes!
end
ActionDispatch :: Callbacks . to_prepare do
api_reloader . execute_if_updated
end
endFor Rails >= 5.1.4, change this:
ActionDispatch :: Callbacks . to_prepare do
api_reloader . execute_if_updated
endto this:
ActiveSupport :: Reloader . to_prepare do
api_reloader . execute_if_updated
endSee StackOverflow #3282655 for more information.
Grape has built-in support for ActiveSupport::Notifications which provides simple hook points to instrument key parts of your application.
The following are currently supported:
The main execution of an endpoint, includes filters and rendering.
The execution of the main content block of the endpoint.
The execution of validators.
Serialization or template rendering.
Grape::Formatter::Json )See the ActiveSupport::Notifications documentation for information on how to subscribe to these events.
Grape integrates with following third-party tools:
Grape is work of hundreds of contributors. You're encouraged to submit pull requests, propose features and discuss issues.
See CONTRIBUTING.
See SECURITY for details.
MIT License. See LICENSE for details.
Copyright (c) 2010-2020 Michael Bleigh, Intridea Inc. and Contributors.
