grape 0.15.0 → 0.16.1

data/lib/grape/router/route.rb

@@ -0,0 +1,105 @@
+require 'grape/router/pattern'
+require 'grape/router/attribute_translator'
+require 'forwardable'
+require 'pathname'
+
+module Grape
+  class Router
+    class Route
+      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/.freeze
+      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
+      TRANSLATION_ATTRIBUTES = [
+        :prefix,
+        :version,
+        :namespace,
+        :settings,
+        :format,
+        :description,
+        :http_codes,
+        :headers,
+        :entity,
+        :details,
+        :requirements,
+        :request_method
+      ].freeze
+
+      attr_accessor :pattern, :translator, :app, :index, :regexp
+
+      alias_method :attributes, :translator
+
+      extend Forwardable
+      def_delegators :pattern, :path, :origin
+
+      def self.translate(*attributes)
+        AttributeTranslator.register(*attributes)
+        def_delegators :@translator, *attributes
+      end
+
+      translate(*TRANSLATION_ATTRIBUTES)
+
+      def method_missing(method_id, *arguments)
+        match = ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
+        if match
+          method_name = match.captures.last.to_sym
+          warn_route_methods(method_name, caller(1).shift)
+          @options[method_name]
+        else
+          super
+        end
+      end
+
+      def route_method
+        warn_route_methods(:method, caller(1).shift, :request_method)
+        request_method
+      end
+
+      def route_path
+        warn_route_methods(:path, caller(1).shift)
+        pattern.path
+      end
+
+      def initialize(method, pattern, options = {})
+        @suffix     = options[:suffix]
+        @options    = options.merge(method: method.to_s.upcase)
+        @pattern    = Pattern.new(pattern, options)
+        @translator = AttributeTranslator.new(options.merge(request_method: method.to_s.upcase))
+      end
+
+      def exec(env)
+        @app.call(env)
+      end
+
+      def apply(app)
+        @app = app
+        self
+      end
+
+      def match?(input)
+        translator.respond_to?(:forward_match) && translator.forward_match ? input.start_with?(pattern.origin) : pattern.match?(input)
+      end
+
+      def params(input = nil)
+        if input.nil?
+          default = pattern.named_captures.keys.each_with_object({}) do |key, defaults|
+            defaults[key] = ''
+          end
+          default.delete_if { |key, _| key == 'format' }.merge(translator.params)
+        else
+          parsed = pattern.params(input)
+          parsed ? parsed.delete_if { |_, value| value.nil? }.symbolize_keys : {}
+        end
+      end
+
+      private
+
+      def warn_route_methods(name, location, expected = nil)
+        path, line = *location.scan(SOURCE_LOCATION_REGEXP).first
+        path = File.realpath(path) if Pathname.new(path).relative?
+        expected ||= name
+        warn <<-EOS
+#{path}:#{line}: The route_xxx methods such as route_#{name} have been deprecated, please use #{expected}.
+        EOS
+      end
+    end
+  end
+end

data/lib/grape/serve_file/file_body.rb

@@ -0,0 +1,34 @@
+module Grape
+  module ServeFile
+    CHUNK_SIZE = 16_384
+
+    # Class helps send file through API
+    class FileBody
+      attr_reader :path
+
+      # @param path [String]
+      def initialize(path)
+        @path = path
+      end
+
+      # Need for Rack::Sendfile middleware
+      #
+      # @return [String]
+      def to_path
+        path
+      end
+
+      def each
+        File.open(path, 'rb') do |file|
+          while (chunk = file.read(CHUNK_SIZE))
+            yield chunk
+          end
+        end
+      end
+
+      def ==(other)
+        path == other.path
+      end
+    end
+  end
+end

data/lib/grape/{util → serve_file}/file_response.rb

@@ -1,5 +1,5 @@
 module Grape
-  module Util
+  module ServeFile
     # A simple class used to identify responses which represent files and do not
     # need to be formatted or pre-read by Rack::Response
     class FileResponse

data/lib/grape/{util → serve_file}/sendfile_response.rb

@@ -1,5 +1,5 @@
 module Grape
-  module Util
+  module ServeFile
     # Response should respond to to_path method
     # for using Rack::SendFile middleware
     class SendfileResponse < Rack::Response

data/lib/grape/util/env.rb

@@ -13,10 +13,10 @@ module Grape
     RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'.freeze
     RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'.freeze
     RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'.freeze
