contracts 0.7 → 0.8

data/lib/contracts/testable.rb

@@ -7,11 +7,11 @@ module Contracts
     #
     #   [[1, 3], [1, 4], [2, 3], [2, 4]]
     def self.product(arrays)
-      arrays.inject { |acc, x|
+      arrays.inject do |acc, x|
         acc.product(x)
-      }.flatten(arrays.size - 2)
+      end.flatten(arrays.size - 2)
     end
-    
+
     # Given a contract, tells if you it's testable
     def self.testable?(contract)
       if contract.respond_to?(:testable?)
@@ -30,10 +30,10 @@ module Contracts
       end
     end
 
-    # TODO Should work on whatever class it was invoked on, no?
+    # TODO: Should work on whatever class it was invoked on, no?
     def self.check_all
       o = Object.new
-      Object.decorated_methods.each do |name, contracts|
+      Object.decorated_methods.each do |name, _contracts|
         check(o.method(name))
       end
     end
@@ -64,6 +64,6 @@ module Contracts
         end
         puts "#{test_data.size} tests run."
       end
-    end    
+    end
   end
 end

data/lib/contracts/version.rb

@@ -1,3 +1,3 @@
 module Contracts
-  VERSION = "0.7"
+  VERSION = "0.8"
 end

data/script/rubocop.rb

@@ -0,0 +1,5 @@
+if RUBY_VERSION.to_f == 2.1
+  puts "running rubocop..."
+  puts `bundle exec rubocop #{ARGV.join(" ")} -D`
+  exit $?.exitstatus
+end

data/spec/builtin_contracts_spec.rb

@@ -22,6 +22,10 @@ RSpec.describe "Contracts:" do
       expect { @o.pos_test(1) }.to_not raise_error
     end
 
+    it "should fail for 0" do
+      expect { @o.pos_test(0) }.to raise_error(ContractError)
+    end
+
     it "should fail for negative numbers" do
       expect { @o.pos_test(-1) }.to raise_error(ContractError)
     end
@@ -32,11 +36,33 @@ RSpec.describe "Contracts:" do
       expect { @o.neg_test(-1) }.to_not raise_error
     end
 
+    it "should fail for 0" do
+      expect { @o.neg_test(0) }.to raise_error(ContractError)
+    end
+
     it "should fail for positive numbers" do
       expect { @o.neg_test(1) }.to raise_error(ContractError)
     end
   end
 
+  describe "Nat:" do
+    it "should pass for 0" do
+      expect { @o.nat_test(0) }.to_not raise_error
+    end
+
+    it "should pass for positive whole numbers" do
+      expect { @o.nat_test(1) }.to_not raise_error
+    end
+
+    it "should fail for positive non-whole numbers" do
+      expect { @o.nat_test(1.5) }.to raise_error(ContractError)
+    end
+
+    it "should fail for negative numbers" do
+      expect { @o.nat_test(-1) }.to raise_error(ContractError)
+    end
+  end
+
   describe "Any:" do
     it "should pass for numbers" do
       expect { @o.show(1) }.to_not raise_error
@@ -143,6 +169,28 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "Eq:" do
+    it "should pass for a class" do
+      expect { @o.eq_class_test(Foo) }
+    end
+
+    it "should pass for a module" do
+      expect { @o.eq_module_test(Bar) }
+    end
+
+    it "should pass for other values" do
+      expect { @o.eq_value_test(Baz) }
+    end
+
+    it "should fail when not equal" do
+      expect { @o.eq_class_test(Bar) }.to raise_error(ContractError)
+    end
+
+    it "should fail when given instance of class" do
+      expect { @o.eq_class_test(Foo.new) }.to raise_error(ContractError)
+    end
+  end
+
   describe "Not:" do
     it "should pass for an argument that isn't nil" do
       expect { @o.not_nil(1) }.to_not raise_error
@@ -192,22 +240,22 @@ RSpec.describe "Contracts:" do
     end
   end
 
-  describe 'HashOf:' do
-    context 'given a fulfilled contract' do
+  describe "HashOf:" do
+    context "given a fulfilled contract" do
       it { expect(@o.gives_max_value(:panda => 1, :bamboo => 2)).to eq(2) }
     end
 
-    context 'given an unfulfilled contract' do
-      it { expect { @o.gives_max_value(:panda => '1', :bamboo => '2') }.to raise_error(ContractError) }
+    context "given an unfulfilled contract" do
+      it { expect { @o.gives_max_value(:panda => "1", :bamboo => "2") }.to raise_error(ContractError) }
     end
 
-    describe '#to_s' do
-      context 'given Symbol => String' do
-        it { expect(Contracts::HashOf[Symbol, String].to_s).to eq('Hash<Symbol, String>') }
+    describe "#to_s" do
+      context "given Symbol => String" do
+        it { expect(Contracts::HashOf[Symbol, String].to_s).to eq("Hash<Symbol, String>") }
       end
 
