sinatra-param 1.2.2 → 1.3.0

data/lib/sinatra/param.rb

@@ -14,7 +14,7 @@ module Sinatra
     def param(name, type, options = {})
       name = name.to_s
 
-      return unless params.member?(name) or present?(options[:default]) or options[:required]
+      return unless params.member?(name) or options[:default] or options[:required]
 
       begin
         params[name] = coerce(params[name], type, options)
@@ -36,20 +36,26 @@ module Sinatra
       end
     end
 
-    def one_of(*names)
-      count = 0
-      names.each do |name|
-        if params[name] and present?(params[name])
-          count += 1
-          next unless count > 1
+    def one_of(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      names = args.collect(&:to_s)
 
-          error = "Parameters #{names.join(', ')} are mutually exclusive"
-          if content_type and content_type.match(mime_type(:json))
-            error = {message: error}.to_json
-          end
+      return unless names.length > 2
 
-          halt 400, error
+      begin
+        validate_one_of!(params, names, options)
+      rescue InvalidParameterError => exception
+        if options[:raise] or (settings.raise_sinatra_param_exceptions rescue false)
+          exception.param, exception.options = names, options
+          raise exception
         end
+
+        error = "Parameters #{names.join(', ')} are mutually exclusive"
+        if content_type and content_type.match(mime_type(:json))
+          error = {message: error, errors: {names => exception.message}}.to_json
+        end
+
+        halt 400, error
       end
     end
 
@@ -112,6 +118,10 @@ module Sinatra
       end
     end
 
+    def validate_one_of!(params, names, options)
+      raise InvalidParameterError, "Parameters #{names.join(', ')} are mutually exclusive" if names.count{|name| present?(params[name])} > 1
+    end
+
     # ActiveSupport #present? and #blank? without patching Object
     def present?(object)
       !blank?(object)

data/lib/sinatra/param/version.rb

@@ -1,5 +1,5 @@
 module Sinatra
   module Param
-    VERSION = '1.2.2'
+    VERSION = '1.3.0'
   end
 end

data/spec/dummy/app.rb

@@ -80,6 +80,11 @@ class App < Sinatra::Base
     params.to_json
   end
 
+  get '/default/hash' do
+    param :attributes, Hash, default: {}
+    params.to_json
+  end
+
   get '/default/proc' do
     param :year, Integer, default: proc { 2014 }
     params.to_json
@@ -185,15 +190,27 @@ class App < Sinatra::Base
     param :b, String
     param :c, String
 
-    one_of(:a, :b, :c)
+    one_of :a, :b, :c
 
     {
       message: 'OK'
     }.to_json
   end
 
-  get '/raise' do
+  get '/raise/validation/required' do
     param :arg, String, required: true, raise: true
     params.to_json
   end
+
+  get '/raise/choice' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    one_of :a, :b, :c, raise: true
+
+    {
+      message: 'OK'
+    }.to_json
+  end
 end

data/spec/{parameter_sets_spec.rb → parameter_exclusivity_spec.rb}

@@ -8,26 +8,35 @@ describe 'Parameter Sets' do
         {b: 2, c: 3},
         {a: 1, b: 2, c: 3}
       ]
+
       params.each do |param|
         get('/choice', param) do |response|
-          response.status.should == 400
-          JSON.parse(response.body)['message'].should =~ /mutually exclusive/
+          expect(response.status).to eql 400
+          expect(JSON.parse(response.body)['message']).to match(/mutually exclusive/)
         end
       end
     end
 
-    it 'returns successfully for requests that only have one parameter' do
+    it 'returns successfully for requests that have one parameter' do
       params = [
         {a: 1},
         {b: 2},
         {c: 3}
       ]
+
       params.each do |param|
         get('/choice', param) do |response|
-          response.status.should == 200
-          JSON.parse(response.body)['message'].should =~ /OK/
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['message']).to match(/OK/)
         end
       end
     end
+
+    it 'returns successfully for requests that have no parameter' do
+      get('/choice') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['message']).to match(/OK/)
+      end
+    end
   end
 end

data/spec/parameter_raise_spec.rb

@@ -4,8 +4,15 @@ describe 'Exception' do
   describe 'raise' do
     it 'should raise error when option is specified' do
       expect {
-        get('/raise')
+        get('/raise/validation/required')
       }.to raise_error
     end
   end