-    RACK_ROUTING_ARGS = 'rack.routing_args'.freeze
 
     GRAPE_REQUEST = 'grape.request'.freeze
     GRAPE_REQUEST_HEADERS = 'grape.request.headers'.freeze
     GRAPE_REQUEST_PARAMS = 'grape.request.params'.freeze
+    GRAPE_ROUTING_ARGS = 'grape.routing_args'.freeze
   end
 end

data/lib/grape/util/registrable.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Util
+    module Registrable
+      def default_elements
+        @default_elements ||= {}
+      end
+
+      def register(format, element)
+        default_elements[format] = element unless default_elements[format]
+      end
+    end
+  end
+end

data/lib/grape/validations/types/custom_type_coercer.rb

@@ -136,6 +136,8 @@ module Grape
             # Note that this will fail unless a method is also
             # passed, or if the type also implements a parse() method.
             type
+          elsif type.is_a?(Enumerable)
+            ->(value) { value.all? { |item| item.is_a? type[0] } }
           else
             # By default, do a simple type check
             ->(value) { value.is_a? type }

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '0.15.0'
+  VERSION = '0.16.1'
 end

data/spec/grape/api/invalid_format_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  before do
+    subject.namespace do
+      format :json
+      content_type :json, 'application/json'
+      params do
+        requires :id, desc: 'Identifier.'
+      end
+      get ':id' do
+        {
+          id: params[:id],
+          format: params[:format]
+        }
+      end
+    end
+  end
+
+  context 'get' do
+    it 'no format' do
+      get '/foo'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: nil))
+    end
+    it 'json format' do
+      get '/foo.json'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: 'json'))
+    end
+    it 'invalid format' do
+      get '/foo.invalid'
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq(MultiJson.dump(id: 'foo', format: 'invalid'))
+    end
+  end
+end

data/spec/grape/api/recognize_path_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Grape::API do
+  describe '.recognize_path' do
+    subject { Class.new(Grape::API) }
+
+    it 'fetches endpoint by given path' do
+      subject.get('/foo/:id') {}
+      subject.get('/bar/:id') {}
+      subject.get('/baz/:id') {}
+
+      actual = subject.recognize_path('/bar/1234').routes[0].origin
+      expect(actual).to eq('/bar/:id')
+    end
+
+    it 'returns nil if given path does not match with registered routes' do
+      subject.get {}
+      expect(subject.recognize_path('/bar/1234')).to be_nil
+    end
+  end
+end

data/spec/grape/api/required_parameters_with_invalid_method_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Grape::Endpoint do
+  subject { Class.new(Grape::API) }
+
+  def app
+    subject
+  end
+
+  before do
+    subject.namespace do
+      params do
+        requires :id, desc: 'Identifier.'
+      end
+      get ':id' do
+      end
+    end
+  end
+
+  context 'post' do
+    it '405' do
+      post '/something'
+      expect(last_response.status).to eq 405
+    end
+  end
+end

data/spec/grape/api_spec.rb

@@ -411,7 +411,7 @@ describe Grape::API do
       end
 
       subject.endpoints.first.routes.each do |route|
-        expect(route.route_path).to eql '/abc(.:format)'
+        expect(route.path).to eql '/abc(.:format)'
       end
 
       get '/abc'
@@ -567,6 +567,72 @@ XML
       expect(last_response.headers['Content-Type']).to eql 'text/plain'
     end
 
+    describe 'adds an OPTIONS route that' do
+      before do
+        subject.before { header 'X-Custom-Header', 'foo' }
+        subject.get 'example' do
+          'example'
+        end
+        subject.route :any, '*path' do
+          error! :not_found, 404
+        end
+        options '/example'
+      end
+
+      it 'returns a 204' do
+        expect(last_response.status).to eql 204
+      end
+
+      it 'has an empty body' do
+        expect(last_response.body).to be_blank
+      end
+
+      it 'has an Allow header' do
+        expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD'
+      end
+
+      it 'has a X-Custom-Header' do
+        expect(last_response.headers['X-Custom-Header']).to eql 'foo'
+      end
+
+      it 'has no Content-Type' do
+        expect(last_response.content_type).to be_nil
+      end
+
+      it 'has no Content-Length' do
+        expect(last_response.content_length).to be_nil
+      end
+    end
+
+    describe 'adds a 405 Not Allowed route that' do
+      before do
+        subject.before { header 'X-Custom-Header', 'foo' }
+        subject.post :example do
+          'example'
+        end
+        subject.route :any, '*path' do
+          error! :not_found, 404
+        end
+        get '/example'
+      end
+
+      it 'returns a 405' do
+        expect(last_response.status).to eql 405
+      end
+
+      it 'contains error message in body' do
+        expect(last_response.body).to eq '405 Not Allowed'
+      end
+
+      it 'has an Allow header' do
+        expect(last_response.headers['Allow']).to eql 'OPTIONS, POST'
+      end
+
+      it 'has a X-Custom-Header' do
+        expect(last_response.headers['X-Custom-Header']).to eql 'foo'
+      end
+    end
+
     context 'allows HEAD on a GET request that' do
       before do
         subject.get 'example' do
