grape 1.0.1 → 1.0.2

data/spec/grape/util/stackable_values_spec.rb

@@ -9,7 +9,7 @@ module Grape
         it 'returns all key' 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 +19,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 +52,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 +71,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 +103,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

@@ -4,7 +4,7 @@ module Grape
     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/params_scope_spec.rb

@@ -74,7 +74,7 @@ describe Grape::Validations::ParamsScope do
   end
 
   context 'setting description' do
-    [:desc, :description].each do |description_type|
+    %i[desc description].each do |description_type|
       it "allows setting #{description_type}" do
         subject.params do
           requires :int, type: Integer, description_type => 'My very nice integer'
@@ -160,18 +160,18 @@ describe Grape::Validations::ParamsScope do
   context 'array without coerce type explicitly given' do
     it 'sets the type based on first element' do
       subject.params do
-        requires :periods, type: Array, values: -> { %w(day month) }
+        requires :periods, type: Array, values: -> { %w[day month] }
       end
       subject.get('/required') { 'required works' }
 
-      get '/required', periods: %w(day month)
+      get '/required', periods: %w[day month]
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('required works')
     end
 
     it 'fails to call API without Array type' do
       subject.params do
-        requires :periods, type: Array, values: -> { %w(day month) }
+        requires :periods, type: Array, values: -> { %w[day month] }
       end
       subject.get('/required') { 'required works' }
 
@@ -339,6 +339,18 @@ describe Grape::Validations::ParamsScope do
       get '/optional_type_array'
     end
 
+    it 'handles missing optional Array type' do
+      subject.params do
+        optional :a, type: Array do
+          requires :b
+        end
+      end
+      subject.get('/test') { declared(params).to_json }
+      get '/test'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('{"a":[]}')
+    end
+
     it 'errors with an unsupported type' do
       expect do
         subject.params do
@@ -456,7 +468,7 @@ describe Grape::Validations::ParamsScope do
 
     it 'does not validate nested requires when given is false' do
       subject.params do
-        requires :a, type: String, allow_blank: false, values: %w(x y z)
+        requires :a, type: String, allow_blank: false, values: %w[x y z]
         given a: ->(val) { val == 'x' } do
           requires :inner1, type: Hash, allow_blank: false do
             requires :foo, type: Integer, allow_blank: false
@@ -574,8 +586,8 @@ describe Grape::Validations::ParamsScope do
 
   context 'when validations are dependent on a parameter with specific value' do
     # build test cases from all combinations of declarations and options
-    a_decls = %i(optional requires)
-    a_options = [{}, { values: %w(x y z) }]
+    a_decls = %i[optional requires]
+    a_options = [{}, { values: %w[x y z] }]
     b_options = [{}, { type: String }, { allow_blank: false }, { type: String, allow_blank: false }]
     combinations = a_decls.product(a_options, b_options)
     combinations.each_with_index do |combination, i|

data/spec/grape/validations/validators/all_or_none_spec.rb

@@ -11,7 +11,7 @@ describe Grape::Validations::AllOrNoneOfValidator do
         def required?; end
       end
     end
-    let(:all_or_none_params) { [:beer, :wine, :grapefruit] }
+    let(:all_or_none_params) { %i[beer wine grapefruit] }
     let(:validator) { described_class.new(all_or_none_params, {}, false, scope.new) }
 
     context 'when all restricted params are present' do

data/spec/grape/validations/validators/at_least_one_of_spec.rb

@@ -11,7 +11,7 @@ describe Grape::Validations::AtLeastOneOfValidator do
         def required?; end
       end
     end
-    let(:at_least_one_of_params) { [:beer, :wine, :grapefruit] }
+    let(:at_least_one_of_params) { %i[beer wine grapefruit] }
     let(:validator) { described_class.new(at_least_one_of_params, {}, false, scope.new) }
 
     context 'when all restricted params are present' do

data/spec/grape/validations/validators/coerce_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'spec_helper'
 
 describe Grape::Validations::CoerceValidator do
@@ -136,11 +135,11 @@ describe Grape::Validations::CoerceValidator do
         'array int works'
       end
 
-      get 'array', ids: %w(1 2 az)
+      get 'array', ids: %w[1 2 az]
       expect(last_response.status).to eq(400)
       expect(last_response.body).to eq('ids is invalid')
 
