grape 0.9.0 → 0.10.0

data/spec/grape/dsl/callbacks_spec.rb

@@ -14,28 +14,28 @@ module Grape
 
       describe '.before' do
         it 'adds a block to "before"' do
-          expect(subject).to receive(:imbue).with(:befores, [proc])
+          expect(subject).to receive(:namespace_stackable).with(:befores, proc)
           subject.before(&proc)
         end
       end
 
       describe '.before_validation' do
         it 'adds a block to "before_validation"' do
-          expect(subject).to receive(:imbue).with(:before_validations, [proc])
+          expect(subject).to receive(:namespace_stackable).with(:before_validations, proc)
           subject.before_validation(&proc)
         end
       end
 
       describe '.after_validation' do
         it 'adds a block to "after_validation"' do
-          expect(subject).to receive(:imbue).with(:after_validations, [proc])
+          expect(subject).to receive(:namespace_stackable).with(:after_validations, proc)
           subject.after_validation(&proc)
         end
       end
 
       describe '.after' do
         it 'adds a block to "after"' do
-          expect(subject).to receive(:imbue).with(:afters, [proc])
+          expect(subject).to receive(:namespace_stackable).with(:afters, proc)
           subject.after(&proc)
         end
       end

data/spec/grape/dsl/configuration_spec.rb

@@ -5,12 +5,6 @@ module Grape
     module ConfigurationSpec
       class Dummy
         include Grape::DSL::Configuration
-
-        # rubocop:disable TrivialAccessors
-        def self.last_desc
-          @last_description
-        end
-        # rubocop:enable TrivialAccessors
       end
     end
     describe Configuration do
@@ -22,16 +16,61 @@ module Grape
           subject.logger logger
           expect(subject.logger).to eq logger
         end
+
+        it 'returns a logger' do
+          expect(subject.logger logger).to eq logger
+        end
       end
 
       describe '.desc' do
         it 'sets a description' do
+          desc_text = 'The description'
           options = { message: 'none' }
-          subject.desc options
-          expect(subject.last_desc).to eq(description: options)
+          subject.desc desc_text, options
+          expect(subject.namespace_setting(:description)).to eq(options.merge(description: desc_text))
+          expect(subject.route_setting(:description)).to eq(options.merge(description: desc_text))
         end
-      end
 
+        it 'can be set with a block' do
+          expected_options = {
+            description: 'The description',
+            detail: 'more details',
+            params: { first: :param },
+            entity: Object,
+            http_codes: [[401, 'Unauthorized', 'Entities::Error']],
+            named: 'My named route',
+            headers: [XAuthToken: {
+              description: 'Valdates your identity',
+              required: true
+            },
+                      XOptionalHeader: {
+                        description: 'Not really needed',
+                        required: false
+                      }
+              ]
+          }
+
+          subject.desc 'The description' do
+            detail 'more details'
+            params(first: :param)
+            success Object
+            failure [[401, 'Unauthorized', 'Entities::Error']]
+            named 'My named route'
+            headers [XAuthToken: {
+              description: 'Valdates your identity',
+              required: true
+            },
+                     XOptionalHeader: {
+                       description: 'Not really needed',
+                       required: false
+                     }
+            ]
+          end
+
+          expect(subject.namespace_setting(:description)).to eq(expected_options)
+          expect(subject.route_setting(:description)).to eq(expected_options)
+        end
+      end
     end
   end
 end

data/spec/grape/dsl/helpers_spec.rb

@@ -6,17 +6,9 @@ module Grape
       class Dummy
         include Grape::DSL::Helpers
 
-        def self.settings
-          @settings ||= Grape::Util::HashStack.new
-        end
-
-        def self.set(_, mod)
-          @mod = mod
-        end
-
         # rubocop:disable TrivialAccessors
         def self.mod
-          @mod
+          namespace_stackable(:helpers).first
         end
         # rubocop:enable TrivialAccessors
       end
@@ -33,7 +25,8 @@ module Grape
 
       describe '.helpers' do
         it 'adds a module with the given block' do
-          expect(subject).to receive(:set).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original
+          expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original
+          expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original
           subject.helpers(&proc)
 
           expect(subject.mod.instance_methods).to include(:test)
@@ -42,11 +35,11 @@ module Grape
         it 'uses provided modules' do
           mod = Module.new
 
-          expect(subject).to receive(:set).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original
+          expect(subject).to receive(:namespace_stackable).with(:helpers, kind_of(Grape::DSL::Helpers::BaseHelper)).and_call_original
+          expect(subject).to receive(:namespace_stackable).with(:helpers).and_call_original
           subject.helpers(mod, &proc)
 
-          expect(subject.mod).not_to eq mod
-          expect(subject.mod).to include mod
+          expect(subject.mod).to eq mod
         end
       end
     end

data/spec/grape/dsl/inside_route_spec.rb

@@ -6,12 +6,12 @@ module Grape
       class Dummy
         include Grape::DSL::InsideRoute
 
-        attr_reader :env, :request, :settings
+        attr_reader :env, :request, :new_settings
 
         def initialize
           @env = {}
           @header = {}
