grape 0.6.0 → 0.6.1

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

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Param do
 
-  let(:app) { lambda{|env| [200, env, env['api.version']]} }
+  let(:app) { lambda { |env| [200, env, env['api.version']] } }
   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"}})
+    env = Rack::MockRequest.env_for("/awesome", { params: { "apiver" => "v1" } })
     subject.call(env)[1]["api.version"].should == 'v1'
   end
 
-  it 'cuts (only) the version out of the params', :focus => true do
-    env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1", "other_param" => "5"}})
+  it 'cuts (only) the version out of the params', focus: true do
+    env = Rack::MockRequest.env_for("/awesome", { params: { "apiver" => "v1", "other_param" => "5" } })
     subject.call(env)[1]['rack.request.query_hash']["apiver"].should be_nil
     subject.call(env)[1]['rack.request.query_hash']["other_param"].should == "5"
   end
@@ -22,37 +22,36 @@ describe Grape::Middleware::Versioner::Param do
   end
 
   context 'with specified parameter name' do
-    before{ @options = {:parameter => ['v']}}
+    before { @options = { parameter: 'v' } }
     it 'sets the API version based on the custom parameter name' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"v" => "v1"}})
-      s = subject.call(env)[1]["api.version"] == "v1"
+      env = Rack::MockRequest.env_for("/awesome", { params: { "v" => "v1" } })
+      subject.call(env)[1]["api.version"].should == "v1"
     end
     it 'does not set the API version based on the default param' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1"}})
-      s = subject.call(env)[1]["api.version"] == nil
+      env = Rack::MockRequest.env_for("/awesome", { params: { "apiver" => "v1" } })
+      subject.call(env)[1]["api.version"].should be_nil
     end
   end
 
   context 'with specified versions' do
-    before{ @options = {:versions => ['v1', 'v2']}}
+    before { @options = { versions: ['v1', 'v2'] } }
     it 'throws an error if a non-allowed version is specified' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v3"}})
-      catch(:error){subject.call(env)}[:status].should == 404
+      env = Rack::MockRequest.env_for("/awesome", { params: { "apiver" => "v3" } })
+      catch(:error) { subject.call(env) }[:status].should == 404
     end
-
     it 'allows versions that have been specified' do
-      env = Rack::MockRequest.env_for("/awesome", {:params => {"apiver" => "v1"}})
+      env = Rack::MockRequest.env_for("/awesome", { params: { "apiver" => "v1" } })
       subject.call(env)[1]["api.version"].should == 'v1'
     end
   end
 
   it 'returns a 200 when no version is set (matches the first version found)' do
     @options = {
-      :versions => ['v1'],
-      :version_options => {:using => :header}
+      versions: ['v1'],
+      version_options: { using: :header }
     }
-    env = Rack::MockRequest.env_for("/awesome", {:params => {}})
+    env = Rack::MockRequest.env_for("/awesome", { params: {} })
     subject.call(env).first.should == 200
   end
 
-end
+end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Grape::Middleware::Versioner::Path do
-  let(:app) { lambda{|env| [200, env, env['api.version']]} }
+  let(:app) { lambda { |env| [200, env, env['api.version']] } }
   subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) }
 
   it 'sets the API version based on the first path' do
@@ -17,7 +17,7 @@ describe Grape::Middleware::Versioner::Path do
   end
 
   context 'with a pattern' do
-    before { @options = {:pattern => /v./i} }
+    before { @options = { pattern: /v./i } }
     it 'sets the version if it matches' do
       subject.call('PATH_INFO' => '/v1/awesome').last.should == 'v1'
     end
@@ -27,12 +27,12 @@ describe Grape::Middleware::Versioner::Path do
     end
   end
 