+
+  it 'should raise error when more than one parameter is specified' do
+    params = {a: 1, b: 2, c: 3}
+    expect {
+      get('/raise/choice', params)
+    }.to raise_error
+  end
 end

data/spec/parameter_spec.rb

@@ -4,16 +4,16 @@ describe 'Parameter' do
   it 'only sets parameters present in request or with a default value' do
     get('/', a: 'a', b: 'b') do |response|
       response_body = JSON.parse(response.body)
-      response_body.member?('a').should eq true
-      response_body.member?('b').should eq true
-      response_body.member?('c').should eq true
-      response_body.member?('d').should eq false
+      expect(response_body).to be_member('a')
+      expect(response_body).to be_member('b')
+      expect(response_body).to be_member('c')
+      expect(response_body).to_not be_member('d')
     end
   end
 
   it 'stringifies parameters' do
     get('/keys/stringify', q: 'test') do |response|
-      response.body.should eq 'TEST'
+      expect(response.body).to eq 'TEST'
     end
   end
 end

data/spec/parameter_transformations_spec.rb

@@ -4,15 +4,22 @@ describe 'Parameter Transformations' do
   describe 'default' do
     it 'sets a default value when none is given' do
       get('/default') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['sort'].should == 'title'
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['sort']).to eql 'title'
+      end
+    end
+
+    it 'sets a default value from an empty hash' do
+      get('/default/hash') do |response|
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['attributes']).to eql Hash.new
       end
     end
 
     it 'sets a default value from a proc' do
       get('/default/proc') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['year'].should == 2014
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['year']).to eql 2014
       end
     end
   end
@@ -20,15 +27,15 @@ describe 'Parameter Transformations' do
   describe 'transform' do
     it 'transforms the input using to_proc' do
       get('/transform', order: 'asc') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['order'].should == 'ASC'
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['order']).to eql 'ASC'
       end
     end
 
     it 'skips transformations when the value is nil' do
       get('/transform/required') do |response|
-        response.status.should == 400
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: order')
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: order')
       end
     end
   end

data/spec/parameter_type_coercion_spec.rb

@@ -4,8 +4,8 @@ describe 'Parameter Types' do
   describe 'String' do
     it 'coerces strings' do
       get('/coerce/string', arg: '1234') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['arg'].should eq('1234')
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq('1234')
       end
     end
   end
@@ -13,15 +13,15 @@ describe 'Parameter Types' do
   describe 'Integer' do
     it 'coerces integers' do
       get('/coerce/integer', arg: '1234') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['arg'].should eq(1234)
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq(1234)
       end
     end
 
     it 'returns 400 on requests when integer is invalid' do
       get('/coerce/integer', arg: '123abc') do |response|
-        response.status.should == 400
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
   end
@@ -29,15 +29,15 @@ describe 'Parameter Types' do
   describe 'Float' do
     it 'coerces floats' do
       get('/coerce/float', arg: '1234') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['arg'].should eq(1234.0)
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq(1234.0)
       end
     end
 
     it 'returns 400 on requests when float is invalid' do
       get('/coerce/float', arg: '123abc') do |response|
-        response.status.should == 400
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
   end
@@ -45,15 +45,15 @@ describe 'Parameter Types' do
   describe 'Time' do
     it 'coerces time' do
       get('/coerce/time', arg: '20130117') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['arg'].should match(/2013-01-17 00:00:00/)
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to match(/2013-01-17 00:00:00/)
       end
     end
 
     it 'returns 400 on requests when time is invalid' do
       get('/coerce/time', arg: '123abc') do |response|
-        response.status.should == 400
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
   end
@@ -61,15 +61,15 @@ describe 'Parameter Types' do
   describe 'Date' do
     it 'coerces date' do
       get('/coerce/date', arg: '20130117') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['arg'].should eq('2013-01-17')
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq('2013-01-17')
       end
     end
 
     it 'returns 400 on requests when date is invalid' do
       get('/coerce/date', arg: 'abc') do |response|
-        response.status.should == 400
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
   end