-          @settings = Grape::Util::HashStack.new
+          @new_settings = { namespace_inheritable: {}, namespace_stackable: {} }
         end
       end
     end
@@ -46,7 +46,7 @@ module Grape
 
         describe 'default_error_status' do
           before do
-            subject.settings[:default_error_status] = 500
+            subject.namespace_inheritable(:default_error_status, 500)
             catch(:error) { subject.error! 'Unknown' }
           end
           it 'sets status to default_error_status' do
@@ -89,7 +89,7 @@ module Grape
       end
 
       describe '#status' do
-        ['GET', 'PUT', 'DELETE', 'OPTIONS'].each do |method|
+        %w(GET PUT DELETE OPTIONS).each do |method|
           it 'defaults to 200 on GET' do
             request = Grape::Request.new(Rack::MockRequest.env_for('/', method: method))
             expect(subject).to receive(:request).and_return(request)
@@ -160,6 +160,17 @@ module Grape
           end
         end
 
+        describe 'false' do
+          before do
+            subject.body false
+          end
+
+          it 'sets status to 204' do
+            expect(subject.body).to eq ''
+            expect(subject.status).to eq 204
+          end
+        end
+
         it 'returns default' do
           expect(subject.body).to be nil
         end
@@ -208,6 +219,34 @@ module Grape
             end
           end
         end
+
+        describe 'with' do
+          describe 'multiple entities' do
+            let(:entity_mock1) do
+              entity_mock1 = Object.new
+              allow(entity_mock1).to receive(:represent).and_return(dummy1: 'dummy1')
+              entity_mock1
+            end
+
+            let(:entity_mock2) do
+              entity_mock2 = Object.new
+              allow(entity_mock2).to receive(:represent).and_return(dummy2: 'dummy2')
+              entity_mock2
+            end
+
+            describe 'instance' do
+              before do
+                subject.present 'dummy1', with: entity_mock1
+                subject.present 'dummy2', with: entity_mock2
+              end
+
+              it 'presents both dummy objects' do
+                expect(subject.body[:dummy1]).to eq 'dummy1'
+                expect(subject.body[:dummy2]).to eq 'dummy2'
+              end
+            end
+          end
+        end
       end
 
       describe '#declared' do

data/spec/grape/dsl/middleware_spec.rb

@@ -5,14 +5,6 @@ module Grape
     module MiddlewareSpec
       class Dummy
         include Grape::DSL::Middleware
-
-        def self.settings
-          @settings ||= Grape::Util::HashStack.new
-        end
-
-        def self.imbue(key, value)
-          settings.imbue(key, value)
-        end
       end
     end
     describe Middleware do
@@ -21,11 +13,10 @@ module Grape
 
       describe '.use' do
         it 'adds a middleware' do
-          expect(subject).to receive(:imbue).with(:middleware, [[:my_middleware, :arg1, proc]])
+          expect(subject).to receive(:namespace_stackable).with(:middleware, [:my_middleware, :arg1, proc])
 
           subject.use :my_middleware, :arg1, &proc
         end
-
       end
 
       describe '.middleware' do

data/spec/grape/dsl/parameters_spec.rb

@@ -95,6 +95,14 @@ module Grape
         end
       end
 
+      describe '#all_or_none_of' do
+        it 'adds an all or none of parameter validation' do
+          subject.all_or_none_of :media, :audio
+
+          expect(subject.valids).to eq([[:media, :audio], { all_or_none_of: true }])
+        end
+      end
+
       xdescribe '#group' do
         it 'does some thing'
       end
@@ -102,7 +110,6 @@ module Grape
       xdescribe '#params' do
         it 'does some thing'
       end
-
     end
   end
 end

data/spec/grape/dsl/request_response_spec.rb

@@ -6,10 +6,6 @@ module Grape
       class Dummy
         include Grape::DSL::RequestResponse
 
-        def self.settings
-          @settings ||= Grape::Util::HashStack.new
-        end
-
         def self.set(key, value)
           settings[key.to_sym] = value
         end
@@ -27,7 +23,7 @@ module Grape
 
       describe '.default_format' do
         it 'sets the default format' do
-          expect(subject).to receive(:set).with(:default_format, :format)
+          expect(subject).to receive(:namespace_inheritable).with(:default_format, :format)
           subject.default_format :format
         end
 
@@ -40,8 +36,8 @@ module Grape
 
       describe '.format' do
         it 'sets a new format' do
-          expect(subject).to receive(:set).with(:format, format.to_sym)
-          expect(subject).to receive(:set).with(:default_error_formatter, Grape::ErrorFormatter::Txt)
+          expect(subject).to receive(:namespace_inheritable).with(:format, format.to_sym)
+          expect(subject).to receive(:namespace_inheritable).with(:default_error_formatter, Grape::ErrorFormatter::Txt)
 
           subject.format format
         end
@@ -49,21 +45,21 @@ module Grape
 
       describe '.formatter' do
         it 'sets the formatter for a content type' do
