grape 1.0.0 → 1.6.0

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Param do
   let(:app) { ->(env) { [200, env, env['api.version']] } }
   let(:options) { {} }
-  subject { Grape::Middleware::Versioner::Param.new(app, options) }
+  subject { Grape::Middleware::Versioner::Param.new(app, **options) }
 
   it 'sets the API version based on the default param (apiver)' do
     env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v1' })
@@ -35,7 +37,7 @@ describe Grape::Middleware::Versioner::Param do
   end
 
   context 'with specified versions' do
-    let(:options) { { versions: %w(v1 v2) } }
+    let(:options) { { versions: %w[v1 v2] } }
     it 'throws an error if a non-allowed version is specified' do
       env = Rack::MockRequest.env_for('/awesome', params: { 'apiver' => 'v3' })
       expect(catch(:error) { subject.call(env) }[:status]).to eq(404)

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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Path do
   let(:app) { ->(env) { [200, env, env['api.version']] } }
   let(:options) { {} }
-  subject { Grape::Middleware::Versioner::Path.new(app, options) }
+  subject { Grape::Middleware::Versioner::Path.new(app, **options) }
 
   it 'sets the API version based on the first path' do
     expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
@@ -28,7 +30,7 @@ describe Grape::Middleware::Versioner::Path do
     end
   end
 