@@ -77,15 +77,15 @@ describe 'Parameter Types' do
   describe 'DateTime' do
     it 'coerces datetimes' do
       get('/coerce/datetime', arg: '20130117') do |response|
-        response.status.should == 200
-        JSON.parse(response.body)['arg'].should eq('2013-01-17T00:00:00+00:00')
+        expect(response.status).to eql 200
+        expect(JSON.parse(response.body)['arg']).to eq('2013-01-17T00:00:00+00:00')
       end
     end
 
     it 'returns 400 on requests when datetime is invalid' do
       get('/coerce/datetime', arg: 'abc') do |response|
-        response.status.should == 400
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eql 400
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
   end
@@ -93,28 +93,28 @@ describe 'Parameter Types' do
   describe 'Array' do
     it 'coerces arrays' do
       get('/coerce/array', arg: '1,2,3,4,5') do |response|
-        response.status.should == 200
+        expect(response.status).to eql 200
         parsed_body = JSON.parse(response.body)
-        parsed_body['arg'].should be_an(Array)
-        parsed_body['arg'].should eq(%w(1 2 3 4 5))
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq(%w(1 2 3 4 5))
       end
     end
 
     it 'coerces arrays of size 1' do
       get('/coerce/array', arg: '1') do |response|
-        response.status.should == 200
+        expect(response.status).to eql 200
         parsed_body = JSON.parse(response.body)
-        parsed_body['arg'].should be_an(Array)
-        parsed_body['arg'].should eq(%w(1))
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq(%w(1))
       end
     end
 
     it 'coerces arrays with arg[] style' do
       get('/coerce/array', 'arg[]' => ['1','2','3','4','5']) do |response|
-        response.status.should == 200
+        expect(response.status).to eql 200
         parsed_body = JSON.parse(response.body)
-        parsed_body['arg'].should be_an(Array)
-        parsed_body['arg'].should eq(%w(1 2 3 4 5))
+        expect(parsed_body['arg']).to be_an(Array)
+        expect(parsed_body['arg']).to eq(%w(1 2 3 4 5))
       end
     end
   end
@@ -122,10 +122,10 @@ describe 'Parameter Types' do
   describe 'Hash' do
     it 'coerces hashes' do
       get('/coerce/hash', arg: 'a:b,c:d') do |response|
-        response.status.should == 200
+        expect(response.status).to eql 200
         parsed_body = JSON.parse(response.body)
-        parsed_body['arg'].should be_an(Hash)
-        parsed_body['arg'].should eq({ 'a' => 'b', 'c' => 'd'})
+        expect(parsed_body['arg']).to be_an(Hash)
+        expect(parsed_body['arg']).to eq({ 'a' => 'b', 'c' => 'd'})
       end
     end
   end
@@ -134,8 +134,8 @@ describe 'Parameter Types' do
     it 'coerces truthy booleans to true' do
       %w(1 true t yes y).each do |bool|
         get('/coerce/boolean', arg: bool) do |response|
-          response.status.should == 200
-          JSON.parse(response.body)['arg'].should be_true
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be true
         end
       end
     end
@@ -143,9 +143,9 @@ describe 'Parameter Types' do
     it 'coerces falsey booleans to false' do
       %w(0 false f no n).each do |bool|
         get('/coerce/boolean', arg: bool) do |response|
-          response.status.should == 200
-          JSON.parse(response.body)['arg'].should be_false
-          JSON.parse(response.body)['arg'].should_not be_nil
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be false
+          expect(JSON.parse(response.body)['arg']).to_not be_nil
         end
       end
     end
@@ -153,8 +153,8 @@ describe 'Parameter Types' do
     it 'coerces truthy booleans to true when default is false' do
       %w(1 true t yes y).each do |bool|
         get('/default/boolean/false', arg: bool) do |response|
-          response.status.should == 200
-          JSON.parse(response.body)['arg'].should be_true
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be true
         end
       end
     end
@@ -162,9 +162,9 @@ describe 'Parameter Types' do
     it 'coerces falsey booleans to false when default is true' do
       %w(0 false f no n).each do |bool|
         get('/default/boolean/true', arg: bool) do |response|