-          expect(subject.settings).to receive(:imbue).with(:formatters, c_type.to_sym => :formatter)
+          expect(subject).to receive(:namespace_stackable).with(:formatters, c_type.to_sym => :formatter)
           subject.formatter c_type, :formatter
         end
       end
 
       describe '.parser' do
         it 'sets a parser for a content type' do
-          expect(subject.settings).to receive(:imbue).with(:parsers, c_type.to_sym => :parser)
+          expect(subject).to receive(:namespace_stackable).with(:parsers, c_type.to_sym => :parser)
           subject.parser c_type, :parser
         end
       end
 
       describe '.default_error_formatter' do
         it 'sets a new error formatter' do
-          expect(subject).to receive(:set).with(:default_error_formatter, Grape::ErrorFormatter::Json)
+          expect(subject).to receive(:namespace_inheritable).with(:default_error_formatter, Grape::ErrorFormatter::Json)
           subject.default_error_formatter :json
         end
       end
@@ -71,38 +67,36 @@ module Grape
       describe '.error_formatter' do
         it 'sets a error_formatter' do
           format = 'txt'
-          expect(subject.settings).to receive(:imbue).with(:error_formatters, format.to_sym => :error_formatter)
+          expect(subject).to receive(:namespace_stackable).with(:error_formatters, format.to_sym => :error_formatter)
           subject.error_formatter format, :error_formatter
         end
 
         it 'understands syntactic sugar' do
-          expect(subject.settings).to receive(:imbue).with(:error_formatters, format.to_sym => :error_formatter)
+          expect(subject).to receive(:namespace_stackable).with(:error_formatters, format.to_sym => :error_formatter)
           subject.error_formatter format, with: :error_formatter
         end
       end
 
       describe '.content_type' do
         it 'sets a content type for a format' do
-          expect(subject.settings).to receive(:imbue).with(:content_types, format.to_sym => c_type)
+          expect(subject).to receive(:namespace_stackable).with(:content_types, format.to_sym => c_type)
           subject.content_type format, c_type
         end
       end
 
       describe '.content_types' do
         it 'returns all content types' do
-          expect(subject.content_types).to eq(xml: "application/xml",
-                                              serializable_hash: "application/json",
-                                              json: "application/json",
-                                              jsonapi: "application/vnd.api+json",
-                                              atom: "application/atom+xml",
-                                              rss: "application/rss+xml",
-                                              txt: "text/plain")
+          expect(subject.content_types).to eq(xml: 'application/xml',
+                                              serializable_hash: 'application/json',
+                                              json: 'application/json',
+                                              txt: 'text/plain',
+                                              binary: 'application/octet-stream')
         end
       end
 
       describe '.default_error_status' do
         it 'sets a default error status' do
-          expect(subject).to receive(:set).with(:default_error_status, 500)
+          expect(subject).to receive(:namespace_inheritable).with(:default_error_status, 500)
           subject.default_error_status 500
         end
       end
@@ -114,7 +108,7 @@ module Grape
       describe '.represent' do
         it 'sets a presenter for a class' do
           presenter = Class.new
-          expect(subject).to receive(:imbue).with(:representations, ThisClass: presenter)
+          expect(subject).to receive(:namespace_stackable).with(:representations, ThisClass: presenter)
           subject.represent :ThisClass, with: presenter
         end
       end

data/spec/grape/dsl/routing_spec.rb

@@ -21,27 +21,43 @@ module Grape
       describe '.prefix' do
         it 'sets a prefix for route' do
           prefix = '/api'
-          expect(subject).to receive(:set).with(:root_prefix, prefix)
+          expect(subject).to receive(:namespace_inheritable).with(:root_prefix, prefix)
           subject.prefix prefix
         end
       end
 
       describe '.do_not_route_head!' do
         it 'sets do not route head option' do
-          expect(subject).to receive(:set).with(:do_not_route_head, true)
+          expect(subject).to receive(:namespace_inheritable).with(:do_not_route_head, true)
           subject.do_not_route_head!
         end
       end
 
       describe '.do_not_route_options!' do
         it 'sets do not route options option' do
-          expect(subject).to receive(:set).with(:do_not_route_options, true)
+          expect(subject).to receive(:namespace_inheritable).with(:do_not_route_options, true)
           subject.do_not_route_options!
         end
       end
 
-      xdescribe '.mount' do
-        it 'does some thing'
+      describe '.mount' do
+        it 'mounts on a nested path' do
+          subject = Class.new(Grape::API)
+          app1 = Class.new(Grape::API)
+          app2 = Class.new(Grape::API)
+          app2.get '/nice' do
+            'play'
+          end
+
+          subject.mount app1 => '/app1'
+          app1.mount app2 => '/app2'
+
+          expect(subject.inheritable_setting.to_hash[:namespace]).to eq({})
+          expect(subject.inheritable_setting.to_hash[:namespace_inheritable]).to eq({})
+          expect(app1.inheritable_setting.to_hash[:namespace_stackable]).to eq(:mount_path => ['/app1'])
+
+          expect(app2.inheritable_setting.to_hash[:namespace_stackable]).to eq(:mount_path => ['/app1', '/app2'])
+        end
       end
       xdescribe '.route' do
         it 'does some thing'