haveapi 0.19.3 → 0.21.0

data/spec/params_spec.rb

@@ -6,7 +6,6 @@ describe HaveAPI::Params do
     end
 
     class Index < HaveAPI::Actions::Default::Index
-
     end
 
     class Show < HaveAPI::Actions::Default::Show
@@ -16,17 +15,16 @@ describe HaveAPI::Params do
     end
 
     class Create < HaveAPI::Actions::Default::Create
-
     end
   end
 
   it 'executes all blocks' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { string :param1 }
-    p.add_block Proc.new { string :param2 }
-    p.add_block Proc.new { string :param3 }
+    p.add_block proc { string :param1 }
+    p.add_block proc { string :param2 }
+    p.add_block proc { string :param3 }
     p.exec
-    expect(p.params.map { |p| p.name }).to contain_exactly(*%i(param1 param2 param3))
+    expect(p.params.map(&:name)).to contain_exactly(*%i[param1 param2 param3])
   end
 
   it 'returns deduced singular namespace' do
@@ -48,43 +46,43 @@ describe HaveAPI::Params do
 
   it 'uses params from parent resource' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { use :all }
+    p.add_block proc { use :all }
     p.exec
-    expect(p.params.map { |p| p.name }).to contain_exactly(*%i(res_param1 res_param2))
+    expect(p.params.map(&:name)).to contain_exactly(*%i[res_param1 res_param2])
   end
 
   it 'has param requires' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { requires :p_required }
+    p.add_block proc { requires :p_required }
     p.exec
     expect(p.params.first.required?).to be true
   end
 
   it 'has param optional' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { optional :p_optional }
+    p.add_block proc { optional :p_optional }
     p.exec
     expect(p.params.first.required?).to be false
   end
 
   it 'has param string' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { string :p_string }
+    p.add_block proc { string :p_string }
     p.exec
     expect(p.params.first.type).to eq(String)
   end
 
   it 'has param text' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { text :p_text }
+    p.add_block proc { text :p_text }
     p.exec
     expect(p.params.first.type).to eq(Text)
   end
 
-  %i(id integer foreign_key).each do |type|
+  %i[id integer foreign_key].each do |type|
     it "has param #{type}" do
       p = HaveAPI::Params.new(:input, MyResource::Index)
-      p.add_block Proc.new { send(type, :"p_#{type}") }
+      p.add_block proc { send(type, :"p_#{type}") }
       p.exec
       expect(p.params.first.type).to eq(Integer)
     end
@@ -92,42 +90,42 @@ describe HaveAPI::Params do
 
   it 'has param float' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { float :p_float }
+    p.add_block proc { float :p_float }
     p.exec
     expect(p.params.first.type).to eq(Float)
   end
 
   it 'has param bool' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { bool :p_bool }
+    p.add_block proc { bool :p_bool }
     p.exec
     expect(p.params.first.type).to eq(Boolean)
   end
 
   it 'has param datetime' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { datetime :p_datetime }
+    p.add_block proc { datetime :p_datetime }
     p.exec
     expect(p.params.first.type).to eq(Datetime)
   end
 
   it 'has param param' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { param :p_param, type: Integer }
+    p.add_block proc { param :p_param, type: Integer }
     p.exec
     expect(p.params.first.type).to eq(Integer)
   end
 
   it 'has param resource' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block Proc.new { resource MyResource }