@@ -1980,7 +2046,7 @@ XML
     end
 
     it 'presented with' do
-      error = { code: 408, with: error_presenter }
+      error = { code: 408, with: error_presenter }.freeze
       subject.get '/exception' do
         error! error, 408
       end
@@ -2006,9 +2072,9 @@ XML
       it 'returns one route' do
         expect(subject.routes.size).to eq(1)
         route = subject.routes[0]
-        expect(route.route_version).to be_nil
-        expect(route.route_path).to eq('/ping(.:format)')
-        expect(route.route_method).to eq('GET')
+        expect(route.version).to be_nil
+        expect(route.path).to eq('/ping(.:format)')
+        expect(route.request_method).to eq('GET')
       end
     end
     describe 'api structure with two versions and a namespace' do
@@ -2036,18 +2102,18 @@ XML
       end
       it 'sets route paths' do
         expect(subject.routes.size).to be >= 2
-        expect(subject.routes[0].route_path).to eq('/:version/version(.:format)')
-        expect(subject.routes[1].route_path).to eq('/p/:version/n1/n2/version(.:format)')
+        expect(subject.routes[0].path).to eq('/:version/version(.:format)')
+        expect(subject.routes[1].path).to eq('/p/:version/n1/n2/version(.:format)')
       end
       it 'sets route versions' do
-        expect(subject.routes[0].route_version).to eq('v1')
-        expect(subject.routes[1].route_version).to eq('v2')
+        expect(subject.routes[0].version).to eq('v1')
+        expect(subject.routes[1].version).to eq('v2')
       end
       it 'sets a nested namespace' do
-        expect(subject.routes[1].route_namespace).to eq('/n1/n2')
+        expect(subject.routes[1].namespace).to eq('/n1/n2')
       end
       it 'sets prefix' do
-        expect(subject.routes[1].route_prefix).to eq('p')
+        expect(subject.routes[1].prefix).to eq('p')
       end
     end
     describe 'api structure with additional parameters' do
@@ -2068,9 +2134,9 @@ XML
         get '/split/a,b,c.json', token: ',', limit: '2'
         expect(last_response.body).to eq('["a","b,c"]')
       end
