contracts 0.8 → 0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 124deda42f022fb31b53dc3389bd51ff85860d30
-  data.tar.gz: 8ea3f78006952432311338880c563cdbdf327f33
+  metadata.gz: c872d0fc055f6b1ace99f6793c436ee222111992
+  data.tar.gz: 0bc9d2a28a4dd77395932974fe46e9175818fa73
 SHA512:
-  metadata.gz: 644753384168c11234cd6a77b6d64384cc0f6fca93f3614e4d71ae3629ec7d05d85b02bfbd0150b3db21f94e04fe980f784d0e4decee0e5dcfd912f66526b2fb
-  data.tar.gz: 8a92fd259e98d4320fe5a4a52cc0d2d6cd01e7362b0fc6ed809001ef4e4618a7d1fab4513b2cb2db5946028fdf7a1c745e13491bf9d1e4e897f2dfe39446aafe
+  metadata.gz: 2c2eb482b3c7b2e697ff29076734fa9ec74dc93b9f8344514fdfab3a999a1b40dff0d57bbf487dcd82eaf51b7b503c55cc55a6573745b36314f09f3ce2f5778c
+  data.tar.gz: 3535f6d2ceea6e1382b9810679fcb619b94ed9788434022b597f120165a534383c306e6d5ce305ac0808a1b0d34dd0f1b1ca1ec53e3e61f3481a860197e8be5a

data/CHANGELOG.markdown

@@ -0,0 +1,28 @@
+## v0.9
+- MAJOR fix in pattern-matching: If the return contract for a pattern-matched function fails, it should NOT try the next pattern-match function. Pattern-matching is only for params, not return values.
+- raise an error if multiple defns have the same contract for pattern matching.
+
+- New syntax for functions with no input params.
+  Old way:
+  Contract nil => 1
+  def one
+
+  New way:
+  Contract 1
+  def one
+
+- Prettier HashOf contract can now be written like this: `HashOf[Num => String]`
+- Add `SetOf` contract
+- various small fixes
+
+## v0.8
+- code refactored (very slight loss of performance, big increase in readability)
+- fail when defining a contract on a module without `include Contracts::Modules`
+- fixed several bugs in argument parsing, functions with complex params get contracts applied correctly now.
+- added rubocop to ci.
+- if a contract is set on a protected method, it should not become public.
+- fixed pattern matching when the multiple definitions of functions have different arities.
+- couple of new built-in contracts: Nat, Eq.
+- changed `Invariant` to `invariant`: `invariant(:day) { 1 <= day && day <= 31 }`
+- prettier error messages (`Contracts::Num` is now just `Num`, for example)
+- support for yard-contracts

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 group :test do
   gem "rspec"
-  gem "rubocop", "~> 0.29", :platform => [:ruby_20, :ruby_21]
+  gem "rubocop", "~> 0.29.1", :platform => [:ruby_20, :ruby_21]
 end
 
 group :development do

data/TUTORIAL.md