-  [ [ 'v1', 'v2'], [ :v1, :v2 ], [ :v1, 'v2' ], [ 'v1', :v2 ] ].each do |versions|
+  [['v1', 'v2'], [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
     context 'with specified versions as #{versions}' do
-      before { @options = { :versions => versions } }
+      before { @options = { versions: versions } }
 
       it 'throws an error if a non-allowed version is specified' do
-        catch(:error){subject.call('PATH_INFO' => '/v3/awesome')}[:status].should == 404
+        catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status].should == 404
       end
 
       it 'allows versions that have been specified' do
@@ -41,4 +41,4 @@ describe Grape::Middleware::Versioner::Path do
     end
   end
 
-end
+end

data/spec/grape/middleware/versioner_spec.rb

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

data/spec/grape/util/hash_stack_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe Grape::Util::HashStack do
-  let(:klass){ Grape::Util::HashStack }
 
   describe '#get' do
     it 'finds the first available key' do
       subject[:abc] = 123
-      subject.push(:abc => 345)
+      subject.push(abc: 345)
       subject.get(:abc).should == 345
     end
 
@@ -32,9 +31,9 @@ describe Grape::Util::HashStack do
     end
 
     it 'merges a hash that is passed' do
-      subject[:abc] = {:foo => 'bar'}
-      subject.imbue(:abc, {:baz => 'wich'})
-      subject[:abc].should == {:foo => 'bar', :baz => 'wich'}
+      subject[:abc] = { foo: 'bar' }
+      subject.imbue(:abc, { baz: 'wich' })
+      subject[:abc].should == { foo: 'bar', baz: 'wich' }
     end
 
     it 'sets the value if not a hash or array' do
@@ -45,86 +44,86 @@ describe Grape::Util::HashStack do
     it 'is able to imbue an array without explicit setting' do
       subject.imbue(:arr, [1])
       subject.imbue(:arr, [2])
-      subject[:arr].should == [1,2]
+      subject[:arr].should == [1, 2]
     end
 
     it 'is able to imbue a hash without explicit setting' do
-      subject.imbue(:hash, :foo => 'bar')
-      subject.imbue(:hash, :baz => 'wich')
-      subject[:hash].should == {:foo => 'bar', :baz => 'wich'}
+      subject.imbue(:hash, foo: 'bar')
+      subject.imbue(:hash, baz: 'wich')
+      subject[:hash].should == { foo: 'bar', baz: 'wich' }
     end
   end
 
   describe '#push' do
     it 'returns a HashStack' do
-      subject.push(klass.new).should be_kind_of(klass)
+      subject.push(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
     end
 
     it 'places the passed value on the top of the stack' do
-      subject.push(:abc => 123)
-      subject.stack.should == [{}, {:abc => 123}]
+      subject.push(abc: 123)
+      subject.stack.should == [{}, { abc: 123 }]
     end
 
     it 'pushes an empty hash by default' do
       subject[:abc] = 123
       subject.push
-      subject.stack.should == [{:abc => 123}, {}]
+      subject.stack.should == [{ abc: 123 }, {}]
     end
   end
 
   describe '#pop' do
     it 'removes and return the top frame' do
-      subject.push(:abc => 123)
-      subject.pop.should == {:abc => 123}
+      subject.push(abc: 123)
+      subject.pop.should == { abc: 123 }
       subject.stack.size.should == 1
     end
   end
 
   describe '#peek' do
     it 'returns the top frame without removing it' do
-      subject.push(:abc => 123)
-      subject.peek.should == {:abc => 123}
+      subject.push(abc: 123)
+      subject.peek.should == { abc: 123 }
       subject.stack.size.should == 2
     end
   end
 
   describe '#prepend' do
     it 'returns a HashStack' do
-      subject.prepend(klass.new).should be_kind_of(klass)
+      subject.prepend(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
     end
 
     it "prepends a HashStack's stack onto its own stack" do
-      other = klass.new.push(:abc => 123)
-      subject.prepend(other).stack.should == [{}, {:abc => 123}, {}]
+      other = Grape::Util::HashStack.new.push(abc: 123)
+      subject.prepend(other).stack.should == [{}, { abc: 123 }, {}]
     end
   end
 
   describe '#concat' do
     it 'returns a HashStack' do
-      subject.concat(klass.new).should be_kind_of(klass)
+      subject.concat(Grape::Util::HashStack.new).should be_kind_of(Grape::Util::HashStack)
     end
 
     it "appends a HashStack's stack onto its own stack" do
-      other = klass.new.push(:abc => 123)
-      subject.concat(other).stack.should == [{}, {}, {:abc => 123}]
+      other = Grape::Util::HashStack.new.push(abc: 123)
+      subject.concat(other).stack.should == [{}, {}, { abc: 123 }]
     end
   end
 
   describe '#update' do
     it 'merges! into the top frame' do
-      subject.update(:abc => 123)
-      subject.stack.should == [{:abc => 123}]
+      subject.update(abc: 123)
+      subject.stack.should == [{ abc: 123 }]
     end
 
     it 'returns a HashStack' do
-      subject.update(:abc => 123).should be_kind_of(klass)
+      subject.update(abc: 123).should be_kind_of(Grape::Util::HashStack)
     end
   end
 
   describe '#clone' do
     it 'performs a deep copy' do
       subject[:abc] = 123
-      subject.push :def => 234
+      subject.push def: 234
       clone = subject.clone
       clone[:def] = 345
       subject[:def].should == 234

data/spec/grape/validations/coerce_spec.rb

@@ -2,8 +2,13 @@
 require 'spec_helper'
 
 describe Grape::Validations::CoerceValidator do
-  subject { Class.new(Grape::API) }
-  def app; subject end
+  subject do
+    Class.new(Grape::API)
+  end
+
+  def app
+    subject
+  end
 
   describe 'coerce' do
 
@@ -14,23 +19,23 @@ describe Grape::Validations::CoerceValidator do
       end
 
       it "i18n error on malformed input" do
-        I18n.load_path << File.expand_path('../zh-CN.yml',__FILE__)
+        I18n.load_path << File.expand_path('../zh-CN.yml', __FILE__)
         I18n.reload!
-        I18n.locale = :'zh-CN'
-        subject.params { requires :age, :type => Integer }
+        I18n.locale = 'zh-CN'.to_sym
+        subject.params { requires :age, type: Integer }
         subject.get '/single' do 'int works'; end
 
-        get '/single', :age => '43a'
+        get '/single', age: '43a'
         last_response.status.should == 400
         last_response.body.should == '年龄格式不正确'
       end
 
       it 'gives an english fallback error when default locale message is blank' do
-        I18n.locale = :'pt-BR'
-        subject.params { requires :age, :type => Integer }
+        I18n.locale = 'pt-BR'.to_sym
+        subject.params { requires :age, type: Integer }
         subject.get '/single' do 'int works'; end
 
-        get '/single', :age => '43a'
+        get '/single', age: '43a'
         last_response.status.should == 400
         last_response.body.should == 'age is invalid'
       end
@@ -38,27 +43,27 @@ describe Grape::Validations::CoerceValidator do
     end
 
     it 'error on malformed input' do
-      subject.params { requires :int, :type => Integer }
+      subject.params { requires :int, type: Integer }
       subject.get '/single' do 'int works'; end
 
-      get '/single', :int => '43a'
+      get '/single', int: '43a'
       last_response.status.should == 400
       last_response.body.should == 'int is invalid'
 
-      get '/single', :int => '43'
+      get '/single', int: '43'
       last_response.status.should == 200
       last_response.body.should == 'int works'
     end
 
     it 'error on malformed input (Array)' do
-      subject.params { requires :ids, :type => Array[Integer] }
+      subject.params { requires :ids, type: Array[Integer] }
       subject.get '/array' do 'array int works'; end
 
-      get 'array', { :ids => ['1', '2', 'az'] }
+      get 'array', { ids: ['1', '2', 'az'] }
       last_response.status.should == 400
       last_response.body.should == 'ids is invalid'
 
-      get 'array', { :ids => ['1', '2', '890'] }
+      get 'array', { ids: ['1', '2', '890'] }
       last_response.status.should == 200
       last_response.body.should == 'array int works'
     end
@@ -66,21 +71,21 @@ describe Grape::Validations::CoerceValidator do
     context 'complex objects' do
       module CoerceValidatorSpec
         class User
-          include Virtus
+          include Virtus.model
           attribute :id, Integer
           attribute :name, String
         end
       end
 
       it 'error on malformed input for complex objects' do
-        subject.params { requires :user, :type => CoerceValidatorSpec::User }
+        subject.params { requires :user, type: CoerceValidatorSpec::User }
         subject.get '/user' do 'complex works'; end
 
-        get '/user', :user => "32"
+        get '/user', user: "32"
         last_response.status.should == 400
         last_response.body.should == 'user is invalid'
 
-        get '/user', :user => { :id => 32, :name => 'Bob' }
+        get '/user', user: { id: 32, name: 'Bob' }
         last_response.status.should == 200
         last_response.body.should == 'complex works'
       end
@@ -88,58 +93,58 @@ describe Grape::Validations::CoerceValidator do
 
     context 'coerces' do
       it 'Integer' do
-        subject.params { requires :int, :coerce => Integer }
+        subject.params { requires :int, coerce: Integer }
         subject.get '/int' do params[:int].class; end
 
-        get '/int', { :int => "45" }
+        get '/int', { int: "45" }
         last_response.status.should == 200
         last_response.body.should == 'Fixnum'
       end
 
       it 'Array of Integers' do
-        subject.params { requires :arry, :coerce => Array[Integer] }
+        subject.params { requires :arry, coerce: Array[Integer] }
         subject.get '/array' do params[:arry][0].class; end
 
-        get '/array', { :arry => [ '1', '2', '3' ] }
+        get '/array', { arry: ['1', '2', '3'] }
         last_response.status.should == 200
         last_response.body.should == 'Fixnum'
       end
 
       it 'Array of Bools' do
-        subject.params { requires :arry, :coerce => Array[Virtus::Attribute::Boolean] }
+        subject.params { requires :arry, coerce: Array[Virtus::Attribute::Boolean] }
         subject.get '/array' do params[:arry][0].class; end
 
-        get 'array', { :arry => [1, 0] }
+        get 'array', { arry: [1, 0] }
         last_response.status.should == 200
         last_response.body.should == 'TrueClass'
       end
 
       it 'Bool' do
-        subject.params { requires :bool, :coerce => Virtus::Attribute::Boolean }
+        subject.params { requires :bool, coerce: Virtus::Attribute::Boolean }
         subject.get '/bool' do params[:bool].class; end
 
-        get '/bool', { :bool => 1 }
+        get '/bool', { bool: 1 }
         last_response.status.should == 200
         last_response.body.should == 'TrueClass'
 
-        get '/bool', { :bool => 0 }
+        get '/bool', { bool: 0 }
         last_response.status.should == 200
         last_response.body.should == 'FalseClass'
 
-        get '/bool', { :bool => 'false' }
+        get '/bool', { bool: 'false' }
         last_response.status.should == 200
         last_response.body.should == 'FalseClass'
 
-        get '/bool', { :bool => 'true' }
+        get '/bool', { bool: 'true' }
         last_response.status.should == 200
         last_response.body.should == 'TrueClass'
       end
 
       it 'file' do
-        subject.params { requires :file, :coerce => Rack::Multipart::UploadedFile }
+        subject.params { requires :file, coerce: Rack::Multipart::UploadedFile }
         subject.post '/upload' do params[:file].filename; end
 
-        post '/upload', { :file => Rack::Test::UploadedFile.new(__FILE__) }
+        post '/upload', { file: Rack::Test::UploadedFile.new(__FILE__) }
         last_response.status.should == 201
         last_response.body.should == File.basename(__FILE__).to_s
       end
@@ -147,12 +152,12 @@ describe Grape::Validations::CoerceValidator do
       it 'Nests integers' do
         subject.params do
           group :integers do
-            requires :int, :coerce => Integer
+            requires :int, coerce: Integer
           end
         end
         subject.get '/int' do params[:integers][:int].class; end
 
-        get '/int', { :integers => { :int => "45" } }
+        get '/int', { integers: { int: "45" } }
         last_response.status.should == 200
         last_response.body.should == 'Fixnum'
       end

data/spec/grape/validations/default_spec.rb

@@ -9,28 +9,28 @@ describe Grape::Validations::DefaultValidator do
 
         params do
           optional :id
-          optional :type, :default => 'default-type'
+          optional :type, default: 'default-type'
         end
         get '/' do
-          { :id => params[:id], :type => params[:type] }
+          { id: params[:id], type: params[:type] }
         end
 
         params do
-          optional :type1, :default => 'default-type1'
-          optional :type2, :default => 'default-type2'
+          optional :type1, default: 'default-type1'
+          optional :type2, default: 'default-type2'
         end
         get '/user' do
-          { :type1 => params[:type1], :type2 => params[:type2] }
+          { type1: params[:type1], type2: params[:type2] }
         end
 
         params do
           requires :id
-          optional :type1, :default => 'default-type1'
-          optional :type2, :default => 'default-type2'
+          optional :type1, default: 'default-type1'
+          optional :type2, default: 'default-type2'
         end
 
         get '/message' do
-          { :id => params[:id], :type1 => params[:type1], :type2 => params[:type2] }
+          { id: params[:id], type1: params[:type1], type2: params[:type2] }
         end
       end
     end
@@ -43,25 +43,24 @@ describe Grape::Validations::DefaultValidator do
   it 'set default value for optional param' do
     get("/")
     last_response.status.should == 200
-    last_response.body.should == { :id => nil, :type => 'default-type' }.to_json
+    last_response.body.should == { id: nil, type: 'default-type' }.to_json
   end
 
   it 'set default values for optional params' do
     get("/user")
     last_response.status.should == 200
-    last_response.body.should == { :type1 => 'default-type1', :type2 => 'default-type2' }.to_json
+    last_response.body.should == { type1: 'default-type1', type2: 'default-type2' }.to_json
   end
 
   it 'set default values for missing params in the request' do
     get("/user?type2=value2")
     last_response.status.should == 200
-    last_response.body.should == { :type1 => 'default-type1', :type2 => 'value2' }.to_json
+    last_response.body.should == { type1: 'default-type1', type2: 'value2' }.to_json
   end
 
   it 'set default values for optional params and allow to use required fields in the same time' do
     get("/message?id=1")
     last_response.status.should == 200
-    last_response.body.should == { :id => '1', :type1 => 'default-type1', :type2 => 'default-type2' }.to_json
+    last_response.body.should == { id: '1', type1: 'default-type1', type2: 'default-type2' }.to_json
   end
 end
-