+    p.add_block proc { resource MyResource }
     p.exec
     expect(p.params.first).to be_an_instance_of(HaveAPI::Parameters::Resource)
   end
 
   it 'patches params' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block(Proc.new do
+    p.add_block(proc do
       string :param1, label: 'Param 1'
       string :param2, label: 'Param 2', desc: 'Implicit description'
     end)
@@ -140,7 +138,7 @@ describe HaveAPI::Params do
 
   it 'validates upon build' do
     p = HaveAPI::Params.new(:output, MyResource::Index)
-    p.add_block Proc.new { resource MyResource }
+    p.add_block proc { resource MyResource }
     p.exec
     expect(p.params.first).to be_an_instance_of(HaveAPI::Parameters::Resource)
     expect { p.validate_build }.to raise_error(RuntimeError)
@@ -148,7 +146,7 @@ describe HaveAPI::Params do
 
   it 'accepts valid input layout' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block(Proc.new do
+    p.add_block(proc do
       string :param1, required: true
       string :param2
     end)
@@ -163,7 +161,7 @@ describe HaveAPI::Params do
 
   it 'rejects invalid input layout' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block(Proc.new do
+    p.add_block(proc do
       string :param1, required: true
       string :param2
     end)
@@ -178,7 +176,7 @@ describe HaveAPI::Params do
 
   it 'indexes parameters by name' do
     p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block(Proc.new do
+    p.add_block(proc do
       string :param1
       string :param2
     end)

data/spec/resource_spec.rb

@@ -1,6 +1,5 @@
 describe HaveAPI::Resource do
   class PluralTest < HaveAPI::Resource
-    
   end
 
   class SingularTest < HaveAPI::Resource
@@ -21,14 +20,13 @@ describe HaveAPI::Resource do
   end
 
   class ComplexTest < HaveAPI::Resource
-    class Index < HaveAPI::Actions::Default::Index ; end
-    class Show < HaveAPI::Actions::Default::Show ; end
-    class Create < HaveAPI::Actions::Default::Create ; end
-    class Dummy ; end
+    class Index < HaveAPI::Actions::Default::Index; end
+    class Show < HaveAPI::Actions::Default::Show; end
+    class Create < HaveAPI::Actions::Default::Create; end
 
     class SubResource < HaveAPI::Resource
-      class Index < HaveAPI::Actions::Default::Index ; end
-      class Show < HaveAPI::Actions::Default::Show ; end
+      class Index < HaveAPI::Actions::Default::Index; end
+      class Show < HaveAPI::Actions::Default::Show; end
     end
   end
 

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@ require_rel '../lib/haveapi/spec/*.rb'
 module HaveAPI
   module Spec
     module API
-
     end
   end
 end

data/spec/validators/acceptance_spec.rb

@@ -4,7 +4,7 @@ describe HaveAPI::Validators::Acceptance do
       expect(@v.valid?('foo')).to be true
     end
 
-    it "rejects incorrect value" do
+    it 'rejects incorrect value' do
       expect(@v.valid?('bar')).to be false
     end
   end

data/spec/validators/confirmation_spec.rb

@@ -1,11 +1,11 @@
 describe HaveAPI::Validators::Confirmation do
   shared_examples(:all) do
     it 'accepts the same value' do
-      expect(@v.validate('foo', {other_param: 'foo'})).to be true
+      expect(@v.validate('foo', { other_param: 'foo' })).to be true
     end
 
-    it "rejects a different value" do
-      expect(@v.validate('bar', {other_param: 'foo'})).to be false
+    it 'rejects a different value' do
+      expect(@v.validate('bar', { other_param: 'foo' })).to be false
     end
   end
 
@@ -36,11 +36,11 @@ describe HaveAPI::Validators::Confirmation do
     end
 
     it 'rejects the same value' do
-      expect(@v.validate('foo', {other_param: 'foo'})).to be false
+      expect(@v.validate('foo', { other_param: 'foo' })).to be false
     end
 
     it 'accepts a different value' do
-      expect(@v.validate('bar', {other_param: 'foo'})).to be true
+      expect(@v.validate('bar', { other_param: 'foo' })).to be true
     end
   end
 end

data/spec/validators/exclusion_spec.rb

@@ -6,7 +6,7 @@ describe HaveAPI::Validators::Exclusion do
       expect(@v.valid?('three')).to be false
     end
 
-    it "accepts an unlisted value" do
+    it 'accepts an unlisted value' do
       expect(@v.valid?('zero')).to be true
       expect(@v.valid?('four')).to be true
     end
@@ -14,7 +14,7 @@ describe HaveAPI::Validators::Exclusion do
 
   context 'short form' do
     before(:each) do
-      @v = HaveAPI::Validators::Exclusion.new(:exclude, %w(one two three))
+      @v = HaveAPI::Validators::Exclusion.new(:exclude, %w[one two three])
     end
 
     include_examples :all
@@ -23,7 +23,7 @@ describe HaveAPI::Validators::Exclusion do
   context 'full form' do
     before(:each) do
       @v = HaveAPI::Validators::Exclusion.new(:exclude, {
-        values: %w(one two three)
+        values: %w[one two three]
       })
     end
 

data/spec/validators/format_spec.rb

@@ -5,7 +5,7 @@ describe HaveAPI::Validators::Format do
       expect(@v.valid?('aacacb')).to be true
     end
 
-    it "rejects a value that does not match the regexp" do
+    it 'rejects a value that does not match the regexp' do
       expect(@v.valid?('aacac')).to be false
       expect(@v.valid?('bacacb')).to be false
       expect(@v.valid?('b')).to be false
@@ -45,7 +45,7 @@ describe HaveAPI::Validators::Format do
       expect(@v.valid?('aacacb')).to be false
     end
 
-    it "accepts a value if it does not match the regexp" do
+    it 'accepts a value if it does not match the regexp' do
       expect(@v.valid?('aacac')).to be true
       expect(@v.valid?('bacacb')).to be true
       expect(@v.valid?('b')).to be true

data/spec/validators/inclusion_spec.rb

@@ -6,14 +6,14 @@ describe HaveAPI::Validators::Inclusion do
       expect(@v.valid?('three')).to be true
     end
 
-    it "rejects an unlisted value" do
+    it 'rejects an unlisted value' do
       expect(@v.valid?('zero')).to be false
       expect(@v.valid?('four')).to be false
     end
   end
 
   [
-    %w(one two three),
+    %w[one two three],
     {
       one: 'Fancy one',
       two: 'Fancy two',
@@ -23,7 +23,7 @@ describe HaveAPI::Validators::Inclusion do
     context "with include as a '#{include.class}'" do
       context 'short form' do
         before(:each) do
-          @v = HaveAPI::Validators::Inclusion.new(:include, %w(one two three))
+          @v = HaveAPI::Validators::Inclusion.new(:include, %w[one two three])
         end
 
         include_examples :all
@@ -32,7 +32,7 @@ describe HaveAPI::Validators::Inclusion do
       context 'full form' do
         before(:each) do
           @v = HaveAPI::Validators::Inclusion.new(:include, {
-            values: %w(one two three)
+            values: %w[one two three]
           })
         end
 

data/spec/validators/length_spec.rb

@@ -1,10 +1,10 @@
 describe HaveAPI::Validators::Length do
   it 'does not allow to mix min/max with equals' do
     expect do
-      HaveAPI::Validators::Length.new(:length, {min: 33, equals: 42})
+      HaveAPI::Validators::Length.new(:length, { min: 33, equals: 42 })
     end.to raise_error(RuntimeError)
   end
-  
+
   it 'requires one of min, max or equals' do
     expect do
       HaveAPI::Validators::Length.new(:length, {})
@@ -12,34 +12,34 @@ describe HaveAPI::Validators::Length do
   end
 
   it 'checks minimum' do
-    v = HaveAPI::Validators::Length.new(:length, {min: 2})
-    expect(v.valid?('a'*1)).to be false
-    expect(v.valid?('a'*2)).to be true
-    expect(v.valid?('a'*33)).to be true
+    v = HaveAPI::Validators::Length.new(:length, { min: 2 })
+    expect(v.valid?('a' * 1)).to be false
+    expect(v.valid?('a' * 2)).to be true
+    expect(v.valid?('a' * 33)).to be true
   end
-  
+
   it 'checks maximum' do
-    v = HaveAPI::Validators::Length.new(:length, {max: 5})
-    expect(v.valid?('a'*4)).to be true
-    expect(v.valid?('a'*5)).to be true
-    expect(v.valid?('a'*6)).to be false
-    expect(v.valid?('a'*11)).to be false
+    v = HaveAPI::Validators::Length.new(:length, { max: 5 })
+    expect(v.valid?('a' * 4)).to be true
+    expect(v.valid?('a' * 5)).to be true
+    expect(v.valid?('a' * 6)).to be false
+    expect(v.valid?('a' * 11)).to be false
   end
 
   it 'checks range' do
-    v = HaveAPI::Validators::Length.new(:length, {min: 3, max: 6})
-    expect(v.valid?('a'*2)).to be false
-    expect(v.valid?('a'*3)).to be true
-    expect(v.valid?('a'*4)).to be true
-    expect(v.valid?('a'*5)).to be true
-    expect(v.valid?('a'*6)).to be true
-    expect(v.valid?('a'*7)).to be false
+    v = HaveAPI::Validators::Length.new(:length, { min: 3, max: 6 })
+    expect(v.valid?('a' * 2)).to be false
+    expect(v.valid?('a' * 3)).to be true
+    expect(v.valid?('a' * 4)).to be true
+    expect(v.valid?('a' * 5)).to be true
+    expect(v.valid?('a' * 6)).to be true
+    expect(v.valid?('a' * 7)).to be false
   end
 
   it 'check a specific length' do
-    v = HaveAPI::Validators::Length.new(:length, {equals: 4})
-    expect(v.valid?('a'*2)).to be false
-    expect(v.valid?('a'*4)).to be true
-    expect(v.valid?('a'*5)).to be false
+    v = HaveAPI::Validators::Length.new(:length, { equals: 4 })
+    expect(v.valid?('a' * 2)).to be false
+    expect(v.valid?('a' * 4)).to be true
+    expect(v.valid?('a' * 5)).to be false
   end
 end

data/spec/validators/numericality_spec.rb

@@ -1,19 +1,19 @@
 describe HaveAPI::Validators::Numericality do
   it 'cannot be both even and odd at the same time' do
     expect do
-      HaveAPI::Validators::Numericality.new(:number, {odd: true, even: true})
+      HaveAPI::Validators::Numericality.new(:number, { odd: true, even: true })
     end.to raise_error(RuntimeError)
   end
 
   it 'checks minimum' do
-    v = HaveAPI::Validators::Numericality.new(:number, {min: 5})
+    v = HaveAPI::Validators::Numericality.new(:number, { min: 5 })
     expect(v.valid?(4)).to be false
     expect(v.valid?(5)).to be true
     expect(v.valid?(6)).to be true
   end
-  
+
   it 'checks maximum' do
-    v = HaveAPI::Validators::Numericality.new(:number, {max: 50})
+    v = HaveAPI::Validators::Numericality.new(:number, { max: 50 })
     expect(v.valid?(100)).to be false
     expect(v.valid?(51)).to be false
     expect(v.valid?(50)).to be true
@@ -21,16 +21,16 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that x % y = 0' do
-    v = HaveAPI::Validators::Numericality.new(:number, {mod: 2})
+    v = HaveAPI::Validators::Numericality.new(:number, { mod: 2 })
     expect(v.valid?(3)).to be false
     expect(v.valid?(15)).to be false
     expect(v.valid?(0)).to be true
     expect(v.valid?(2)).to be true
     expect(v.valid?(48)).to be true
   end
-  
+
   it 'checks that the number is in a step' do
-    v = HaveAPI::Validators::Numericality.new(:number, {step: 3})
+    v = HaveAPI::Validators::Numericality.new(:number, { step: 3 })
     expect(v.valid?(4)).to be false
     expect(v.valid?(14)).to be false
     expect(v.valid?(0)).to be true
@@ -40,7 +40,7 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that the number is in a step with a minimum' do
-    v = HaveAPI::Validators::Numericality.new(:number, {min: 5, step: 3})
+    v = HaveAPI::Validators::Numericality.new(:number, { min: 5, step: 3 })
     expect(v.valid?(0)).to be false
     expect(v.valid?(3)).to be false
     expect(v.valid?(4)).to be false
@@ -53,15 +53,15 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that the number is even' do
-    v = HaveAPI::Validators::Numericality.new(:number, {even: true})
+    v = HaveAPI::Validators::Numericality.new(:number, { even: true })
     expect(v.valid?(1)).to be false
     expect(v.valid?(3)).to be false
     expect(v.valid?(0)).to be true
     expect(v.valid?(2)).to be true
   end
-  
+
   it 'checks that the number is odd' do
-    v = HaveAPI::Validators::Numericality.new(:number, {odd: true})
+    v = HaveAPI::Validators::Numericality.new(:number, { odd: true })
     expect(v.valid?(1)).to be true
     expect(v.valid?(3)).to be true
     expect(v.valid?(0)).to be false
@@ -69,12 +69,12 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks number as string' do
-    v = HaveAPI::Validators::Numericality.new(:number, {min: 5})
+    v = HaveAPI::Validators::Numericality.new(:number, { min: 5 })
     expect(v.valid?('5')).to be true
   end
 
   it 'rejects a string that is not a number' do
-    v = HaveAPI::Validators::Numericality.new(:number, {min: 5})
+    v = HaveAPI::Validators::Numericality.new(:number, { min: 5 })
     expect(v.valid?('abc')).to be false
   end
 end

data/spec/validators/presence_spec.rb

@@ -7,7 +7,7 @@ describe HaveAPI::Validators::Presence do
     it 'rejects a missing or empty value' do
       expect(@v.valid?(nil)).to be false
       expect(@v.valid?('')).to be false
-      expect(@v.valid?(" \t"*4)).to be false
+      expect(@v.valid?(" \t" * 4)).to be false
     end
   end
 
@@ -31,7 +31,7 @@ describe HaveAPI::Validators::Presence do
 
   context 'with empty = false' do
     before(:each) do
-      @v = HaveAPI::Validators::Presence.new(:required, {empty: true})
+      @v = HaveAPI::Validators::Presence.new(:required, { empty: true })
     end
 
     it 'accepts a present value' do
@@ -41,7 +41,7 @@ describe HaveAPI::Validators::Presence do
     it 'rejects a missing or an empty value' do
       expect(@v.valid?(nil)).to be false
       expect(@v.valid?('')).to be true
-      expect(@v.valid?(" \t"*4)).to be true
+      expect(@v.valid?(" \t" * 4)).to be true
     end
   end
 end