@@ -79,7 +79,8 @@ contracts.ruby comes with a lot of built-in contracts, including the following:
 * [`And`](http://www.rubydoc.info/gems/contracts/Contracts/And) – passes if all contracts pass, e.g. `And[Fixnum, Float]`
 * [`Not`](http://www.rubydoc.info/gems/contracts/Contracts/Not) – passes if all contracts fail for the given argument, e.g. `Not[nil]`
 * [`ArrayOf`](http://www.rubydoc.info/gems/contracts/Contracts/ArrayOf) – checks that the argument is an array, and all elements pass the given contract, e.g. `ArrayOf[Num]`
-* [`HashOf`](http://www.rubydoc.info/gems/contracts/Contracts/HashOf) – checks that the argument is a hash, and all keys and values pass the given contract, e.g. `HashOf[Symbol, String]`
+* [`SetOf`](http://www.rubydoc.info/gems/contracts/Contracts/SetOf) – checks that the argument is a set, and all elements pass the given contract, e.g. `SetOf[Num]`
+* [`HashOf`](http://www.rubydoc.info/gems/contracts/Contracts/HashOf) – checks that the argument is a hash, and all keys and values pass the given contract, e.g. `HashOf[Symbol => String]`
 * [`Maybe`](http://www.rubydoc.info/gems/contracts/Contracts/Maybe) – passes if the argument is `nil`, or if the given contract passes
 * [`RespondTo`](http://www.rubydoc.info/gems/contracts/Contracts/RespondTo) – checks that the argument responds to all of the given methods, e.g. `RespondTo[:password, :credit_card]`
 * [`Send`](http://www.rubydoc.info/gems/contracts/Contracts/Send) – checks that all named methods return true, e.g. `Send[:valid?]`

data/lib/contracts.rb

@@ -73,22 +73,33 @@ class Contract < Contracts::Decorator
   # to monkey patch #failure_callback only temporary and then switch it back.
   # First important usage - for specs.
   DEFAULT_FAILURE_CALLBACK = proc do |data|
-    fail data[:contracts].failure_exception.new(failure_msg(data), data)
+    if data[:return_value]
+      # this failed on the return contract
+      fail ReturnContractError.new(failure_msg(data), data)
+    else
+      # this failed for a param contract
+      fail data[:contracts].failure_exception.new(failure_msg(data), data)
+    end
   end
 
   attr_reader :args_contracts, :ret_contract, :klass, :method
   def initialize(klass, method, *contracts)
-    if contracts[-1].is_a? Hash
-      # internally we just convert that return value syntax back to an array
-      @args_contracts = contracts[0, contracts.size - 1] + contracts[-1].keys
-      @ret_contract = contracts[-1].values[0]
-    else
-      fail %{
-        It looks like your contract for #{method} doesn't have a return value.
-        A contract should be written as `Contract arg1, arg2 => return_value`.
-      }.strip
+    unless contracts.last.is_a?(Hash)
+      unless contracts.one?
+        fail %{
+          It looks like your contract for #{method.name} doesn't have a return
+          value. A contract should be written as `Contract arg1, arg2 =>
+          return_value`.
+        }.strip
+      end
+      contracts = [nil => contracts[-1]]
     end
 
+    # internally we just convert that return value syntax back to an array
+    @args_contracts = contracts[0, contracts.size - 1] + contracts[-1].keys
+
+    @ret_contract = contracts[-1].values[0]
+
     @args_validators = args_contracts.map do |contract|
       Contract.make_validator(contract)
     end
@@ -307,7 +318,8 @@ class Contract < Contracts::Decorator
                                                 :method => method,
                                                 :contracts => self,
                                                 :arg_pos => i+1,
-                                                :total_args => args.size)
+                                                :total_args => args.size,
+                                                :return_value => false)
       end
 
       if contract.is_a?(Contracts::Func)
@@ -339,7 +351,8 @@ class Contract < Contracts::Decorator
                                                   :method => method,
                                                   :contracts => self,
                                                   :arg_pos => i-1,
-                                                  :total_args => args.size)
+                                                  :total_args => args.size,
+                                                  :return_value => false)
         end
 
         if contract.is_a?(Contracts::Func)
@@ -377,7 +390,7 @@ class Contract < Contracts::Decorator
     if @pattern_match
       PatternMatchingError
     else
-      ContractError
+      ParamContractError
     end
   end
 

data/lib/contracts/builtin_contracts.rb

@@ -1,5 +1,5 @@
-require "contracts/testable"
 require "contracts/formatters"
+require "set"
 
 # rdoc
 # This module contains all the builtin contracts.
@@ -24,14 +24,6 @@ module Contracts
     def self.valid? val
       val.is_a? Numeric
     end
-
-    def self.testable?
-      true
-    end
-
-    def self.test_data
-      [-1, 0, 1, 1.5, 50_000]
-    end
   end
 
   # Check that an argument is a positive number.
@@ -39,14 +31,6 @@ module Contracts
     def self.valid? val
       val > 0
     end
-
-    def testable?
-      true
-    end
-
-    def self.test_data
-      (0..5).map { rand(999) + 1 }
-    end
   end
 
   # Check that an argument is a negative number.
@@ -54,28 +38,12 @@ module Contracts
     def self.valid? val
       val < 0
     end
-
-    def testable?
-      true
-    end
-
-    def self.test_data
-      (0..5).map { (rand(999) + 1) * -1 }
-    end
   end
 
   # Check that an argument is a natural number.
   class Nat
     def self.valid? val
-      val >= 0 && val.integer?
-    end
-
-    def testable?
-      true
-    end
-
-    def self.test_data
-      (0..5).map { |n| n * rand(999) }
+      val && val >= 0 && val.integer?
     end
   end
 
@@ -128,19 +96,6 @@ module Contracts
         InspectWrapper.create(x)
       end.join(", ") + " or " + InspectWrapper.create(@vals[-1]).to_s
     end
-
-    # this can only be tested IF all the sub-contracts have a test_data method
-    def testable?
-      @vals.all? do |val|
-        Testable.testable?(val)
-      end
-    end
-
-    def test_data
-      @vals.map do |val|
-        Testable.test_data(val)
-      end.flatten
-    end
   end
 
   # Takes a variable number of contracts.
@@ -164,18 +119,6 @@ module Contracts
         InspectWrapper.create(x)
       end.join(", ") + " xor " + InspectWrapper.create(@vals[-1]).to_s
     end
-
-    def testable?
-      @vals.all? do |val|
-        Testable.testable? val
-      end
-    end
-
-    def test_data
-      @vals.map do |val|
-        Testable.test_data val
-      end.flatten
-    end
   end
 
   # Takes a variable number of contracts.
@@ -295,17 +238,20 @@ module Contracts
     end
   end
 
-  # Takes a contract. The related argument must be an array.
-  # Checks the contract against every element of the array.
+  # @private
+  # Takes a collection(responds to :each) type and a contract.
+  # The related argument must be of specified collection type.
+  # Checks the contract against every element of the collection.
   # If it passes for all elements, the contract passes.
-  # Example: <tt>ArrayOf[Num]</tt>
-  class ArrayOf < CallableClass
-    def initialize(contract)
+  # Example: <tt>CollectionOf[Array, Num]</tt>
+  class CollectionOf < CallableClass
+    def initialize(collection_class, contract)
+      @collection_class = collection_class
       @contract = contract
     end
 
     def valid?(vals)
-      return false unless vals.is_a?(Array)
+      return false unless vals.is_a?(@collection_class)
       vals.all? do |val|
         res, _ = Contract.valid?(val, @contract)
         res
@@ -313,22 +259,36 @@ module Contracts
     end
 
     def to_s
-      "an array of #{@contract}"
+      "a collection #{@collection_class} of #{@contract}"
     end
 
-    def testable?
-      Testable.testable? @contract
-    end
+    class Factory
+      def initialize(collection_class, &before_new)
+        @collection_class = collection_class
+        @before_new = before_new
+      end
+
+      def new(contract)
+        @before_new && @before_new.call
+        CollectionOf.new(@collection_class, contract)
+      end
 
-    def test_data
-      [
-        [],
-        [Testable.test_data(@contract)],
-        [Testable.test_data(@contract), Testable.test_data(@contract)]
-      ]
+      alias_method :[], :new
     end
   end
 
+  # Takes a contract. The related argument must be an array.
+  # Checks the contract against every element of the array.
+  # If it passes for all elements, the contract passes.
+  # Example: <tt>ArrayOf[Num]</tt>
+  ArrayOf = CollectionOf::Factory.new(Array)
+
+  # Takes a contract. The related argument must be a set.
+  # Checks the contract against every element of the set.
+  # If it passes for all elements, the contract passes.
+  # Example: <tt>SetOf[Num]</tt>
+  SetOf = CollectionOf::Factory.new(Set)
+
   # Used for <tt>*args</tt> (variadic functions). Takes a contract
   # and uses it to validate every element passed in
   # through <tt>*args</tt>.
@@ -342,18 +302,6 @@ module Contracts
     def to_s
       "Args[#{@contract}]"
     end
-
-    def testable?
-      Testable.testable? @contract
-    end
-
-    def test_data
-      [
-        [],
-        [Testable.test_data(@contract)],
-        [Testable.test_data(@contract), Testable.test_data(@contract)]
-      ]
-    end
   end
 
   class Bool
@@ -366,9 +314,17 @@ module Contracts
   # one for hash keys and one for hash values.
   # Example: <tt>HashOf[Symbol, String]</tt>
   class HashOf < CallableClass
-    def initialize(key, value)
-      @key   = key
-      @value = value
+    INVALID_KEY_VALUE_PAIR = "You should provide only one key-value pair to HashOf contract"
+
+    def initialize(key, value = nil)
+      if value
+        @key   = key
+        @value = value
+      else
+        validate_hash(key)
+        @key   = key.keys.first
+        @value = key[@key]
+      end
     end
 
     def valid?(hash)
@@ -381,6 +337,12 @@ module Contracts
     def to_s
       "Hash<#{@key}, #{@value}>"
     end
+
+    private
+
+    def validate_hash(hash)
+      fail ArgumentError, INVALID_KEY_VALUE_PAIR unless hash.count == 1
+    end
   end
 
   # Takes a Contract.
@@ -392,47 +354,6 @@ module Contracts
     end
   end
 
-  # class ::Hash
-  #   def testable?
-  #     values.all? do |val|
-  #       Testable.testable?(val)
-  #     end
-  #   end
-
-  #   def test_data
-  #     keys = self.keys
-  #     _vals = keys.map do |key|
-  #       ret = Testable.test_data(self[key])
-  #       if ret.is_a? Array
-  #         ret
-  #       else
-  #         [ret]
-  #       end
-  #     end
-  #     all_vals = Testable.product(_vals)
-  #     hashes = []
-  #     all_vals.each do |vals|
-  #       hash = {}
-  #       keys.zip(vals).each do |key, val|
-  #         hash[key] = val
-  #       end
-  #       hashes << hash
-  #     end
-  #     hashes
-  #   end
-  # end
-
-  # class ::String
-  #   def self.testable?
-  #     true
-  #   end
-
-  #   def self.test_data
-  #     # send a random string
-  #     ("a".."z").to_a.shuffle[0, 10].join
-  #   end
-  # end
-
   # Used to define contracts on functions passed in as arguments.
   # Example: <tt>Func[Num => Num] # the function should take a number and return a number</tt>
   class Func < CallableClass

data/lib/contracts/decorators.rb

@@ -61,6 +61,24 @@ module Contracts
 
       @decorated_methods[method_type][name] ||= []
 
+      unless decorators.size == 1
+        fail %{
+Oops, it looks like method '#{name}' has multiple contracts:
+#{decorators.map { |x| x[1][0].inspect }.join("\n")}
+
+Did you accidentally put more than one contract on a single function, like so?
+
+Contract String => String
+Contract Num => String
+def foo x
+end
+
+If you did NOT, then you have probably discovered a bug in this library.
+Please file it along with the relevant code at:
+https://github.com/egonSchiele/contracts.ruby/issues
+        }
+      end
+
       pattern_matching = false
       decorators.each do |klass, args|
         # a reference to the method gets passed into the contract here. This is good because
@@ -68,6 +86,21 @@ module Contracts
         # now the *only* reference to the old method that exists.
         # We assume here that the decorator (klass) responds to .new
         decorator = klass.new(self, method_reference, *args)
+        new_args_contract = decorator.args_contracts
+        matched = @decorated_methods[method_type][name].select do |contract|
+          contract.args_contracts == new_args_contract
+        end
+        unless matched.empty?
+          fail ContractError.new(%{
+It looks like you are trying to use pattern-matching, but
+multiple definitions for function '#{name}' have the same
+contract for input parameters:
+
+#{(matched + [decorator]).map(&:to_s).join("\n")}
+
+Each definition needs to have a different contract for the parameters.
+          }, {})
+        end
         @decorated_methods[method_type][name] << decorator
         pattern_matching ||= decorator.pattern_match?
       end
@@ -93,14 +126,14 @@ module Contracts
       # Here's why: Suppose you have this code:
       #
       #     class Foo
-      #       Contract nil => String
+      #       Contract String
       #       def to_s
       #         "Foo"
       #       end
       #     end
       #
       #     class Bar < Foo
-      #       Contract nil => String
+      #       Contract String
       #       def to_s
       #         super + "Bar"
       #       end

data/lib/contracts/errors.rb

@@ -22,6 +22,12 @@ end
 class ContractError < ContractBaseError
 end
 
+class ParamContractError < ContractError
+end
+
+class ReturnContractError < ContractError
+end
+
 # @private
 # Special contract error used internally to detect pattern failure during pattern matching
 class PatternMatchingError < ContractBaseError

data/lib/contracts/version.rb

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

data/spec/builtin_contracts_spec.rb

@@ -215,6 +215,20 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "SetOf:" do
+    it "should pass for a set of nums" do
+      expect { @o.product_from_set(Set.new([1, 2, 3])) }.to_not raise_error
+    end
+
+    it "should fail for an array with one non-num" do
+      expect { @o.product_from_set(Set.new([1, 2, 3, "bad"])) }.to raise_error(ContractError)
+    end
+
+    it "should fail for a non-array" do
+      expect { @o.product_from_set(1) }.to raise_error(ContractError)
+    end
+  end
+
   describe "Bool:" do
     it "should pass for an argument that is a boolean" do
       expect { @o.bool_test(true) }.to_not raise_error
@@ -241,12 +255,27 @@ RSpec.describe "Contracts:" do
   end
 
   describe "HashOf:" do
+    it "doesn't allow to specify multiple key-value pairs with pretty syntax" do
+      expect do
+        Class.new do
+          include Contracts
+
+          Contract Contracts::HashOf[Symbol => String, Contracts::Num => Contracts::Num] => nil
+          def something(hash)
+            # ...
+          end
+        end
+      end.to raise_error(ArgumentError, "You should provide only one key-value pair to HashOf contract")
+    end
+
     context "given a fulfilled contract" do
       it { expect(@o.gives_max_value(:panda => 1, :bamboo => 2)).to eq(2) }
+      it { expect(@o.pretty_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) }
+      it { expect { @o.pretty_gives_max_value(:panda => "1", :bamboo => "2") }.to raise_error(ContractError) }
     end
 
     describe "#to_s" do

data/spec/contracts_spec.rb

@@ -15,6 +15,27 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "contracts for functions with no arguments" do
+    it "should work for functions with no args" do
+      expect { @o.no_args }.to_not raise_error
+    end
+
+    it "should still work for old-style contracts for functions with no args" do
+      expect { @o.old_style_no_args }.to_not raise_error
+    end
+
+    it "should not work for a function with a bad contract" do
+      expect do
+        Class.new(GenericExample) do
+          Contract Num, Num
+          def no_args_bad_contract
+            1
+          end
+        end
+      end.to raise_error
+    end
+  end
+
   describe "pattern matching" do
     let(:string_with_hello) { "Hello, world" }
     let(:string_without_hello) { "Hi, world" }
@@ -54,6 +75,28 @@ RSpec.describe "Contracts:" do
       ).to eq("foo")
     end
 
+    it "if the return contract for a pattern match fails, it should fail instead of trying the next pattern match" do
+      expect do
+        subject.double(1)
+      end.to raise_error(ContractError)
+    end
+
+    it "should fail if multiple methods are defined with the same contract (for pattern-matching)" do
+      expect do
+        Class.new(GenericExample) do
+          Contract Contracts::Num => Contracts::Num
+          def same_param_contract x
+            x + 2
+          end
+
+          Contract Contracts::Num => String
+          def same_param_contract x
+            "sdf"
+          end
+        end
+      end.to raise_error(ContractError)
+    end
+
     context "when failure_callback was overriden" do
       before do
         ::Contract.override_failure_callback do |_data|
@@ -73,6 +116,12 @@ RSpec.describe "Contracts:" do
         ).to be_a(PatternMatchingExample::Failure)
       end
 
+      it "if the return contract for a pattern match fails, it should fail instead of trying the next pattern match, even with the failure callback" do
+        expect do
+          subject.double(1)
+        end.to raise_error(ContractError)
+      end
+
       it "uses overriden failure_callback when pattern matching fails" do
         expect do
           subject.process_request("hello")
@@ -273,10 +322,6 @@ RSpec.describe "Contracts:" do
     end
   end
 
-  it "should work for functions with no args" do
-    expect { @o.no_args }.to_not raise_error
-  end
-
   describe "classes" do
     it "should pass for correct input" do
       expect { @o.hello("calvin") }.to_not raise_error

data/spec/fixtures/fixtures.rb

@@ -212,15 +212,29 @@ class GenericExample
     end
   end
 
+  Contract SetOf[Num] => Num
+  def product_from_set(vals)
+    vals.inject(1) do |acc, x|
+      acc * x
+    end
+  end
+
   Contract Bool => nil
   def bool_test(x)
   end
 
-  Contract nil => Num
+  Contract Num
   def no_args
     1
   end
 
+  # This function has a contract which says it has no args,
+  # but the function does have args.
+  Contract nil => Num
+  def old_style_no_args
+    2
+  end
+
   Contract ArrayOf[Num], Func[Num => Num] => ArrayOf[Num]
   def map(arr, func)
     ret = []
@@ -267,18 +281,23 @@ class GenericExample
     hash.values.max
   end
 
+  Contract HashOf[Symbol => Num] => Num
+  def pretty_gives_max_value(hash)
+    hash.values.max
+  end
+
   Contract EmptyCont => Any
   def using_empty_contract(a)
     a
   end
 
-  Contract nil => String
+  Contract String
   def a_private_method
     "works"
   end
   private :a_private_method
 
-  Contract nil => String
+  Contract String
   def a_protected_method
     "works"
   end
@@ -286,14 +305,14 @@ class GenericExample
 
   private
 
-  Contract nil => String
+  Contract String
   def a_really_private_method
     "works for sure"
   end
 
   protected
 
-  Contract nil => String
+  Contract String
   def a_really_protected_method
     "works for sure"
   end
@@ -394,6 +413,16 @@ class PatternMatchingExample
   def do_stuff(number, string, other_number)
     "bar"
   end
+
+  Contract Num => Num
+  def double x
+    "bad"
+  end
+
+  Contract String => String
+  def double x
+    x * 2
+  end
 end
 
 # invariant example (silliest implementation ever)

data/spec/ruby_version_specific/contracts_spec_1.9.rb

@@ -3,6 +3,12 @@ class GenericExample
   def splat_then_arg(*vals, n)
     vals.map { |v| v * n }
   end
+
+  if ruby_version <= 1.9
+    Contract ({:foo => Nat}) => nil
+    def nat_test_with_kwarg(a_hash)
+    end
+  end
 end
 
 RSpec.describe "Contracts:" do

data/spec/ruby_version_specific/contracts_spec_2.0.rb

@@ -3,6 +3,10 @@ class GenericExample
   def splat_then_optional_named(*vals, repeat: 2)
     vals.map { |v| v * repeat }
   end
+
+  Contract ({foo: Nat}) => nil
+  def nat_test_with_kwarg(foo: 10)
+  end
 end
 
 RSpec.describe "Contracts:" do
@@ -19,4 +23,18 @@ RSpec.describe "Contracts:" do
       expect { @o.splat_then_optional_named("hello", "world", repeat: 3) }.to_not raise_error
     end
   end
+
+  describe "Nat:" do
+    it "should pass for keyword args with correct arg given" do
+      expect { @o.nat_test_with_kwarg(foo: 10) }.to_not raise_error
+    end
+
+    it "should fail with a ContractError for wrong keyword args input" do
+      expect { @o.nat_test_with_kwarg(foo: -10) }.to raise_error(ContractError)
+    end
+
+    it "should fail with a ContractError for no input" do
+      expect { @o.nat_test_with_kwarg }.to raise_error(ContractError)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contracts
 version: !ruby/object:Gem::Version
-  version: '0.8'
+  version: '0.9'
 platform: ruby
 authors:
 - Aditya Bhargava
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-02 00:00:00.000000000 Z
+date: 2015-04-24 00:00:00.000000000 Z
 dependencies: []
 description: This library provides contracts for Ruby. Contracts let you clearly express
   how your code behaves, and free you from writing tons of boilerplate, defensive
@@ -22,8 +22,8 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.markdown
 - Gemfile
-- Gemfile.lock
 - README.md
 - TODO.markdown
 - TUTORIAL.md
@@ -42,7 +42,6 @@ files:
 - lib/contracts/method_reference.rb
 - lib/contracts/modules.rb
 - lib/contracts/support.rb
-- lib/contracts/testable.rb
 - lib/contracts/version.rb
 - script/rubocop.rb
 - spec/builtin_contracts_spec.rb

data/Gemfile.lock

@@ -1,49 +0,0 @@
-PATH
-  remote: .
-  specs:
-    contracts (0.7)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    ast (2.0.0)
-    astrolabe (1.3.0)
-      parser (>= 2.2.0.pre.3, < 3.0)
-    diff-lcs (1.2.5)
-    hirb (0.7.2)
-    method_profiler (2.0.1)
-      hirb (>= 0.6.0)
-    parser (2.2.0.3)
-      ast (>= 1.1, < 3.0)
-    powerpack (0.1.0)
-    rainbow (2.0.0)
-    rspec (3.1.0)
-      rspec-core (~> 3.1.0)
-      rspec-expectations (~> 3.1.0)
-      rspec-mocks (~> 3.1.0)
-    rspec-core (3.1.7)
-      rspec-support (~> 3.1.0)
-    rspec-expectations (3.1.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.1.0)
-    rspec-mocks (3.1.3)
-      rspec-support (~> 3.1.0)
-    rspec-support (3.1.2)
-    rubocop (0.29.1)
-      astrolabe (~> 1.3)
-      parser (>= 2.2.0.1, < 3.0)
-      powerpack (~> 0.1)
-      rainbow (>= 1.99.1, < 3.0)
-      ruby-progressbar (~> 1.4)
-    ruby-prof (0.15.2)
-    ruby-progressbar (1.7.5)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  contracts!
-  method_profiler
-  rspec
-  rubocop (~> 0.29)
-  ruby-prof

data/lib/contracts/testable.rb

@@ -1,69 +0,0 @@
-module Contracts
-  class Testable
-    # Given an array-of-arrays of arguments,
-    # gives you the product of those arguments so that
-    # each possible combination is tried.
-    # Example: <tt>[[1, 2], [3, 4]]</tt> would give you:
-    #
-    #   [[1, 3], [1, 4], [2, 3], [2, 4]]
-    def self.product(arrays)
-      arrays.inject do |acc, x|
-        acc.product(x)
-      end.flatten(arrays.size - 2)
-    end
-
-    # Given a contract, tells if you it's testable
-    def self.testable?(contract)
-      if contract.respond_to?(:testable?)
-        contract.testable?
-      else
-        contract.respond_to?(:new) && contract.method(:new).arity == 0
-      end
-    end
-
-    # Given a contract, returns the test data associated with that contract
-    def self.test_data(contract)
-      if contract.respond_to?(:testable?)
-        contract.test_data
-      else
-        contract.new
-      end
-    end
-
-    # 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|
-        check(o.method(name))
-      end
-    end
-
-    def self.check(meth)
-      contracts = meth.owner.decorated_methods[meth.name.to_sym][0].contracts
-      arg_contracts = contracts[0, contracts.size - 1]
-      return_val = contracts[-1]
-      checkable = arg_contracts.all? do |arg_contract|
-        Testable.testable?(arg_contract)
-      end
-
-      if checkable
-        print "Checking #{meth.name}..."
-        _test_data = arg_contracts.map do |arg_contract|
-          data = Testable.test_data(arg_contract)
-          data.is_a?(Array) ? data : [data]
-        end
-        test_data = Testable.product _test_data
-        test_data.each do |args|
-          if args.is_a? Hash
-            # because *hash destroys the hash
-            res = meth.call(args)
-          else
-            res = meth.call(*args)
-          end
-          Contract.valid?(res, return_val)
-        end
-        puts "#{test_data.size} tests run."
-      end
-    end
-  end
-end