-      get 'array', ids: %w(1 2 890)
+      get 'array', ids: %w[1 2 890]
       expect(last_response.status).to eq(200)
       expect(last_response.body).to eq('array int works')
     end
@@ -187,7 +186,7 @@ describe Grape::Validations::CoerceValidator do
             params[:arry][0].class
           end
 
-          get '/array', arry: %w(1 2 3)
+          get '/array', arry: %w[1 2 3]
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq(integer_class_name)
         end
@@ -225,6 +224,55 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('1')
         end
+
+        it 'Array of type implementing parse' do
+          subject.params do
+            requires :uri, type: Array[URI]
+          end
+          subject.get '/uri_array' do
+            params[:uri][0].class
+          end
+          get 'uri_array', uri: ['http://www.google.com']
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('URI::HTTP')
+        end
+
+        it 'Set of type implementing parse' do
+          subject.params do
+            requires :uri, type: Set[URI]
+          end
+          subject.get '/uri_array' do
+            "#{params[:uri].class},#{params[:uri].first.class},#{params[:uri].size}"
+          end
+          get 'uri_array', uri: Array.new(2) { 'http://www.example.com' }
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('Set,URI::HTTP,1')
+        end
+
+        it 'Array of class implementing parse and parsed?' do
+          class SecureURIOnly
+            def self.parse(value)
+              URI.parse(value)
+            end
+
+            def self.parsed?(value)
+              value.is_a? URI::HTTPS
+            end
+          end
+
+          subject.params do
+            requires :uri, type: Array[SecureURIOnly]
+          end
+          subject.get '/secure_uris' do
+            params[:uri].first.class
+          end
+          get 'secure_uris', uri: ['https://www.example.com']
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('URI::HTTPS')
+          get 'secure_uris', uri: ['https://www.example.com', 'http://www.example.com']
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('uri is invalid')
+        end
       end
 
       context 'Set' do
@@ -395,11 +443,11 @@ describe Grape::Validations::CoerceValidator do
 
         get '/ints', values: '1 2 3 4'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq(%w(1 2 3 4))
+        expect(JSON.parse(last_response.body)).to eq(%w[1 2 3 4])
 
         get '/ints', values: 'a b c d'
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq(%w(0 0 0 0))
+        expect(JSON.parse(last_response.body)).to eq(%w[0 0 0 0])
       end
 
       it 'parses parameters with Array[Integer] type' do
@@ -419,6 +467,23 @@ describe Grape::Validations::CoerceValidator do
         expect(JSON.parse(last_response.body)).to eq([0, 0, 0, 0])
       end
 
+      it 'parses parameters even if type is valid' do
+        subject.params do
+          requires :values, type: Array, coerce_with: ->(array) { array.map { |val| val.to_i + 1 } }
+        end
+        subject.get '/ints' do
+          params[:values]
+        end
+
+        get '/ints', values: [1, 2, 3, 4]
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eq([2, 3, 4, 5])
+
+        get '/ints', values: %w[a b c d]
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eq([1, 1, 1, 1])
+      end
+
       it 'uses parse where available' do
         subject.params do
           requires :ints, type: Array, coerce_with: JSON do
@@ -477,7 +542,7 @@ describe Grape::Validations::CoerceValidator do
     end
 
     context 'first-class JSON' do
-      it 'parses objects and arrays' do
+      it 'parses objects, hashes, and arrays' do
         subject.params do
           requires :splines, type: JSON do
             requires :x, type: Integer, values: [1, 2, 3]
@@ -499,17 +564,33 @@ describe Grape::Validations::CoerceValidator do
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('woof')
 
+        get '/', splines: { x: 1, ints: [1, 2, 3], obj: { y: 'woof' } }
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('woof')
+
         get '/', splines: '[{"x":2,"ints":[]},{"x":3,"ints":[4],"obj":{"y":"quack"}}]'
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('arrays work')
 
+        get '/', splines: [{ x: 2, ints: [] }, { x: 3, ints: [4], obj: { y: 'quack' } }]
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('arrays work')
+
         get '/', splines: '{"x":4,"ints":[2]}'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('splines[x] does not have a valid value')
 