-      context 'given String => Num' do
-        it { expect(Contracts::HashOf[String, Contracts::Num].to_s).to eq('Hash<String, Contracts::Num>') }
+      context "given String => Num" do
+        it { expect(Contracts::HashOf[String, Contracts::Num].to_s).to eq("Hash<String, Contracts::Num>") }
       end
     end
   end

data/spec/contracts_spec.rb

@@ -5,9 +5,9 @@ RSpec.describe "Contracts:" do
 
   describe "basic" do
     it "should fail for insufficient arguments" do
-      expect {
+      expect do
         @o.hello
-      }.to raise_error
+      end.to raise_error
     end
 
     it "should fail for insufficient contracts" do
@@ -23,8 +23,8 @@ RSpec.describe "Contracts:" do
 
     it "should work as expected when there is no contract violation" do
       expect(
-        subject.process_request(PatternMatchingExample::Success[string_with_hello])
-      ).to eq(PatternMatchingExample::Success[expected_decorated_string])
+        subject.process_request(PatternMatchingExample::Success.new(string_with_hello))
+      ).to eq(PatternMatchingExample::Success.new(expected_decorated_string))
 
       expect(
         subject.process_request(PatternMatchingExample::Failure.new)
@@ -33,28 +33,38 @@ RSpec.describe "Contracts:" do
 
     it "should not fall through to next pattern when there is a deep contract violation" do
       expect(PatternMatchingExample::Failure).not_to receive(:is_a?)
-      expect {
-        subject.process_request(PatternMatchingExample::Success[string_without_hello])
-      }.to raise_error(ContractError)
+      expect do
+        subject.process_request(PatternMatchingExample::Success.new(string_without_hello))
+      end.to raise_error(ContractError)
     end
 
     it "should fail when the pattern-matched method's contract fails" do
-      expect {
+      expect do
         subject.process_request("bad input")
-      }.to raise_error(ContractError)
+      end.to raise_error(ContractError)
+    end
+
+    it "should work for differing arities" do
+      expect(
+        subject.do_stuff(1, "abc", 2)
+      ).to eq("bar")
+
+      expect(
+        subject.do_stuff(3, "def")
+      ).to eq("foo")
     end
 
     context "when failure_callback was overriden" do
       before do
         ::Contract.override_failure_callback do |_data|
-          raise RuntimeError, "contract violation"
+          fail "contract violation"
         end
       end
 
       it "calls a method when first pattern matches" do
         expect(
-          subject.process_request(PatternMatchingExample::Success[string_with_hello])
-        ).to eq(PatternMatchingExample::Success[expected_decorated_string])
+          subject.process_request(PatternMatchingExample::Success.new(string_with_hello))
+        ).to eq(PatternMatchingExample::Success.new(expected_decorated_string))
       end
 
       it "falls through to 2nd pattern when first pattern does not match" do
@@ -64,9 +74,9 @@ RSpec.describe "Contracts:" do
       end
 
       it "uses overriden failure_callback when pattern matching fails" do
-        expect {
+        expect do
           subject.process_request("hello")
-        }.to raise_error(RuntimeError, /contract violation/)
+        end.to raise_error(RuntimeError, /contract violation/)
       end
     end
   end
@@ -77,13 +87,13 @@ RSpec.describe "Contracts:" do
     end
 
     it "should fail with proper error when there is contract violation" do
-      expect {
+      expect do
         SingletonClassExample.hoge(3)
-      }.to raise_error(ContractError, /Expected: String/)
+      end.to raise_error(ContractError, /Expected: String/)
     end
 
     context "when owner class does not include Contracts" do
