grape 0.9.0 → 0.10.0

data/spec/grape/middleware/versioner/path_spec.rb

@@ -27,7 +27,7 @@ describe Grape::Middleware::Versioner::Path do
     end
   end
 
-  [['v1', 'v2'], [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
+  [%w(v1 v2), [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
     context 'with specified versions as #{versions}' do
       before { @options = { versions: versions } }
 
@@ -40,5 +40,4 @@ describe Grape::Middleware::Versioner::Path do
       end
     end
   end
-
 end

data/spec/grape/middleware/versioner_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner do
-
   let(:klass) { Grape::Middleware::Versioner }
 
   it 'recognizes :path' do

data/spec/grape/path_spec.rb

@@ -2,65 +2,64 @@ require 'spec_helper'
 
 module Grape
   describe Path do
-
-    describe "#initialize" do
-      it "remembers the path" do
+    describe '#initialize' do
+      it 'remembers the path' do
         path = Path.new('/:id', anything, anything)
         expect(path.raw_path).to eql('/:id')
       end
 
-      it "remembers the namespace" do
+      it 'remembers the namespace' do
         path = Path.new(anything, '/users', anything)
         expect(path.namespace).to eql('/users')
       end
 
-      it "remebers the settings" do
+      it 'remebers the settings' do
         path = Path.new(anything, anything, foo: 'bar')
         expect(path.settings).to eql(foo: 'bar')
       end
     end
 
-    describe "#mount_path" do
-      it "is nil when no mount path setting exists" do
+    describe '#mount_path' do
+      it 'is nil when no mount path setting exists' do
         path = Path.new(anything, anything, {})
         expect(path.mount_path).to be_nil
       end
 
-      it "is nil when the mount path is nil" do
+      it 'is nil when the mount path is nil' do
         path = Path.new(anything, anything, mount_path: nil)
         expect(path.mount_path).to be_nil
       end
 
-      it "splits the mount path" do
-        path = Path.new(anything, anything, mount_path: 'foo/bar')
-        expect(path.mount_path).to eql(['foo', 'bar'])
+      it 'splits the mount path' do
+        path = Path.new(anything, anything, mount_path: %w(foo bar))
+        expect(path.mount_path).to eql(%w(foo bar))
       end
     end
 
-    describe "#root_prefix" do
-      it "is nil when no root prefix setting exists" do
+    describe '#root_prefix' do
+      it 'is nil when no root prefix setting exists' do
         path = Path.new(anything, anything, {})
         expect(path.root_prefix).to be_nil
       end
 
-      it "is nil when the mount path is nil" do
+      it 'is nil when the mount path is nil' do
         path = Path.new(anything, anything, root_prefix: nil)
         expect(path.root_prefix).to be_nil
       end
 
-      it "splits the mount path" do
+      it 'splits the mount path' do
         path = Path.new(anything, anything, root_prefix: 'hello/world')
-        expect(path.root_prefix).to eql(['hello', 'world'])
+        expect(path.root_prefix).to eql(%w(hello world))
       end
     end
 
-    describe "#uses_path_versioning?" do
-      it "is false when the version setting is nil" do
+    describe '#uses_path_versioning?' do
+      it 'is false when the version setting is nil' do
         path = Path.new(anything, anything, version: nil)
         expect(path.uses_path_versioning?).to be false
       end
 
-      it "is false when the version option is header" do
+      it 'is false when the version option is header' do
         path = Path.new(
           anything,
           anything,
@@ -71,7 +70,7 @@ module Grape
         expect(path.uses_path_versioning?).to be false
       end
 
-      it "is true when the version option is path" do
+      it 'is true when the version option is path' do
         path = Path.new(
           anything,
           anything,
@@ -83,70 +82,70 @@ module Grape
       end
     end
 
-    describe "#has_namespace?" do
-      it "is false when the namespace is nil" do
+    describe '#has_namespace?' do
+      it 'is false when the namespace is nil' do
         path = Path.new(anything, nil, anything)
         expect(path).not_to have_namespace
       end
 
-      it "is false when the namespace starts with whitespace" do
+      it 'is false when the namespace starts with whitespace' do
         path = Path.new(anything, ' /foo', anything)
         expect(path).not_to have_namespace
       end
 
-      it "is false when the namespace is the root path" do
+      it 'is false when the namespace is the root path' do
         path = Path.new(anything, '/', anything)
         expect(path).not_to have_namespace
       end
 
-      it "is true otherwise" do
+      it 'is true otherwise' do
         path = Path.new(anything, '/world', anything)
         expect(path).to have_namespace
       end
     end
 
-    describe "#has_path?" do
-      it "is false when the path is nil" do
+    describe '#has_path?' do
+      it 'is false when the path is nil' do
         path = Path.new(nil, anything, anything)
         expect(path).not_to have_path
       end
 
-      it "is false when the path starts with whitespace" do
+      it 'is false when the path starts with whitespace' do
         path = Path.new(' /foo', anything, anything)
         expect(path).not_to have_path
       end
 
-      it "is false when the path is the root path" do
+      it 'is false when the path is the root path' do
         path = Path.new('/', anything, anything)
         expect(path).not_to have_path
       end
 
-      it "is true otherwise" do
+      it 'is true otherwise' do
         path = Path.new('/hello', anything, anything)
         expect(path).to have_path
       end
     end
 
-    describe "#path" do
-      context "mount_path" do
-        it "is not included when it is nil" do
+    describe '#path' do
+      context 'mount_path' do
+        it 'is not included when it is nil' do
           path = Path.new(nil, nil, mount_path: '/foo/bar')
           expect(path.path).to eql '/foo/bar'
         end
 
-        it "is included when it is not nil" do
+        it 'is included when it is not nil' do
           path = Path.new(nil, nil, {})
           expect(path.path).to eql('/')
         end
       end
 
-      context "root_prefix" do
-        it "is not included when it is nil" do
+      context 'root_prefix' do
+        it 'is not included when it is nil' do
           path = Path.new(nil, nil, {})
           expect(path.path).to eql('/')
         end
 
-        it "is included after the mount path" do
+        it 'is included after the mount path' do
           path = Path.new(
             nil,
             nil,
@@ -158,7 +157,7 @@ module Grape
         end
       end
 
-      it "uses the namespace after the mount path and root prefix" do
+      it 'uses the namespace after the mount path and root prefix' do
         path = Path.new(
           nil,
           'namespace',
@@ -169,7 +168,7 @@ module Grape
         expect(path.path).to eql('/foo/hello/namespace')
       end
 
-      it "uses the raw path after the namespace" do
+      it 'uses the raw path after the namespace' do
         path = Path.new(
           'raw_path',
           'namespace',
@@ -181,19 +180,30 @@ module Grape
       end
     end
 
-    describe "#suffix" do
-      context "when path versioning is used" do
+    describe '#suffix' do
+      context 'when using a specific format' do
+        it 'is empty' do
+          path = Path.new(nil, nil, {})
+          allow(path).to receive(:uses_specific_format?) { true }
+
+          expect(path.suffix).to eql('')
+        end
+      end
+
+      context 'when path versioning is used' do
         it "includes a '/'" do
           path = Path.new(nil, nil, {})
+          allow(path).to receive(:uses_specific_format?) { false }
           allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(/.:format)')
         end
       end
 
-      context "when path versioning is not used" do
+      context 'when path versioning is not used' do
         it "does not include a '/' when the path has a namespace" do
           path = Path.new(nil, 'namespace', {})
+          allow(path).to receive(:uses_specific_format?) { false }
           allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(.:format)')
@@ -201,6 +211,7 @@ module Grape
 
         it "does not include a '/' when the path has a path" do
           path = Path.new('/path', nil, {})
+          allow(path).to receive(:uses_specific_format?) { false }
           allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(.:format)')
@@ -208,6 +219,7 @@ module Grape
 
         it "includes a '/' otherwise" do
           path = Path.new(nil, nil, {})
+          allow(path).to receive(:uses_specific_format?) { false }
           allow(path).to receive(:uses_path_versioning?) { true }
 
           expect(path.suffix).to eql('(/.:format)')
@@ -215,15 +227,24 @@ module Grape
       end
     end
 
-    describe "#path_with_suffix" do
-      it "combines the path and suffix" do
+    describe '#path_with_suffix' do
+      it 'combines the path and suffix' do
         path = Path.new(nil, nil, {})
         allow(path).to receive(:path) { '/the/path' }
         allow(path).to receive(:suffix) { 'suffix' }
 
         expect(path.path_with_suffix).to eql('/the/pathsuffix')
       end
-    end
 
+      context 'when using a specific format' do
+        it 'does not have a suffix' do
+          path = Path.new(nil, nil, {})
+          allow(path).to receive(:path) { '/the/path' }
+          allow(path).to receive(:uses_specific_format?) { true }
+
+          expect(path.path_with_suffix).to eql('/the/path')
+        end
+      end
+    end
   end
 end

data/spec/grape/util/inheritable_setting_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+module Grape
+  module Util
+    describe InheritableSetting do
+      before :each do
+        InheritableSetting.reset_global!
+      end
+
+      let(:parent) do
+        Grape::Util::InheritableSetting.new.tap do |settings|
+          settings.global[:global_thing] = :global_foo_bar
+          settings.namespace[:namespace_thing] = :namespace_foo_bar
+          settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar
+          settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar
+          settings.route[:route_thing] = :route_foo_bar
+        end
+      end
+
+      let(:other_parent) do
+        Grape::Util::InheritableSetting.new.tap do |settings|
+          settings.namespace[:namespace_thing] = :namespace_foo_bar_other
+          settings.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar_other
+          settings.namespace_stackable[:namespace_stackable_thing] = :namespace_stackable_foo_bar_other
+          settings.route[:route_thing] = :route_foo_bar_other
+        end
+      end
+
+      before :each do
+        subject.inherit_from parent
+      end
+
+      describe '#global' do
+        it 'sets a global value' do
+          subject.global[:some_thing] = :foo_bar
+          expect(subject.global[:some_thing]).to eq :foo_bar
+          subject.global[:some_thing] = :foo_bar_next
+          expect(subject.global[:some_thing]).to eq :foo_bar_next
+        end
+
+        it 'sets the global inherited values' do
+          expect(subject.global[:global_thing]).to eq :global_foo_bar
+        end
+
+        it 'overrides global values' do
+          subject.global[:global_thing] = :global_new_foo_bar
+          expect(parent.global[:global_thing]).to eq :global_new_foo_bar
+        end
+
+        it 'should handle different parents' do
+          subject.global[:global_thing] = :global_new_foo_bar
+
+          subject.inherit_from other_parent
+
+          expect(parent.global[:global_thing]).to eq :global_new_foo_bar
+          expect(other_parent.global[:global_thing]).to eq :global_new_foo_bar
+        end
+      end
+
+      describe '#api_class' do
+        it 'is specific to the class' do
+          subject.api_class[:some_thing] = :foo_bar
+          parent.api_class[:some_thing] = :some_thing
+
+          expect(subject.api_class[:some_thing]).to eq :foo_bar
+          expect(parent.api_class[:some_thing]).to eq :some_thing
+        end
+      end
+
+      describe '#namespace' do
+        it 'sets a value until the end of a namespace' do
+          subject.namespace[:some_thing] = :foo_bar
+          expect(subject.namespace[:some_thing]).to eq :foo_bar
+        end
+
+        it 'uses new values when a new namespace starts' do
+          subject.namespace[:namespace_thing] = :new_namespace_foo_bar
+          expect(subject.namespace[:namespace_thing]).to eq :new_namespace_foo_bar
+
+          expect(parent.namespace[:namespace_thing]).to eq :namespace_foo_bar
+        end
+      end
+
+      describe '#namespace_inheritable' do
+        it 'works with inheritable values' do
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
+        end
+
+        it 'should handle different parents' do
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
+
+          subject.inherit_from other_parent
+
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar_other
+
+          subject.inherit_from parent
+
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
+
+          subject.inherit_from other_parent
+
+          subject.namespace_inheritable[:namespace_inheritable_thing] = :my_thing
+
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing
+
+          subject.inherit_from parent
+
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing
+        end
+      end
+
+      describe '#namespace_stackable' do
+        it 'works with stackable values' do
+          expect(subject.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar]
+
+          subject.inherit_from other_parent
+
+          expect(subject.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar_other]
+        end
+      end
+
+      describe '#route' do
+        it 'sets a value until the next route' do
+          subject.route[:some_thing] = :foo_bar
+          expect(subject.route[:some_thing]).to eq :foo_bar
+
+          subject.route_end
+
+          expect(subject.route[:some_thing]).to be_nil
+        end
+
+        it 'works with route values' do
+          expect(subject.route[:route_thing]).to eq :route_foo_bar
+        end
+      end
+
+      describe '#api_class' do
+        it 'is specific to the class' do
+          subject.api_class[:some_thing] = :foo_bar
+          expect(subject.api_class[:some_thing]).to eq :foo_bar
+        end
+      end
+
+      describe '#inherit_from' do
+        it 'notifies clones' do
+          new_settings = subject.point_in_time_copy
+          expect(new_settings).to receive(:inherit_from).with(other_parent)
+
+          subject.inherit_from other_parent
+        end
+      end
+
+      describe '#point_in_time_copy' do
+        let!(:cloned_obj) { subject.point_in_time_copy }
+
+        it 'resets point_in_time_copies' do
+          expect(cloned_obj.point_in_time_copies).to be_empty
+        end
+
+        it 'decouples namespace values' do
+          subject.namespace[:namespace_thing] = :namespace_foo_bar
+
+          cloned_obj.namespace[:namespace_thing] = :new_namespace_foo_bar
+          expect(subject.namespace[:namespace_thing]).to eq :namespace_foo_bar
+        end
+
+        it 'decouples namespace inheritable values' do
+          expect(cloned_obj.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
+
+          subject.namespace_inheritable[:namespace_inheritable_thing] = :my_thing
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing
+
+          expect(cloned_obj.namespace_inheritable[:namespace_inheritable_thing]).to eq :namespace_inheritable_foo_bar
+
+          cloned_obj.namespace_inheritable[:namespace_inheritable_thing] = :my_cloned_thing
+          expect(cloned_obj.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_cloned_thing
+          expect(subject.namespace_inheritable[:namespace_inheritable_thing]).to eq :my_thing
+        end
+
+        it 'decouples namespace stackable values' do
+          expect(cloned_obj.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar]
+
+          subject.namespace_stackable[:namespace_stackable_thing] = :other_thing
+          expect(subject.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar, :other_thing]
+          expect(cloned_obj.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar]
+        end
+
+        it 'decouples route values' do
+          expect(cloned_obj.route[:route_thing]).to eq :route_foo_bar
+
+          subject.route[:route_thing] = :new_route_foo_bar
+          expect(cloned_obj.route[:route_thing]).to eq :route_foo_bar
+        end
+
+        it 'adds itself to original as clone' do
+          expect(subject.point_in_time_copies).to include(cloned_obj)
+        end
+      end
+
+      describe '#to_hash' do
+        it 'return all settings as a hash' do
+          subject.global[:global_thing] = :global_foo_bar
+          subject.namespace[:namespace_thing] = :namespace_foo_bar
+          subject.namespace_inheritable[:namespace_inheritable_thing] = :namespace_inheritable_foo_bar
+          subject.namespace_stackable[:namespace_stackable_thing] = [:namespace_stackable_foo_bar]
+          subject.route[:route_thing] = :route_foo_bar
+
+          expect(subject.to_hash).to include(global: { global_thing: :global_foo_bar })
+          expect(subject.to_hash).to include(namespace: { namespace_thing: :namespace_foo_bar })
+          expect(subject.to_hash).to include(namespace_inheritable: {
+                                               namespace_inheritable_thing: :namespace_inheritable_foo_bar })
+          expect(subject.to_hash).to include(namespace_stackable: { namespace_stackable_thing: [:namespace_stackable_foo_bar, [:namespace_stackable_foo_bar]] })
+          expect(subject.to_hash).to include(route: { route_thing: :route_foo_bar })
+        end
+      end
+    end
+  end
+end