-          response.status.should == 200
-          JSON.parse(response.body)['arg'].should be_false
-          JSON.parse(response.body)['arg'].should_not be_nil
+          expect(response.status).to eql 200
+          expect(JSON.parse(response.body)['arg']).to be false
+          expect(JSON.parse(response.body)['arg']).to_not be_nil
         end
       end
     end

data/spec/parameter_validations_spec.rb

@@ -4,14 +4,14 @@ describe 'Parameter Validations' do
   describe 'required' do
     it 'returns 400 on requests without required fields' do
       get('/validation/required') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests when required field present' do
       get('/validation/required', arg: 'foo') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -19,35 +19,35 @@ describe 'Parameter Validations' do
   describe 'blank' do
     it 'returns 400 on requests when string is blank' do
       get('/validation/blank/string', arg: '') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 400 on requests when array is blank' do
       get('/validation/blank/array', arg: '') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 400 on requests when hash is blank' do
       get('/validation/blank/hash', arg: '') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 400 on requests when hash is blank' do
       get('/validation/blank/other', arg: '') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on request when blank is true' do
       get('/validation/nonblank/string', arg: '') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -55,19 +55,19 @@ describe 'Parameter Validations' do
   describe 'format' do
     it 'returns 200 on requests when value matches the param regex' do
       get('/validation/format/hello', arg: 'hello world') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
 
     it 'returns 400 on requests when value does not match the param regex' do
       get('/validation/format/hello', arg: 'world') do |response|
-        response.status.should eq(400)
+        expect(response.status).to eq(400)
       end
     end
 
     it 'returns 400 on requests when value is not a string' do
       get('/validation/format/9000', arg: 9000) do |response|
-        response.status.should eq(400)
+        expect(response.status).to eq(400)
       end
     end
   end
@@ -75,14 +75,14 @@ describe 'Parameter Validations' do
   describe 'is' do
     it 'returns 400 on requests when value is other than defined' do
       get('/validation/is', arg: 'bar') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a value is other than defined' do
       get('/validation/is', arg: 'foo') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -90,14 +90,14 @@ describe 'Parameter Validations' do
   describe 'in' do
     it 'returns 400 on requests with a value not in the set' do
       get('/validation/in', arg: 'MISC') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a value in the set' do
       get('/validation/in', arg: 'ASC') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -105,14 +105,14 @@ describe 'Parameter Validations' do
   describe 'within' do
     it 'returns 400 on requests with a value outside the range' do
       get('/validation/within', arg: 20) do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a value within the range' do
       get('/validation/within', arg: 5) do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -120,14 +120,14 @@ describe 'Parameter Validations' do
   describe 'range' do
     it 'returns 400 on requests with a value outside the range' do
       get('/validation/range', arg: 20) do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests within the range' do
       get('/validation/range', arg: 10) do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -135,14 +135,14 @@ describe 'Parameter Validations' do
   describe 'min' do
     it 'returns 400 on requests with a value smaller than min' do
       get('/validation/min', arg: 5) do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a value larger than min' do
       get('/validation/min', arg: 200) do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -150,14 +150,14 @@ describe 'Parameter Validations' do
   describe 'max' do
     it 'returns 400 on requests with a value larger than max' do
       get('/validation/max', arg: 100) do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a value smaller than max' do
       get('/validation/max', arg: 2) do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -165,14 +165,14 @@ describe 'Parameter Validations' do
   describe 'min_length' do
     it 'returns 400 on requests with a string shorter than min_length' do
       get('/validation/min_length', arg: 'hi') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a string longer than min_length' do
       get('/validation/max_length', arg: 'longer') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end
@@ -180,14 +180,14 @@ describe 'Parameter Validations' do
   describe 'max_length' do
     it 'returns 400 on requests with a string longer than max_length' do
       get('/validation/max_length', arg: 'reallylongstringlongerthanmax') do |response|
-        response.status.should eq(400)
-        JSON.parse(response.body)['message'].should eq('Invalid Parameter: arg')
+        expect(response.status).to eq(400)
+        expect(JSON.parse(response.body)['message']).to eq('Invalid Parameter: arg')
       end
     end
 
     it 'returns 200 on requests with a string shorter than max_length' do
       get('/validation/max_length', arg: 'short') do |response|
-        response.status.should eq(200)
+        expect(response.status).to eq(200)
       end
     end
   end