-      it 'sets route_params' do
+      it 'sets params' do
         expect(subject.routes.map { |route|
-          { params: route.route_params }
+          { params: route.params }
         }).to eq [
           {
             params: {
@@ -2098,9 +2164,9 @@ XML
         subject.get 'two' do
         end
       end
-      it 'sets route_params' do
+      it 'sets params' do
         expect(subject.routes.map { |route|
-          { params: route.route_params }
+          { params: route.params }
         }).to eq [
           {
             params: {
@@ -2129,9 +2195,9 @@ XML
         subject.get 'two' do
         end
       end
-      it 'sets route_params' do
+      it 'sets params' do
         expect(subject.routes.map { |route|
-          { params: route.route_params }
+          { params: route.params }
         }).to eq [
           {
             params: {
@@ -2153,7 +2219,7 @@ XML
       it 'exposed' do
         expect(subject.routes.count).to eq 1
         route = subject.routes.first
-        expect(route.route_settings[:custom]).to eq(key: 'value')
+        expect(route.settings[:custom]).to eq(key: 'value')
       end
     end
     describe 'status' do
@@ -2187,9 +2253,9 @@ XML
       subject.get :first do; end
       expect(subject.routes.length).to eq(1)
       route = subject.routes.first
-      expect(route.route_description).to eq('first method')
+      expect(route.description).to eq('first method')
       expect(route.route_foo).to be_nil
-      expect(route.route_params).to eq({})
+      expect(route.params).to eq({})
     end
     it 'describes methods separately' do
       subject.desc 'first method'
@@ -2198,7 +2264,7 @@ XML
       subject.get :second do; end
       expect(subject.routes.count).to eq(2)
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: 'first method', params: {} },
         { description: 'second method', params: {} }
@@ -2209,7 +2275,7 @@ XML
       subject.get :first do; end
       subject.get :second do; end
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: 'first method', params: {} },
         { description: nil, params: {} }
@@ -2221,7 +2287,7 @@ XML
         get 'second' do; end
       end
       expect(subject.routes.map { |route|
-        { description: route.route_description, foo: route.route_foo, params: route.route_params }
+        { description: route.description, foo: route.route_foo, params: route.params }
       }).to eq [
         { description: 'ns second', foo: 'bar', params: {} }
       ]
@@ -2230,7 +2296,7 @@ XML
       subject.desc 'method', details: 'method details'
       subject.get 'method' do; end
       expect(subject.routes.map { |route|
-        { description: route.route_description, details: route.route_details, params: route.route_params }
+        { description: route.description, details: route.details, params: route.params }
       }).to eq [
         { description: 'method', details: 'method details', params: {} }
       ]
@@ -2241,7 +2307,7 @@ XML
         params[:s].reverse
       end
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } }
       ]
@@ -2262,7 +2328,7 @@ XML
         get do; end
       end
       routes_doc = subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }
       expect(routes_doc).to eq [
         { description: 'global description',
@@ -2292,7 +2358,7 @@ XML
       end
 
       routes_doc = subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }
       expect(routes_doc).to eq [
         { description: 'method',
@@ -2324,7 +2390,7 @@ XML
         end
       end
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: 'method',
           params: {
@@ -2350,7 +2416,7 @@ XML
       end
       subject.get 'method' do; end
 
-      expect(subject.routes.map(&:route_params)).to eq [{
+      expect(subject.routes.map(&:params)).to eq [{
         'group1'         => { required: true, type: 'Array' },
         'group1[param1]' => { required: false, desc: 'group1 param1 desc' },
         'group1[param2]' => { required: true, desc: 'group1 param2 desc' },
@@ -2369,7 +2435,7 @@ XML
       end
       subject.get 'method' do; end
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: 'nesting',
           params: {
@@ -2393,7 +2459,7 @@ XML
       end
       subject.get 'method' do; end
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: nil, params: { 'one_param' => { required: true, desc: 'one param' } } }
       ]
@@ -2404,7 +2470,7 @@ XML
         params[:s].reverse
       end
       expect(subject.routes.map { |route|
-        { description: route.route_description, params: route.route_params }
+        { description: route.description, params: route.params }
       }).to eq [
         { description: 'Reverses a string.', params: { 's' => { desc: 'string to reverse', type: 'string' } } }
       ]
@@ -2512,8 +2578,8 @@ XML
           mount app
         end
         expect(subject.routes.size).to eq(2)
-        expect(subject.routes.first.route_path).to match(%r{\/cool\/awesome})
-        expect(subject.routes.last.route_path).to match(%r{\/cool\/sauce})
+        expect(subject.routes.first.path).to match(%r{\/cool\/awesome})
+        expect(subject.routes.last.path).to match(%r{\/cool\/sauce})
       end
 
       it 'mounts on a path' do
@@ -2732,10 +2798,10 @@ XML
     context 'plain' do
       before(:each) do
         subject.get '/' do
-          route.route_path
+          route.path
         end
         subject.get '/path' do
-          route.route_path
+          route.path
         end
       end
       it 'provides access to route info' do
@@ -2749,11 +2815,11 @@ XML
       before(:each) do
         subject.desc 'returns description'
         subject.get '/description' do
-          route.route_description
+          route.description
         end
         subject.desc 'returns parameters', params: { 'x' => 'y' }
         subject.get '/params/:id' do
-          route.route_params[params[:id]]
+          route.params[params[:id]]
         end
       end
       it 'returns route description' do
@@ -2980,6 +3046,12 @@ XML
         get '/v2/hello'
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('v2')
+        options '/v2/hello'
+        expect(last_response.status).to eq(204)
+        expect(last_response.body).to be_blank
+        head '/v2/hello'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to be_blank
         get '/foobar'
         expect(last_response.status).to eq(404)
         expect(last_response.body).to eq('Unrecognized request path: foobar - /foobar')