-  [%w(v1 v2), [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
+  [%w[v1 v2], %i[v1 v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
     context "with specified versions as #{versions}" do
       let(:options) { { versions: versions } }
 

data/spec/grape/middleware/versioner_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner do

data/spec/grape/named_api_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'A named API' do
+  subject(:api_name) { NamedAPI.endpoints.last.options[:for].to_s }
+
+  let(:api) do
+    Class.new(Grape::API) do
+      get 'test' do
+        'response'
+      end
+    end
+  end
+
+  before { stub_const('NamedAPI', api) }
+
+  it 'can access the name of the API' do
+    expect(api_name).to eq 'NamedAPI'
+  end
+end

data/spec/grape/parser_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Parser do
@@ -15,11 +17,11 @@ describe Grape::Parser do
 
   describe '.parsers' do
     it 'returns an instance of Hash' do
-      expect(subject.parsers({})).to be_an_instance_of(Hash)
+      expect(subject.parsers(**{})).to be_an_instance_of(Hash)
     end
 
     it 'includes built-in parsers' do
-      expect(subject.parsers({})).to include(subject.builtin_parsers)
+      expect(subject.parsers(**{})).to include(subject.builtin_parsers)
     end
 
     context 'with :parsers option' do
@@ -33,7 +35,7 @@ describe Grape::Parser do
       let(:added_parser) { Class.new }
       before { subject.register :added, added_parser }
       it 'includes added parser' do
-        expect(subject.parsers({})).to include(added: added_parser)
+        expect(subject.parsers(**{})).to include(added: added_parser)
       end
     end
   end
@@ -42,8 +44,8 @@ describe Grape::Parser do
     let(:options) { {} }
 
     it 'calls .parsers' do
-      expect(subject).to receive(:parsers).with(options).and_return(subject.builtin_parsers)
-      subject.parser_for(:json, options)
+      expect(subject).to receive(:parsers).with(any_args).and_return(subject.builtin_parsers)
+      subject.parser_for(:json, **options)
     end
 
     it 'returns parser correctly' do

data/spec/grape/path_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Grape
@@ -31,8 +33,8 @@ module Grape
       end
 
       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))
+        path = Path.new(anything, anything, mount_path: %w[foo bar])
+        expect(path.mount_path).to eql(%w[foo bar])
       end
     end
 
@@ -49,7 +51,7 @@ module Grape
 
       it 'splits the mount path' do
         path = Path.new(anything, anything, root_prefix: 'hello/world')
-        expect(path.root_prefix).to eql(%w(hello world))
+        expect(path.root_prefix).to eql(%w[hello world])
       end
     end
 
@@ -85,12 +87,12 @@ module Grape
     describe '#namespace?' do
       it 'is false when the namespace is nil' do
         path = Path.new(anything, nil, anything)
-        expect(path.namespace?).to be nil
+        expect(path.namespace?).to be_falsey
       end
 
       it 'is false when the namespace starts with whitespace' do
         path = Path.new(anything, ' /foo', anything)
-        expect(path.namespace?).to be nil
+        expect(path.namespace?).to be_falsey
       end
 
       it 'is false when the namespace is the root path' do
@@ -107,12 +109,12 @@ module Grape
     describe '#path?' do
       it 'is false when the path is nil' do
         path = Path.new(nil, anything, anything)
-        expect(path.path?).to be nil
+        expect(path.path?).to be_falsey
       end
 
       it 'is false when the path starts with whitespace' do
         path = Path.new(' /foo', anything, anything)
-        expect(path.path?).to be nil
+        expect(path.path?).to be_falsey
       end
 
       it 'is false when the path is the root path' do

data/spec/grape/presenters/presenter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Grape

data/spec/grape/request_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Grape
@@ -62,6 +64,30 @@ module Grape
       end
     end
 
+    describe 'when the param_builder is set to Hashie' do
+      before do
+        Grape.configure do |config|
+          config.param_builder = Grape::Extensions::Hashie::Mash::ParamBuilder
+        end
+      end
+
+      after do
+        Grape.config.reset
+      end
+
+      subject(:request_params) { Grape::Request.new(env, **opts).params }
+
+      context 'when the API does not include a specific param builder' do
+        let(:opts) { {} }
+        it { is_expected.to be_a(Hashie::Mash) }
+      end
+
+      context 'when the API includes a specific param builder' do
+        let(:opts) { { build_params_with: Grape::Extensions::Hash::ParamBuilder } }
+        it { is_expected.to be_a(Hash) }
+      end
+    end
+
     describe '#headers' do
       let(:options) do
         default_options.merge(request_headers)

data/spec/grape/util/inheritable_setting_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 module Grape
   module Util
@@ -192,7 +194,7 @@ module Grape
           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(subject.namespace_stackable[:namespace_stackable_thing]).to eq %i[namespace_stackable_foo_bar other_thing]
           expect(cloned_obj.namespace_stackable[:namespace_stackable_thing]).to eq [:namespace_stackable_foo_bar]
         end
 
@@ -200,7 +202,7 @@ module Grape
           expect(cloned_obj.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:namespace_reverse_stackable_foo_bar]
 
           subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing] = :other_thing
-          expect(subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:other_thing, :namespace_reverse_stackable_foo_bar]
+          expect(subject.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq %i[other_thing namespace_reverse_stackable_foo_bar]
           expect(cloned_obj.namespace_reverse_stackable[:namespace_reverse_stackable_thing]).to eq [:namespace_reverse_stackable_foo_bar]
         end
 

data/spec/grape/util/inheritable_values_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 module Grape
   module Util

data/spec/grape/util/reverse_stackable_values_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 module Grape
   module Util
@@ -9,7 +11,7 @@ module Grape
         it 'returns all keys' do
           subject[:some_thing] = :foo_bar
           subject[:some_thing_else] = :foo_bar
-          expect(subject.keys).to eq [:some_thing, :some_thing_else].sort
+          expect(subject.keys).to eq %i[some_thing some_thing_else].sort
         end
 
         it 'returns merged keys with parent' do
@@ -19,7 +21,7 @@ module Grape
           subject[:some_thing] = :foo_bar
           subject[:some_thing_more] = :foo_bar
 
-          expect(subject.keys).to eq [:some_thing, :some_thing_else, :some_thing_more].sort
+          expect(subject.keys).to eq %i[some_thing some_thing_else some_thing_more].sort
         end
       end
 
@@ -52,7 +54,7 @@ module Grape
         it 'combines parent and actual values (actual first)' do
           parent[:some_thing] = :foo
           subject[:some_thing] = :foo_bar
-          expect(subject[:some_thing]).to eq [:foo_bar, :foo]
+          expect(subject[:some_thing]).to eq %i[foo_bar foo]
         end
 
         it 'parent values are not changed' do
@@ -71,28 +73,28 @@ module Grape
         it 'pushes further values' do
           subject[:some_thing] = :foo
           subject[:some_thing] = :bar
-          expect(subject[:some_thing]).to eq [:foo, :bar]
+          expect(subject[:some_thing]).to eq %i[foo bar]
         end
 
         it 'can handle array values' do
           subject[:some_thing] = :foo
-          subject[:some_thing] = [:bar, :more]
-          expect(subject[:some_thing]).to eq [:foo, [:bar, :more]]
+          subject[:some_thing] = %i[bar more]
+          expect(subject[:some_thing]).to eq [:foo, %i[bar more]]
 
-          parent[:some_thing_else] = [:foo, :bar]
-          subject[:some_thing_else] = [:some, :bar, :foo]
+          parent[:some_thing_else] = %i[foo bar]
+          subject[:some_thing_else] = %i[some bar foo]
 
-          expect(subject[:some_thing_else]).to eq [[:some, :bar, :foo], [:foo, :bar]]
+          expect(subject[:some_thing_else]).to eq [%i[some bar foo], %i[foo bar]]
         end
       end
 
       describe '#to_hash' do
         it 'returns a Hash representation' do
           parent[:some_thing] = :foo
-          subject[:some_thing] = [:bar, :more]
+          subject[:some_thing] = %i[bar more]
           subject[:some_thing_more] = :foo_bar
           expect(subject.to_hash).to eq(
-            some_thing: [[:bar, :more], :foo],
+            some_thing: [%i[bar more], :foo],
             some_thing_more: [:foo_bar]
           )
         end
@@ -106,12 +108,12 @@ module Grape
           grandchild = described_class.new child
 
           parent[:some_thing] = :foo
-          child[:some_thing] = [:bar, :more]
+          child[:some_thing] = %i[bar more]
           grandchild[:some_thing] = :grand_foo_bar
           grandchild[:some_thing_more] = :foo_bar
 
           expect(grandchild.clone.to_hash).to eq(
-            some_thing: [:grand_foo_bar, [:bar, :more], :foo],
+            some_thing: [:grand_foo_bar, %i[bar more], :foo],
             some_thing_more: [:foo_bar]
           )
         end

data/spec/grape/util/stackable_values_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 module Grape
   module Util
@@ -6,10 +8,10 @@ module Grape
       subject { StackableValues.new(parent) }
 
       describe '#keys' do
-        it 'returns all key' do
+        it 'returns all keys' do
           subject[:some_thing] = :foo_bar
           subject[:some_thing_else] = :foo_bar
-          expect(subject.keys).to eq [:some_thing, :some_thing_else].sort
+          expect(subject.keys).to eq %i[some_thing some_thing_else].sort
         end
 
         it 'returns merged keys with parent' do
@@ -19,7 +21,7 @@ module Grape
           subject[:some_thing] = :foo_bar
           subject[:some_thing_more] = :foo_bar
 
-          expect(subject.keys).to eq [:some_thing, :some_thing_else, :some_thing_more].sort
+          expect(subject.keys).to eq %i[some_thing some_thing_else some_thing_more].sort
         end
       end
 
@@ -52,7 +54,7 @@ module Grape
         it 'combines parent and actual values' do
           parent[:some_thing] = :foo
           subject[:some_thing] = :foo_bar
-          expect(subject[:some_thing]).to eq [:foo, :foo_bar]
+          expect(subject[:some_thing]).to eq %i[foo foo_bar]
         end
 
         it 'parent values are not changed' do
@@ -71,27 +73,27 @@ module Grape
         it 'pushes further values' do
           subject[:some_thing] = :foo
           subject[:some_thing] = :bar
-          expect(subject[:some_thing]).to eq [:foo, :bar]
+          expect(subject[:some_thing]).to eq %i[foo bar]
         end
 
         it 'can handle array values' do
           subject[:some_thing] = :foo
-          subject[:some_thing] = [:bar, :more]
-          expect(subject[:some_thing]).to eq [:foo, [:bar, :more]]
+          subject[:some_thing] = %i[bar more]
+          expect(subject[:some_thing]).to eq [:foo, %i[bar more]]
 
-          parent[:some_thing_else] = [:foo, :bar]
-          subject[:some_thing_else] = [:some, :bar, :foo]
+          parent[:some_thing_else] = %i[foo bar]
+          subject[:some_thing_else] = %i[some bar foo]
 
-          expect(subject[:some_thing_else]).to eq [[:foo, :bar], [:some, :bar, :foo]]
+          expect(subject[:some_thing_else]).to eq [%i[foo bar], %i[some bar foo]]
         end
       end
 
       describe '#to_hash' do
         it 'returns a Hash representation' do
           parent[:some_thing] = :foo
-          subject[:some_thing] = [:bar, :more]
+          subject[:some_thing] = %i[bar more]
           subject[:some_thing_more] = :foo_bar
-          expect(subject.to_hash).to eq(some_thing: [:foo, [:bar, :more]], some_thing_more: [:foo_bar])
+          expect(subject.to_hash).to eq(some_thing: [:foo, %i[bar more]], some_thing_more: [:foo_bar])
         end
       end
 
@@ -103,11 +105,11 @@ module Grape
           grandchild = StackableValues.new child
 
           parent[:some_thing] = :foo
-          child[:some_thing] = [:bar, :more]
+          child[:some_thing] = %i[bar more]
           grandchild[:some_thing] = :grand_foo_bar
           grandchild[:some_thing_more] = :foo_bar
 
-          expect(grandchild.clone.to_hash).to eq(some_thing: [:foo, [:bar, :more], :grand_foo_bar], some_thing_more: [:foo_bar])
+          expect(grandchild.clone.to_hash).to eq(some_thing: [:foo, %i[bar more], :grand_foo_bar], some_thing_more: [:foo_bar])
         end
 
         context 'complex (i.e. not primitive) data types (ex. middleware, please see bug #930)' do

data/spec/grape/util/strict_hash_configuration_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 module Grape
   module Util
     describe 'StrictHashConfiguration' do
       subject do
         Class.new do
-          include Grape::Util::StrictHashConfiguration.module(:config1, :config2, config3: [:config4], config5: [config6: [:config7, :config8]])
+          include Grape::Util::StrictHashConfiguration.module(:config1, :config2, config3: [:config4], config5: [config6: %i[config7 config8]])
         end
       end
 

data/spec/grape/validations/attributes_iterator_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Grape::Validations::AttributesIterator do

data/spec/grape/validations/instance_behaivour_spec.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe 'Validator with instance variables' do
   let(:validator_type) do
     Class.new(Grape::Validations::Base) do
       def validate_param!(_attr_name, _params)
-        if @instance_variable
-          raise Grape::Exceptions::Validation, params: ['params'],
-                                               message: 'This should never happen'
+        if instance_variable_defined?(:@instance_variable) && @instance_variable
+          raise Grape::Exceptions::Validation.new(params: ['params'],
+                                                  message: 'This should never happen')
         end
         @instance_variable = true
       end

data/spec/grape/validations/multiple_attributes_iterator_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Grape::Validations::MultipleAttributesIterator do
+  describe '#each' do
+    subject(:iterator) { described_class.new(validator, scope, params) }
+    let(:scope) { Grape::Validations::ParamsScope.new(api: Class.new(Grape::API)) }
+    let(:validator) { double(attrs: %i[first second third]) }
+
+    context 'when params is a hash' do
+      let(:params) do
+        { first: 'string', second: 'string' }
+      end
+
+      it 'yields the whole params hash and the skipped flag without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_with_args(params, false)
+      end
+    end
+
+    context 'when params is an array' do
+      let(:params) do
+        [{ first: 'string1', second: 'string1' }, { first: 'string2', second: 'string2' }]
+      end
+
+      it 'yields each element of the array without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args([params[0], false], [params[1], false])
+      end
+    end
+
+    context 'when params is empty optional placeholder' do
+      let(:params) do
+        [Grape::DSL::Parameters::EmptyOptionalValue, { first: 'string2', second: 'string2' }]
+      end
+
+      it 'yields each element of the array without the list of attrs' do
+        expect { |b| iterator.each(&b) }.to yield_successive_args([Grape::DSL::Parameters::EmptyOptionalValue, true], [params[1], false])
+      end
+    end
+  end
+end