+        get '/', splines: { x: 4, ints: [2] }
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
+
         get '/', splines: '[{"x":1,"ints":[]},{"x":4,"ints":[]}]'
         expect(last_response.status).to eq(400)
         expect(last_response.body).to eq('splines[x] does not have a valid value')
+
+        get '/', splines: [{ x: 1, ints: [] }, { x: 4, ints: [] }]
+        expect(last_response.status).to eq(400)
+        expect(last_response.body).to eq('splines[x] does not have a valid value')
       end
 
       it 'works when declared optional' do
@@ -660,7 +741,7 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('"one way"')
 
-          get '/', a: %w(the other)
+          get '/', a: %w[the other]
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('["the", "other"]')
 
@@ -678,7 +759,7 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('[1, 2, 3]')
 
-          get '/', b: %w(1 2 3)
+          get '/', b: %w[1 2 3]
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('[1, 2, 3]')
 
@@ -700,7 +781,7 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('"one"')
 
-          get '/', d: %w(1 two)
+          get '/', d: %w[1 two]
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('#<Set: {1, "two"}>')
         end
@@ -731,7 +812,7 @@ describe Grape::Validations::CoerceValidator do
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('"one way"')
 
-            get '/', a: %w(the other)
+            get '/', a: %w[the other]
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('#<Hashie::Array ["the", "other"]>')
 
@@ -749,7 +830,7 @@ describe Grape::Validations::CoerceValidator do
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('#<Hashie::Array [1, 2, 3]>')
 
-            get '/', b: %w(1 2 3)
+            get '/', b: %w[1 2 3]
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('#<Hashie::Array [1, 2, 3]>')
 
@@ -771,7 +852,7 @@ describe Grape::Validations::CoerceValidator do
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('"one"')
 
-            get '/', d: %w(1 two)
+            get '/', d: %w[1 two]
             expect(last_response.status).to eq(200)
             expect(last_response.body).to eq('#<Set: {1, "two"}>')
           end

data/spec/grape/validations/validators/default_spec.rb

@@ -75,6 +75,21 @@ describe Grape::Validations::DefaultValidator do
         get '/nested_optional_array' do
           { root: params[:root] }
         end
+
+        params do
+          requires :root, type: Hash do
+            optional :some_things, type: Array do
+              requires :foo
+              optional :options, type: Array do
+                optional :name, type: String
+                optional :value, type: String
+              end
+            end
+          end
+        end
+        get '/another_nested_optional_array' do
+          { root: params[:root] }
+        end
       end
     end
   end
@@ -99,6 +114,31 @@ describe Grape::Validations::DefaultValidator do
     expect(last_response.body).to eq({ root: params }.to_json)
   end
 
+  it 'does not allows faulty optional arrays' do
+    params = { some_things:
+                 [
+                   { foo: 'one', options: [{ name: 'wat', value: 'nope' }] },
+                   { foo: 'two', options: [{ name: 'wat' }] },
+                   { foo: 'three' }
+                 ] }
+    error = { error: 'root[some_things][1][options][0][value] is missing' }
+    get '/nested_optional_array', root: params
+    expect(last_response.status).to eq(400)
+    expect(last_response.body).to eq(error.to_json)
+  end
+
+  it 'allows optional arrays with optional params' do
+    params = { some_things:
+                 [
+                   { foo: 'one', options: [{ value: 'nope' }] },
+                   { foo: 'two', options: [{ name: 'wat' }] },
+                   { foo: 'three' }
+                 ] }
+    get '/another_nested_optional_array', root: params
+    expect(last_response.status).to eq(200)
+    expect(last_response.body).to eq({ root: params }.to_json)
+  end
+
   it 'set default value for optional param' do
     get('/')
     expect(last_response.status).to eq(200)

data/spec/grape/validations/validators/exactly_one_of_spec.rb

@@ -11,7 +11,7 @@ describe Grape::Validations::ExactlyOneOfValidator do
         def required?; end
       end
     end
-    let(:exactly_one_of_params) { [:beer, :wine, :grapefruit] }
+    let(:exactly_one_of_params) { %i[beer wine grapefruit] }
     let(:validator) { described_class.new(exactly_one_of_params, {}, false, scope.new) }
 
     context 'when all restricted params are present' do