-      let(:error) {
+      let(:error) do
         # NOTE Unable to support this user-friendly error for ruby
         # 1.8.7 and jruby 1.8, 1.9 it has much less support for
         # singleton inheritance hierarchy
@@ -92,10 +102,10 @@ RSpec.describe "Contracts:" do
         else
           [NoMethodError, /undefined method `Contract'/]
         end
-      }
+      end
 
       it "fails with descriptive error" do
-        expect {
+        expect do
           Class.new(GenericExample) do
             class << self
               Contract String => String
@@ -104,15 +114,15 @@ RSpec.describe "Contracts:" do
               end
             end
           end
-        }.to raise_error(*error)
+        end.to raise_error(*error)
       end
     end
 
     describe "builtin contracts usage" do
       it "allows to use builtin contracts without namespacing and redundant Contracts inclusion" do
-        expect {
+        expect do
           SingletonClassExample.add("55", 5.6)
-        }.to raise_error(ContractError, /Expected: Contracts::Num/)
+        end.to raise_error(ContractError, /Expected: Num/)
       end
     end
   end
@@ -236,20 +246,20 @@ RSpec.describe "Contracts:" do
     it "should allow two classes to have the same method with different contracts" do
       a = A.new
       b = B.new
-      expect {
+      expect do
         a.triple(5)
         b.triple("a string")
-      }.to_not raise_error
+      end.to_not raise_error
     end
   end
 
   describe "instance and class methods" do
     it "should allow a class to have an instance method and a class method with the same name" do
       a = A.new
-      expect {
+      expect do
         a.instance_and_class_method(5)
         A.instance_and_class_method("a string")
-      }.to_not raise_error
+      end.to_not raise_error
     end
   end
 
@@ -313,77 +323,103 @@ RSpec.describe "Contracts:" do
 
   describe "Hashes" do
     it "should pass for exact correct input" do
-      expect { @o.person({:name => "calvin", :age => 10}) }.to_not raise_error
+      expect { @o.person(:name => "calvin", :age => 10) }.to_not raise_error
     end
 
     it "should pass even if some keys don't have contracts" do
-      expect { @o.person({:name => "calvin", :age => 10, :foo => "bar"}) }.to_not raise_error
+      expect { @o.person(:name => "calvin", :age => 10, :foo => "bar") }.to_not raise_error
     end
 
     it "should fail if a key with a contract on it isn't provided" do
-      expect { @o.person({:name => "calvin"}) }.to raise_error(ContractError)
+      expect { @o.person(:name => "calvin") }.to raise_error(ContractError)
     end
 
     it "should fail for incorrect input" do
-      expect { @o.person({:name => 50, :age => 10}) }.to raise_error(ContractError)
+      expect { @o.person(:name => 50, :age => 10) }.to raise_error(ContractError)
     end
   end
 
   describe "blocks" do
     it "should pass for correct input" do
-      expect { @o.do_call {
-        2 + 2
-      }}.to_not raise_error
+      expect do
+        @o.do_call do
+          2 + 2
+        end
+      end.to_not raise_error
     end
 
     it "should fail for incorrect input" do
-      expect { @o.do_call(nil) }.to raise_error(ContractError)
+      expect do
+        @o.do_call(nil)
+      end.to raise_error(ContractError)
     end
 
     it "should handle properly lack of block when there are other arguments" do
-      expect { @o.double_with_proc(4) }.to raise_error(ContractError, /Actual: nil/)
+      expect do
+        @o.double_with_proc(4)
+      end.to raise_error(ContractError, /Actual: nil/)
     end
   end
 
   describe "varargs" do
     it "should pass for correct input" do
-      expect { @o.sum(1, 2, 3) }.to_not raise_error
+      expect do
+        @o.sum(1, 2, 3)
+      end.to_not raise_error
     end
 
     it "should fail for incorrect input" do
-      expect { @o.sum(1, 2, "bad") }.to raise_error(ContractError)
+      expect do
+        @o.sum(1, 2, "bad")
+      end.to raise_error(ContractError)
+    end
+
+    it "should work with arg before splat" do
+      expect do
+        @o.arg_then_splat(3, "hello", "world")
+      end.to_not raise_error
     end
   end
 
   describe "varargs with block" do
     it "should pass for correct input" do
-      expect { @o.with_partial_sums(1, 2, 3) { |partial_sum| 2 * partial_sum + 1 } }.not_to raise_error
-      expect { @o.with_partial_sums_contracted(1, 2, 3) { |partial_sum| 2 * partial_sum + 1 } }.not_to raise_error
+      expect do
+        @o.with_partial_sums(1, 2, 3) do |partial_sum|
+          2 * partial_sum + 1
+        end
+      end.not_to raise_error
+      expect do
+        @o.with_partial_sums_contracted(1, 2, 3) do |partial_sum|
+          2 * partial_sum + 1
+        end
+      end.not_to raise_error
     end
 
     it "should fail for incorrect input" do
-      expect {
-        @o.with_partial_sums(1, 2, "bad") { |partial_sum| 2 * partial_sum + 1 }
-      }.to raise_error(ContractError, /Actual: "bad"/)
+      expect do
+        @o.with_partial_sums(1, 2, "bad") do |partial_sum|
+          2 * partial_sum + 1
+        end
+      end.to raise_error(ContractError, /Actual: "bad"/)
 
-      expect {
+      expect do
         @o.with_partial_sums(1, 2, 3)
-      }.to raise_error(ContractError, /Actual: nil/)
+      end.to raise_error(ContractError, /Actual: nil/)
 
-      expect {
+      expect do
         @o.with_partial_sums(1, 2, 3, lambda { |x| x })
-      }.to raise_error(ContractError, /Actual: #<Proc/)
+      end.to raise_error(ContractError, /Actual: nil/)
     end
 
     context "when block has Func contract" do
       it "should fail for incorrect input" do
-        expect {
+        expect do
           @o.with_partial_sums_contracted(1, 2, "bad") { |partial_sum| 2 * partial_sum + 1 }
-        }.to raise_error(ContractError, /Actual: "bad"/)
+        end.to raise_error(ContractError, /Actual: "bad"/)
 
-        expect {
+        expect do
           @o.with_partial_sums_contracted(1, 2, 3)
-        }.to raise_error(ContractError, /Actual: nil/)
+        end.to raise_error(ContractError, /Actual: nil/)
       end
     end
   end
@@ -393,8 +429,20 @@ RSpec.describe "Contracts:" do
       expect { @o.map([1, 2, 3], lambda { |x| x + 1 }) }.to_not raise_error
     end
 
+    it "should pass for a function that passes the contract as in tutorial" do
+      expect { @o.tutorial_map([1, 2, 3], lambda { |x| x + 1 }) }.to_not raise_error
+    end
+
     it "should fail for a function that doesn't pass the contract" do
-      expect { @o.map([1, 2, 3], lambda { |x| "bad return value" }) }.to raise_error(ContractError)
+      expect { @o.map([1, 2, 3], lambda { |_| "bad return value" }) }.to raise_error(ContractError)
+    end
+
+    it "should pass for a function that passes the contract with weak other args" do
+      expect { @o.map_plain(["hello", "joe"], lambda { |x| x.size }) }.to_not raise_error
+    end
+
+    it "should fail for a function that doesn't pass the contract with weak other args" do
+      expect { @o.map_plain(["hello", "joe"], lambda { |_| nil }) }.to raise_error(ContractError)
     end
   end
 
@@ -443,6 +491,77 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "Contracts to_s formatting in expected" do
+    def not_s(match)
+      Regexp.new "[^\"\']#{match}[^\"\']"
+    end
+
+    def delim(match)
+      "(#{match})"
+    end
+
+    it "should not stringify native types" do
+      expect do
+        @o.constanty("bad", nil)
+      end.to raise_error(ContractError, not_s(123))
+
+      expect do
+        @o.constanty(123, "bad")
+      end.to raise_error(ContractError, not_s(nil))
+    end
+
+    it "should contain to_s representation within a Hash contract" do
+      expect do
+        @o.hash_complex_contracts(:rigged => "bad")
+      end.to raise_error(ContractError, not_s(delim "TrueClass or FalseClass"))
+    end
+
+    it "should contain to_s representation within a nested Hash contract" do
+      expect do
+        @o.nested_hash_complex_contracts(:rigged => true,
+                                         :contents => {
+                                           :kind => 0,
+                                           :total => 42 })
+      end.to raise_error(ContractError, not_s(delim "String or Symbol"))
+    end
+
+    it "should contain to_s representation within an Array contract" do
+      expect do
+        @o.array_complex_contracts(["bad"])
+      end.to raise_error(ContractError, not_s(delim "TrueClass or FalseClass"))
+    end
+
+    it "should contain to_s representation within a nested Array contract" do
+      expect do
+        @o.nested_array_complex_contracts([true, [0]])
+      end.to raise_error(ContractError, not_s(delim "String or Symbol"))
+    end
+
+    it "should not contain Contracts:: module prefix" do
+      expect do
+        @o.double("bad")
+      end.to raise_error(ContractError, /Expected: Num/)
+    end
+
+    it "should still show nils, not just blank space" do
+      expect do
+        @o.no_args("bad")
+      end.to raise_error(ContractError, /Expected: nil/)
+    end
+
+    it 'should show empty quotes as ""' do
+      expect do
+        @o.no_args("")
+      end.to raise_error(ContractError, /Actual: ""/)
+    end
+
+    it "should not use custom to_s if empty string" do
+      expect do
+        @o.using_empty_contract("bad")
+      end.to raise_error(ContractError, /Expected: EmptyCont/)
+    end
+  end
+
   describe "functype" do
     it "should correctly print out a instance method's type" do
       expect(@o.functype(:double)).not_to eq("")
@@ -455,11 +574,21 @@ RSpec.describe "Contracts:" do
 
   describe "private methods" do
     it "should raise an error if you try to access a private method" do
-      expect { @o.a_private_method }.to raise_error
+      expect { @o.a_private_method }.to raise_error(NoMethodError, /private/)
     end
 
     it "should raise an error if you try to access a private method" do
-      expect { @o.a_really_private_method }.to raise_error
+      expect { @o.a_really_private_method }.to raise_error(NoMethodError, /private/)
+    end
+  end
+
+  describe "protected methods" do
+    it "should raise an error if you try to access a protected method" do
+      expect { @o.a_protected_method }.to raise_error(NoMethodError, /protected/)
+    end
+
+    it "should raise an error if you try to access a protected method" do
+      expect { @o.a_really_protected_method }.to raise_error(NoMethodError, /protected/)
     end
   end