grape
1.0.0
Grapeは、RubyのRESTのようなAPIフレームワークです。ラックで実行したり、RailsやSinatraなどの既存のWebアプリケーションフレームワークを補完したりするように設計されています。複数の形式、サブドメイン/プレフィックス制限、コンテンツネゴシエーション、バージョン化など、共通規則のサポートが組み込まれています。
グレープの次のリリースのドキュメントを読んでいます。これは2.3.0です。現在の安定したリリースは2.2.0です。
Tideliftサブスクリプションの一部として利用可能。
GrapeのメンテナーはTideliftと協力して、商業的なサポートとメンテナンスを提供しています。グレープのメンテナーを支払いながら、時間を節約し、リスクを減らし、コードの健康を改善します。詳細については、ここをクリックしてください。
Ruby 2.7以降が必要です。
Grapeは宝石として利用可能です。
bundle add grape
グレープAPIはGrape::APIサブクラス化することによって作成されたラックアプリケーションです。以下は、Twitter APIの一部を再現するというコンテキストでのGrapeのより一般的な機能のいくつかを示す簡単な例です。
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のDep Recatorは、アプリケーションの設定を適用できるように、 :grapeとしてアプリケーションのDepRecatorに自動的に追加されます。
デフォルトでは、Grapeは最初のルートでルートをコンパイルします。 compile!方法。
Twitter :: API . compile!これは、 config.ru （ラックアップを使用している場合）、 application.rb （レールを使用している場合）、またはサーバーをロードするファイルに追加できます。
上記のサンプルでは、ラックrackup config.ruファイルから実行できるラックアプリケーションを作成します。
run Twitter :: API（プリロードを使用すると、使用できます）
Twitter :: API . compile!
run Twitter :: API次のルートに応答します。
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
また、Grapeは、すべてのGETのヘッドとオプションに自動的に応答し、他のすべてのルートのオプションだけに対応します。
シナトラなどの別のラックフレームワークと一緒にグレープをマウントしたい場合は、 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 ] Rack::Cascadeの問題を使用してアプリをロードする順序に注意してください。 Grapeからカスタム404エラーを上げたい場合（ error!('Not Found',404) ）、Grapeアプリケーションは最後でなければなりません。 Grapeアプリケーションが最後ではなく、404または405の応答を返す場合、Cascadeはそれを信号として使用して次のアプリを試してみます。これにより、間違ったアプリの404ページが間違っていることを示す望ましくない動作につながる可能性があります。
APIファイルをapp/apiに配置します。 Railsは、Rubyモジュールの名前と一致するサブディレクトリと、クラスの名前と一致するファイル名を期待しています。この例では、 Twitter::APIのファイル名の場所とディレクトリはapp/api/twitter/api.rbである必要があります。
config/routesの変更：
mount Twitter :: API => '/' RailsのデフォルトのオートローダーはZeitwerkです。デフォルトでは、 APIの代わりにapiをApiとして活用します。例を機能させるには、 config/initializers/inflections.rbの下部にある線を除外し、次の頭字語としてAPIを追加する必要があります。
ActiveSupport :: Inflector . inflections ( :en ) do | inflect |
inflect . acronym 'API'
end複数のAPI実装を別のAPI実装にマウントできます。これらは異なるバージョンである必要はありませんが、同じAPIのコンポーネントである可能性があります。
class Twitter :: API < Grape :: API
mount Twitter :: APIv1
mount Twitter :: APIv2
endまた、マウントされたAPI自体の内側にprefixを使用することに似たパスにマウントすることもできます。
class Twitter :: API < Grape :: API
mount Twitter :: APIv1 => '/v1'
end宣言はbefore/after/rescue_from 、 mountの前後に配置できます。いずれにせよ、それらは継承されます。
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 同じエンドポイントを2つの異なる場所にマウントできます。
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投稿とコメントのエンドポイントが/postsおよび/commentsに取り付けられていると仮定すると、 get /posts/votes 、 post /posts/votes 、 get /comments/votes and post /comments/votes行うことができるはずです。
再マウント可能なエンドポイントを構成して、それらがマウントされている場所に応じて動作する方法を変更できます。
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ハッシュを最初にmountパラメーターとして渡す場合は、パラメーターの周りに明示的に()を（）に配置する必要があることに注意してください。
# good
mount ( { :: Some :: Api => '/some/api' } , with : { condition : true } )
# bad
mount :: Some :: Api => '/some/api' , with : { condition : true }クラスのconfigurationにアクセスできます（動的属性として使用する）、内部ブロック（名前空間など）
configurationで指定されたロジックが発生したい場合は、 givenヘルパーを使用できます。
class ConditionalEndpoint :: API < Grape :: API
given configuration [ :some_setting ] do
get 'mount_this_endpoint_conditionally' do
configuration [ :configurable_response ]
end
end
endエンドポイントがマウントされるたびにロジックのブロックを実行する必要がある場合（ 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 configurationハッシュとして既に評価されている式としてマウントmountedた式としてマウントされたことにより、より複雑な結果を実現できます。
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 提供される各バージョンに個別のGrape::APIクラスを確立し、それらをプライマリGrape::APIクラスに統合することにより、APIのさまざまなバージョンを提供するオプションがあります。古いバージョンの前に新しいバージョンが取り付けられていることを確認してください。バージョン化へのデフォルトのアプローチは、特定のバージョンが見つからない場合、リクエストを後続のラックミドルウェアに向けます。
require 'v1'
require 'v2'
require 'v3'
class App < Grape :: API
mount V3
mount V2
mount V1
end以前のAPIバージョンを書き換えずに同じエンドポイントを維持するには、以前のAPIバージョン内の複数のバージョンを示すことができます。
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
end提供されている例を使用して、次のエンドポイントにさまざまなバージョンでアクセスできます。
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クライアント:header APIのエンドポイント:accept_version_header到達できる4つの戦略:paramあります:pathデフォルトの戦略は次のとおりです:path 。
version 'v1' , using : :pathこのバージョン化戦略を使用して、クライアントはURLで目的のバージョンを渡す必要があります。
curl http://localhost:9292/v1/statuses/public_timeline
version 'v1' , using : :header , vendor : 'twitter'現在、Grapeは次の形式でバージョンされたメディアタイプのみをサポートしています。
vnd.vendor-and-or-resource-v1234+format
基本的に-と+の間のすべてのトークンはバージョンとして解釈されます。
このバージョン化戦略を使用して、クライアントはHTTP Accept Headで目的のバージョンを渡す必要があります。
curl -H Accept:application/vnd.twitter-v1+json http://localhost:9292/statuses/public_timeline
デフォルトでは、 Acceptヘッダーが提供されない場合に最初のマッチングバージョンが使用されます。この動作は、レールのルーティングに似ています。このデフォルトの動作を回避するには、 :strictオプションを使用できます。このオプションがtrueに設定されている場合、正しいAcceptヘッダーが提供されない場合406 Not Acceptableエラーが返されます。
無効なAcceptヘッダーが提供されると、 :cascadeオプションがfalseに設定されている場合、 406 Not Acceptableエラーが返されます。それ以外の場合は、他のルートが一致しない場合、ラックによって404 Not Foundエラーが返されます。
Grapeは、受け入れヘッダーに含まれる相対的な品質の好みを評価し、省略された場合、デフォルトで1.0の品質になります。次の例では、その順序でXMLとJSONをサポートするグレープAPIがJSONを返します。
curl -H "Accept: text/xml;q=0.8, application/json;q=0.9" localhost:1234/resource
version 'v1' , using : :accept_version_headerこのバージョン化戦略を使用して、クライアントはHTTP Accept-Versionヘッダーで目的のバージョンを渡す必要があります。
curl -H "Accept-Version:v1" http://localhost:9292/statuses/public_timeline
デフォルトでは、 Accept-Versionヘッダーが提供されていない場合に最初のマッチングバージョンが使用されます。この動作は、レールのルーティングに似ています。このデフォルトの動作を回避するには、 :strictオプションを使用できます。このオプションがtrueに設定されている場合、正しいAcceptヘッダーが提供されない場合、 406 Not Acceptableエラーが返され、 :cascadeオプションがfalseに設定されます。それ以外の場合は、他のルートが一致しない場合、ラックによって404 Not Foundエラーが返されます。
version 'v1' , using : :paramこのバージョン化戦略を使用して、クライアントは、URLクエリ文字列またはリクエスト本文のいずれかで、目的のバージョンを要求パラメーターとして渡す必要があります。
curl http://localhost:9292/statuses/public_timeline?apiver=v1
クエリパラメーターのデフォルト名は「Apiver」ですが、次のように指定できます:parameterオプション。
version 'v1' , using : :param , parameter : 'v' curl http://localhost:9292/statuses/public_timeline?v=v1
APIメソッドと名前空間に説明を追加できます。説明は、Swaggerに準拠したドキュメントを生成するために、Grape-Swaggerによって使用されます。
注：説明ブロックはドキュメント専用であり、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 ：より強化された説明params ： Entityからパラメーターを直接定義しますsuccess ：（以前のエンティティ）このルートの成功応答を提示するために使用されるEntity 。failure ：（以前のhttp_codes）使用されている障害HTTPコードとエンティティの定義。default ：このルートのデフォルトの応答を提示するために使用される定義とEntity 。named ：ルートに名前を付けて、ドキュメントでこの名前でそれを見つけるヘルパーハッシュheaders ：使用済みヘッダーの定義Grape.configureを使用して、読み込み時にグローバル設定をセットアップします。現在、構成可能な設定は次のとおりです。
param_builder ：パラメータービルダーを設定します。デフォルトはGrape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder設定します。設定値を変更するには、荷重時間中のある時点で次のコードが実行されることを確認してください
Grape . configure do | config |
config . setting = value
endたとえば、 param_builderの場合、次のコードは初期化器で実行できます。
Grape . configure do | config |
config . param_builder = Grape :: Extensions :: Hashie :: Mash :: ParamBuilder
end単一のAPIを構成することもできます。
API . configure do | config |
config [ key ] = value
endこれは、マウント構成であるかのように、 configurationとともにAPI内で使用できます。
リクエストパラメーターは、 paramsハッシュオブジェクトを介して使用できます。これには、ルート文字列で指定する名前のパラメーターとともに、 GET 、 POST 、 PUTパラメーターが含まれます。
get :public_timeline do
Status . order ( params [ :sort_by ] )
endパラメーターは、 POSTのリクエスト本体から自動的に入力され、フォーム入力、JSONおよびXMLコンテンツタイプ用にPUTます。
リクエスト：
curl -d '{"text": "140 characters"}' 'http://localhost:9292/statuses' -H Content-Type:application/json -v
ブドウのエンドポイント：
post '/statuses' do
Status . create! ( text : params [ :text ] )
endマルチパートの投稿とプットもサポートされています。
リクエスト：
curl --form image_file='@image.jpg;type=image/jpg' http://localhost:9292/upload
ブドウのエンドポイント：
post 'upload' do
# file in params[:image_file]
endどちらかの間の対立の場合：
GET 、 POST 、およびPUTPOSTとPUTのリクエスト本文の内容ルート文字列パラメーターには優先されます。
デフォルトでは、パラメーターはActiveSupport::HashWithIndifferentAccessとして使用できます。これは、たとえば、API全体のRuby HashまたはHashie::Mashに変更できます。
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クラスは、次のようにbuild_withを使用して、個々のパラメーターブロックでオーバーライドすることもできます。
params do
build_with Grape :: Extensions :: Hash :: ParamBuilder
optional :color , type : String
endまたはConfiguration Grape.configure.param_builderを使用してグローバルに。
上記の例では、 params単純なHashであるため、 params["color"] nilを返します。
利用可能なパラメータービルダーはGrape::Extensions::Hash::ParamBuilder 、 Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder and Grape::Extensions::Hashie::Mash::ParamBuilder 。
Grapeを使用すると、 paramsブロックによって宣言されたパラメーターのみにアクセスできます。それは：
次のAPIエンドポイントを検討してください。
format :json
post 'users/signup' do
{ 'declared_params' => declared ( params ) }
endパラメーターを指定していない場合、 declared空のハッシュを返します。
リクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "last_name": "last name"}} '応答
{
"declared_params" : {}
}
パラメーター要件を追加すると、Grapeは宣言されたパラメーターのみのみの返却を開始します。
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 ) }
endリクエスト
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"}} '応答
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : " last name "
}
}
}タイプHashまたは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 ) }
endリクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {} '応答
{
"declared_params" : {
"user" : {
"first_name" : null ,
"last_name" : null
},
"widgets" : []
}
}返されたハッシュは、 ActiveSupport::HashWithIndifferentAccessです。
#declaredメソッドは、パラメーター強制の前に評価されるため、フィルターbeforeに使用できません。
デフォルトではdeclared(params)には、すべての親ネームスペースで定義されたパラメーターが含まれています。現在の名前空間からパラメーターのみを返したい場合は、 include_parent_namespacesオプションを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
endリクエスト
curl -X GET -H " Content-Type: application/json " localhost:9292/parent/foo/bar応答
{
"without_parent_namespaces" : {
"child_name" : " bar "
},
"with_parent_namespaces" : {
"parent_name" : " foo " ,
"child_name" : " bar "
},
}デフォルトでは、 declared(params) nil値を持つパラメーターを含みます。 nilではないパラメーターのみを返す場合は、 include_missingオプションを使用できます。デフォルトでは、 include_missing trueに設定されています。次の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 ) }
endリクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "random": "never shown"}} 'include_missing：falseによる応答
{
"declared_params" : {
"user" : {
"first_name" : " first name "
}
}
}include_missingを使用した応答：true
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : null
}
}
}また、ネストされたハッシュでも機能します。
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 ) }
endリクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "random": "never shown", "address": { "city": "SF"}}} 'include_missing：falseによる応答
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"address" : {
"city" : " SF "
}
}
}
}include_missingを使用した応答：true
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : null ,
"address" : {
"city" : " Zurich " ,
"region" : null
}
}
}
} nil値の属性は欠落しているとは見なされず、 include_missingがfalseに設定されている場合にも返されることに注意してください。
リクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/users/signup -d ' {"user": {"first_name":"first name", "last_name": null, "address": { "city": "SF"}}} 'include_missing：falseによる応答
{
"declared_params" : {
"user" : {
"first_name" : " first name " ,
"last_name" : null ,
"address" : { "city" : " SF " }
}
}
}デフォルトでは、 declared(params) 、 givenパラメーターを評価し、返すことはありません。 evaluate_given使用して、 givenすべてのブロックを評価し、 given条件を満たすパラメーターのみを返します。次の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 ) }
endリクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/child -d ' {"father_id": 1} 'evaluate_givenによる応答：false
{
"declared_params" : {
"child_id" : null ,
"father_id" : 1
}
}evaluate_givenによる応答：true
{
"declared_params" : {
"child_id" : null
}
}また、ネストされたハッシュでも機能します。
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 ) }
endリクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/child -d ' {"child": {"father_id": 1}} 'evaluate_givenによる応答：false
{
"declared_params" : {
"child" : {
"child_id" : null ,
"father_id" : 1
}
}
}evaluate_givenによる応答：true
{
"declared_params" : {
"child" : {
"child_id" : null
}
}
}route_param使用すると、同じ名前で定義された通常のパラメーターよりも優先されます。
params do
requires :foo , type : String
end
route_param :foo do
get do
{ value : params [ :foo ] }
end
endリクエスト
curl -X POST -H " Content-Type: application/json " localhost:9292/bar -d ' {"foo": "baz"} '応答
{
"value" : " bar "
}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
endタイプが指定されている場合、強制後に暗黙の検証が行われ、出力タイプが宣言されたものであることを確認します。
オプションのパラメーターはデフォルト値を持つことができます。
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デフォルト値は熱心に評価されます。上:non_random_numberこのparamsブロックのエンドポイントへのコールごとに同じ数値に評価されます。リクエストごとにデフォルトを怠lazilyに評価するには、上記の:random_numberのようなLambdaを使用します。
デフォルト値は、指定された任意の検証オプションに渡されることに注意してください。次の例は、次の場合に常に失敗します:colorが明示的に提供されていない。
params do
optional :color , type : String , default : 'blue' , values : [ 'red' , 'green' ]
end正しい実装は、デフォルト値がすべての検証に合格するようにすることです。
params do
optional :color , type : String , default : 'blue' , values : [ 'blue' , 'red' , 'green' ]
end 1つのパラメーターの値を、他のパラメーターのデフォルト値として使用できます。この場合、 primary_colorパラメーターが提供されていない場合、 colorパラメーターと同じ値があります。両方が提供されていない場合、両方ともblue値を持ちます。
params do
optional :color , type : String , default : 'blue'
optional :primary_color , type : String , default : -> ( params ) { params [ :color ] }
end以下はすべて有効なタイプで、Grapeによって箱から出してサポートされています。
File ）動作はRuby 2.4と以前のバージョン間で異なることに注意してください。 Ruby 2.4では、数値で構成される値は整数に変換されますが、以前のバージョンでは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上記のサポートされているタイプのデフォルトセットは別として、明示的な強制方法が提供される限り、任意のクラスはタイプとして使用できます。このタイプがクラスレベルのparse法を実装する場合、Grapeはそれを自動的に使用します。この方法では、1つの文字列引数を取り、正しいタイプのインスタンスを返すか、 Grape::Types::InvalidValueのインスタンスを返してください。
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あるいは、 coerce_withを使用して、あらゆるタイプのパラメーターにカスタム強制法を提供することもできます。その優先順位で、任意のクラスまたはオブジェクトにparse方法またはcall方法を実装することができます。メソッドは単一の文字列パラメーターを受け入れる必要があり、戻り値は指定されたtypeと一致する必要があります。
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 nil値はカスタム強制メソッドを呼び出し、欠落しているパラメーターはそうではないことに注意してください。
Lambdaでcoerce_withを使用した例（ parse方法を持つクラスも使用できた可能性があります）文字列を解析し、 Array[Integer] typeに一致させる整数の配列を返します。
params do
requires :values , type : Array [ Integer ] , coerce_with : -> ( val ) { val . split ( / s +/ ) . map ( & :to_i ) }
endグレープは、強制値が与えられたtypeと一致すると主張し、そうでない場合はリクエストを拒否します。この動作をオーバーライドするために、カスタムタイプはparsed?単一の引数を受け入れ、値がタイプの検証に合格した場合にtrueを返す必要がある方法。
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
endGrapeはRack::Requestのマルチパートファイルパラメーターの組み込みサポートを使用しています。このようなパラメーターは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タイプGrapeは、特別なtype: JSON JSON形式の文字列として与えられた複雑なパラメーターをサポートします。 JSONオブジェクトとオブジェクトの配列は、どちらの場合でもすべてのオブジェクトにネストされた検証ルールが適用され、等しく受け入れられます。
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さらにtype: Array[JSON]が使用される場合があります。これは、パラメーターをオブジェクトの配列として明示的にマークします。単一のオブジェクトが提供されると、ラップされます。
params do
requires :json , type : Array [ JSON ] do
requires :int , type : Integer
end
end
get '/' do
params [ :json ] . each { | obj | ... } # always works
end供給される可能性のあるJSON構造のタイプをより厳密に制御するには、 type: Array, coerce_with: JSONまたはtype: Hash, coerce_with: JSONを使用します。
Variantタイプのパラメーターは、 typeではなくtypesオプションを使用して宣言できます。
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"]特別なケースとして、バリアントメンバータイプのコレクションは、複数のメンバーを使用してSetまたはArray 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"]パラメーターは、 groupを使用して、または呼び出しをrequiresして、またはブロックを使用してoptionalてネストできます。上記の例では、これはparams[:media][:url] params[:id]とともに必要であることを意味し、 params[:audio][:format]がparams[:audio]が存在する場合にのみ必要です。ブロック、 group 、 requiresとoptionalの場合、 ArrayまたはHashいずれかであり、デフォルトをArrayにする可能性のある追加のオプションtypeを受け入れます。値に応じて、ネストされたパラメーターは、ハッシュの値として、または配列内のハッシュの値として扱われます。
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別のパラメーターが指定されている場合にのみ、パラメーターの一部が関連するとします。 Grapeを使用すると、パラメーターブロックのgiven方法を通してこの関係を表現できます。
params do
optional :shelf_id , type : Integer
given :shelf_id do
requires :bin_id , type : Integer
end
end上の例では、ブドウはblank? shelf_id paramが存在するかどうかを確認します。
givenカスタムコードを使用してProcも必要です。以下では、 categoryの値がfoo場合にのみ、パラマリのdescriptionが必要です。
params do
optional :category
given category : -> ( val ) { val == 'foo' } do
requires :description
end
endパラメーターの名前を変更できます。
params do
optional :category , as : :type
given type : -> ( val ) { val == 'foo' } do
requires :description
end
end注： givenパラマは、名前が変更されている必要があります。この例では、 categoryではなくtypeある必要があります。
パラメーターオプションをグループ化できます。いくつかのパラメーターに対して一般的な検証またはタイプを抽出する場合に役立ちます。これらのグループ内では、個々のパラメーターが共通の設定を拡張または選択的にオーバーライドすることができ、必要に応じてパラメーター固有のルールを適用しながら、グループレベルでデフォルトを維持できます。
以下の例は、パラメーターが共通オプションを共有する場合の典型的なケースを示しています。
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 Grapeを使用すると、パラメーターブロックのwithを使用して同じロジックを表示できます。
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
endネストされた「with」ブロックを使用して、設定をレイヤーに整理できます。各レイヤーは、その上のレイヤーの設定を使用、追加、または変更できます。これにより、複雑なパラメーターを整理して一貫性を保ち、特定のカスタマイズを行うことができます。
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
endasを使用してパラメーターを変更できます。これは、既存のAPIをリファクタリングするときに役立つことがあります。
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 declared(params)と呼び出すときに、 asに渡された値が鍵となります。
allow_blankパラメーターは、 allow_blankとして定義でき、値が含まれていることを確認できます。デフォルトでは、その値に関係なく、リクエストでパラメーターが送信されたことのみを検証するrequires 。 allow_blank: false 、空の値、またはwhitespaceのみの値のみが無効です。
allow_blank 、 requiresとoptional両方と組み合わせることができます。パラメーターが必要な場合は、値を含める必要があります。オプションの場合は、リクエストに送信しないことが可能ですが、送信されている場合は、空の文字列/唯一のホワイトスペースではなく、ある程度の価値が必要です。
params do
requires :username , allow_blank : false
optional :first_name , allow_blank : false
end valuesパラメーターは: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 :valuesの範囲を次のように供給することにより、パラメーターがその範囲に含まれる（またはパラメーターが含まれている）ことを保証します（ 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'
end注意エンドレス範囲はActiveSupport> = 6.0でサポートされていますが、タイプを提供する必要があります。
params do
requires :minimum , type : Integer , values : 10 ..
optional :maximum , type : Integer , values : .. 10
end両方の範囲のエンドポイントは#kind_of? :typeオプション（ :typeように提供しない場合、範囲の最初のエンドポイントのクラスに等しいと推測されます）。したがって、以下は無効です。
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 :valuesオプションは、各リクエストで怠zileに評価され、 Procで提供することもできます。 Procにアリティゼロがある場合（つまり、引数はかかりません）、リストまたは範囲を返すことが期待され、パラメーターの検証に使用されます。
たとえば、ステータスモデルが与えられた場合、 HashTagモデルで以前に定義したハッシュタグで制限することができます。
params do
requires :hashtag , type : String , values : -> { Hashtag . all . map ( & :tag ) }
endあるいは、Arity OneのProc（つまり、1つの引数を取得する）を使用して、各パラメーター値を明示的に検証することができます。その場合、パラメーター値が有効な場合、PROCは真実値を返すと予想されます。 Procがfalsy値を返す場合、またはStandardErrorを上げる場合、パラメーターは無効と見なされます。
params do
requires :number , type : Integer , values : -> ( v ) { v . even? && v < 25 }
endProcは単一のケースに便利ですが、検証が複数回使用される場合にカスタムバリエーターを使用することを検討してください。
Allow_blank Validatorは:values場合に適用されることに注意してください。次の例では:allow_blankが防止しない:state空白の値を受信することを防止しないため:allow_blankデフォルトでtrueになります。
params do
requires :state , type : Symbol , values : [ :active , :inactive ]
end except_valuesパラメーターは:except_valuesを使用して特定の値のセットを持つことから制限できます。
except_values validatorは、配列、範囲、またはprocを受け入れるという点で、 values Valibatorと同様に動作します。ただし、 values Validatorとは異なり、 except_values Arity ZeroのProcsのみを受け入れます。
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 same_asオプションを指定して、パラメーターの値が一致するようにすることができます。
params do
requires :password
requires :password_confirmation , same_as : :password
end length #lengthメソッドをサポートする型を持つパラメーターは、 :lengthを使用して特定の長さを持つように制限できます。
VALIDATORは:minまたは:maxまたは両方のオプションまたは唯一の唯一のものを受け入れます:is
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パラメーターは、特定の正規表現を:regexpのように一致させるように制限できます。値が正規表現と一致しない場合、エラーが返されます。これは、 requiresパラメーターとoptional両方のパラメーターに当てはまることに注意してください。
params do
requires :email , regexp : /.+@.+/
endパラメーターが値なしで送信された場合、バリデーターは渡されます。パラメーターに値が含まれていることを確認するには、 allow_blank: falseを使用します。
params do
requires :email , allow_blank : false , regexp : /.+@.+/
end mutually_exclusiveパラメーターは、 mutually_exclusiveであると定義でき、リクエストで同時に存在しないことを保証します。
params do
optional :beer
optional :wine
mutually_exclusive :beer , :wine
end複数のセットを定義できます。
params do
optional :beer
optional :wine
mutually_exclusive :beer , :wine
optional :scotch
optional :aquavit
mutually_exclusive :scotch , :aquavit
end警告：必要なパラメーションで相互に排他的なセットを定義しないでください。相互に排他的な2つのパラメーションは、パラマが有効ではないことを意味し、エンドポイントを役に立たないことを意味します。オプションのPARAMを使用して、相互に排他的に必要なパラメーターが必要な場合は、後者が有効ではないことを意味します。
exactly_one_ofパラメーターは「正確な_one_of」として定義でき、正確に1つのパラメーターが選択されるようにします。
params do
optional :beer
optional :wine
exactly_one_of :beer , :wine
end次のことに注意してください:default mutually_exclusiveでは、複数のパラメーターが常にデフォルト値を持ち、 Grape::Exceptions::Validation相互排他的な例外を引き上げます。
at_least_one_ofパラメーターは「at_least_one_of」として定義でき、少なくとも1つのパラメーターが選択されるようにします。
params do
optional :beer
optional :wine
optional :juice
at_least_one_of :beer , :wine , :juice
end all_or_none_ofパラメーターは「all_or_none_of」として定義でき、パラメーターがすべて選択されないようにします。
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_ofこれらの方法はすべて、任意のネストレベルで使用できます。
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
end名前空間はパラメーター定義を許可し、名前空間内のすべてのメソッドに適用します。
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 namespace法には、 group 、 resource 、 resources 、 segmentなど、さまざまなエイリアスがあります。 APIに最適なものを使用してください。
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 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
endパラメーターを使用するカスタムクラスを作成することもできます。
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
endリクエストを使用して属性を検証するカスタム検証を作成することもできます。たとえば、管理者のみが利用できるパラメーターが必要な場合は、以下を実行できます。
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
endエンドポイント定義で使用します。
params do
optional :admin_field , type : String , admin : true
optional :non_admin_field , type : String
optional :admin_false_field , type : String , admin : false
endすべての検証には、バリデーターの独自のインスタンスがあります。つまり、検証装置は状態を持つことができます。
検証エラーと強制エラーが収集され、型Grape::Exceptions::ValidationErrorsが提起されます。例外が無駄にならない場合、400のステータスとエラーメッセージで応答します。検証エラーはパラメーター名でグループ化され、 Grape::Exceptions::ValidationErrors#errorsを介してアクセスできます。
Grape::Exceptions::ValidationErrors 、「ビール、ワインは相互に排他的です」などの人間的に読みやすい文字列です。
params do
optional :beer
optional :wine
optional :juice
exactly_one_of :beer , :wine , :juice
end Grape::Exceptions::ValidationErrorsを救出し、カスタム応答で応答するか、個々のパラメーターと対応するエラーメッセージを分離するJSON APIの適切なフォーマットJSONに応答します。次のrescue_fromの例では[{"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検証メッセージを配列として返します。 Grape::Exceptions::ValidationErrors#messageメッセージを1つの文字列に結合します。
一連の検証メッセージを使用して応答するには、 Grape::Exceptions::ValidationErrors#full_messagesを使用できます。
format :json
subject . rescue_from Grape :: Exceptions :: ValidationErrors do | e |
error! ( { messages : e . full_messages } , 400 )
end Grapeは、デフォルトで見つかったすべての検証と強制エラーを返します。特定のPARAが無効であることがわかった場合、その後のすべての検証チェックをスキップするには、 fail_fast: trueを使用します。
次の例では:wineが存在するかどうかを確認しません:beer 。
params do
required :beer , fail_fast : true
required :wine
end空のパラメーションの結果は、単一のGrape::Exceptions::ValidationErrorsエラーです。
同様に、次の例では、 :blah正規表現テストは実行されません。
params do
required :blah , allow_blank : false , regexp : /blah/ , fail_fast : true
endGrapeは、パラメーター関連のエラーメッセージについてI18Nをサポートしますが、デフォルトのロケールの翻訳が提供されていない場合、英語にフォールバックします。メッセージキーについては、en.ymlを参照してください。
アプリが利用可能なロケールのみを施行し、以下が利用可能なロケールに含まれていない場合、Grapeは英語に戻ることができず、エラーメッセージの翻訳キーを返します。この動作を回避するには、デフォルトのロケールの翻訳を提供するか、使用可能なロケールに追加します。
Grapeは、パラメーター関連および大規模なエラーメッセージのカスタム検証メッセージをサポートしています。
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 translationsカスタム検証メッセージにi18n翻訳が必要な場合は、シンボルを渡すことができます。
params do
requires :name , message : :name_required
end # en.yml
en :
grape :
errors :
format : ! '%{attributes} %{message}'
messages :
name_required : 'must be present' 属性名をオーバーライドすることもできます。
# en.yml
en :
grape :
errors :
format : ! '%{attributes} %{message}'
messages :
name_required : 'must be present'
attributes :
name : 'Oops! Name'「おっと」を生成します！名前は存在する必要があります」
補間%{option1}: %{value1} is incompatible with %{option2}: %{value2}必要があるため、デフォルトにカスタムメッセージオプションを設定することはできません。 incompatible_option_valuesメッセージキーを変更することにより、デフォルトのデフォルトのエラーメッセージを変更できますen.yml
params do
requires :name , values : { value : -> { ( 1 .. 10 ) . to_a } , message : 'not in range from 1 to 10' } , default : 5
enddry-validationまたはdry-schemaを使用します上記のparams DSLの代替として、スキーマまたはdry-validation契約を使用して、エンドポイントのパラメーターを説明できます。これは、アプリケーションの他の部分ですでに上記を使用する場合に特に役立ちます。そうでない場合は、 Gemfileにdry-validationまたはdry-schemaを追加する必要があります。
次に、以前に定義された契約またはスキーマでcontractを呼び出します。
CreateOrdersSchema = Dry :: Schema . Params do
required ( :orders ) . array ( :hash ) do
required ( :name ) . filled ( :string )
optional ( :volume ) . maybe ( :integer , lt? : 9 )
end
end
# ...
contract CreateOrdersSchemaまたはブロックを使用して、スキーマ定義構文を使用してください。
contract do
required ( :orders ) . array ( :hash ) do
required ( :name ) . filled ( :string )
optional ( :volume ) . maybe ( :integer , lt? : 9 )
end
end後者は、強制スキーマ（ Dry::Schema.Params ）を定義します。前者のアプローチを使用する場合、入力が強制が必要かどうかを判断するのはあなた次第です。
エンドポイントのネストされた名前空間のさまざまな部分を記述するために、 paramsとcontract宣言は同じAPIで一緒に使用することもできます。
リクエストヘッダーは、 headersヘルパーから、または元の形式のenvから利用できます。
get do
error! ( 'Unauthorized' , 401 ) unless headers [ 'Secret-Password' ] == 'swordfish'
end get do
error! ( 'Unauthorized' , 401 ) unless env [ 'HTTP_SECRET_PASSWORD' ] == 'swordfish'
end 上記の例は、次のように要求されている可能性があります。
curl -H " secret_PassWord: swordfish " ...ヘッダー名はあなたのために正規化されています。
headerでは、ヘルパー名は、ラック3を使用する場合、 secret-passwordとしてダウンケースのケバブケースに強制されます。headerでは、ラック<3を使用する場合、ヘルパー名は大文字のケバブケースにSecret-PassWordとして強制されます。envコレクションでは、すべての大文字、ヘビの場合に登場し、 HTTP_SECRET_PASSWORDとして「http_」が付いていますヘッダー名は、クライアントから送信されているものに関係なく、RFC2616セクション4.2で定義されているHTTP標準ごとに正規化されます。
API内にheaderを使用して応答ヘッダーを設定できます。
header 'X-Robots-Tag' , 'noindex' error! 、追加のヘッダーを引数として渡します。追加のヘッダーは、 error!電話。
error! 'Unauthorized' , 401 , 'X-Error-Detail' => 'Invalid token.' ルートを定義するには、HTTP動詞にrouteメソッドまたは速記を使用できます。任意のルートセットを受け入れるルートを定義するには:any 。コロンで示されるパスの一部は、ルートパラメーターとして解釈されます。
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内部のすべてのルートを接頭する名前空間を宣言するには、 namespaceメソッドを使用します。 group 、 resource 、 resources 、 segment 、この方法のエイリアスです。内部のエンドポイントは、親コンテキストと、名前空間コンテキストで行われた構成を共有します。
route_paramメソッドは、パラメータールートセグメントを定義するための便利な方法です。タイプを定義すると、このパラメーターの検証が追加されます。
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
endオプションで、名前空間またはエンドポイントの正規表現を使用して、指定されたルートパラメーターの要件を定義できます。ルートは、すべての要件が満たされている場合にのみ一致します。
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 ブロックまたは一連のモジュールを提供することにより、エンドポイントがhelpersマクロで使用できるヘルパーメソッドを定義できます。
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 helpersを使用して再利用可能なparamsを定義できます。
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共有ヘルパーを使用して、再利用可能なparamsを定義することもできます。
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ヘルパーは、デフォルト値の設定に役立つブロックをサポートします。次のAPIは、 ascまたはdescオーダーでidまたはcreated_atでソートされたコレクションを返すことができます。
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 エンドポイント内にパスを生成する方法が必要な場合は、Grape-route-helpers Gemをご覧ください。
documentationハッシュを使用して、追加のドキュメントをparamsに添付できます。
params do
optional :first_name , type : String , documentation : { example : 'Jim' }
requires :last_name , type : String , documentation : { example : 'Smith' }
endドキュメントが必要ない場合（たとえば、内部APIです）、ドキュメントは無効になる可能性があります。
class API < Grape :: API
do_not_document!
# endpoints...
endこの場合、GrapeはRAMに永遠に保持されているドキュメントに関連するオブジェクトを作成しません。
cookiesメソッドを使用して、Cookieを非常に簡単に設定、取得、削除できます。
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
endハッシュベースの構文を使用して、複数の値を設定します。
cookies [ :status_count ] = {
value : 0 ,
expires : Time . tomorrow ,
domain : '.twitter.com' ,
path : '/'
}
cookies [ :status_count ] [ :value ] += 1 deleteでクッキーを削除します。
cookies . delete :status_countオプションのパスを指定します。
cookies . delete :status_count , path : '/' デフォルトでは、Grapeは、 POST -Requestsの201、 DELETEの場合は204を返し、コンテンツを返さないリクエスト、他のすべてのリクエストに対して200のステータスコードを返します。 statusを使用して、実際のHTTPステータスコードをクエリして設定できます
post do
status 202
if status == 200
# do some thing
end
endYou can also use one of status codes symbols that are provided by 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!電話。
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).例：
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)
end名前空間
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.
