contracts 0.9 → 0.10

data/lib/contracts/support.rb

@@ -1,44 +1,59 @@
 module Contracts
   module Support
-    def self.method_position(method)
-      return method.method_position if method.is_a?(MethodReference)
+    class << self
+      def method_position(method)
+        return method.method_position if method.is_a?(MethodReference)
 
-      if RUBY_VERSION =~ /^1\.8/
-        if method.respond_to?(:__file__)
-          method.__file__ + ":" + method.__line__.to_s
+        if RUBY_VERSION =~ /^1\.8/
+          if method.respond_to?(:__file__)
+            method.__file__ + ":" + method.__line__.to_s
+          else
+            method.inspect
+          end
         else
-          method.inspect
+          file, line = method.source_location
+          file + ":" + line.to_s
         end
-      else
-        file, line = method.source_location
-        file + ":" + line.to_s
       end
-    end
 
-    def self.method_name(method)
-      method.is_a?(Proc) ? "Proc" : method.name
-    end
+      def method_name(method)
+        method.is_a?(Proc) ? "Proc" : method.name
+      end
 
-    # Generates unique id, which can be used as a part of identifier
-    #
-    # Example:
-    #    Contracts::Support.unique_id   # => "i53u6tiw5hbo"
-    def self.unique_id
-      # Consider using SecureRandom.hex here, and benchmark which one is better
-      (Time.now.to_f * 1000).to_i.to_s(36) + rand(1_000_000).to_s(36)
-    end
+      # Generates unique id, which can be used as a part of identifier
+      #
+      # Example:
+      #    Contracts::Support.unique_id   # => "i53u6tiw5hbo"
+      def unique_id
+        # Consider using SecureRandom.hex here, and benchmark which one is better
+        (Time.now.to_f * 1000).to_i.to_s(36) + rand(1_000_000).to_s(36)
+      end
 
-    def self.eigenclass_hierarchy_supported?
-      return false if RUBY_PLATFORM == "java" && RUBY_VERSION.to_f < 2.0
-      RUBY_VERSION.to_f > 1.8
-    end
+      def contract_id(contract)
+        contract.object_id
+      end
 
-    def self.eigenclass_of(target)
-      class << target; self; end
-    end
+      def eigenclass_hierarchy_supported?
+        return false if RUBY_PLATFORM == "java" && RUBY_VERSION.to_f < 2.0
+        RUBY_VERSION.to_f > 1.8
+      end
+
+      def eigenclass_of(target)
+        class << target; self; end
+      end
 
-    def self.eigenclass?(target)
-      target <= eigenclass_of(Object)
+      def eigenclass?(target)
+        module_eigenclass?(target) ||
+          target <= eigenclass_of(Object)
+      end
+
+      private
+
+      # Module eigenclass can be detected by its ancestor chain
+      # containing a Module
+      def module_eigenclass?(target)
+        target < Module
+      end
     end
   end
 end

data/lib/contracts/validators.rb

@@ -0,0 +1,127 @@
+module Contracts
+  module Validators
+    DEFAULT_VALIDATOR_STRATEGIES = {
+      # e.g. lambda {true}
+      Proc => lambda { |contract| contract },
+
+      # e.g. [Num, String]
+      # TODO: account for these errors too
+      Array => lambda do |contract|
+        lambda do |arg|
+          return false unless arg.is_a?(Array) && arg.length == contract.length
+          arg.zip(contract).all? do |_arg, _contract|
+            Contract.valid?(_arg, _contract)
+          end
+        end
+      end,
+
+      # e.g. { :a => Num, :b => String }
+      Hash => lambda do |contract|
+        lambda do |arg|
+          return false unless arg.is_a?(Hash)
+          contract.keys.all? do |k|
+            Contract.valid?(arg[k], contract[k])
+          end
+        end
+      end,
+
+      Contracts::Args => lambda do |contract|
+        lambda do |arg|
+          Contract.valid?(arg, contract.contract)
+        end
+      end,
+
+      Contracts::Func => lambda do |_|
+        lambda do |arg|
+          arg.is_a?(Method) || arg.is_a?(Proc)
+        end
+      end,
+
+      :valid => lambda do |contract|
+        lambda { |arg| contract.valid?(arg) }
+      end,
+
+      :class => lambda do |contract|
+        lambda { |arg| arg.is_a?(contract) }
+      end,
+
+      :default => lambda do |contract|
+        lambda { |arg| contract == arg }
+      end
+    }.freeze
+
+    # Allows to override validator with custom one.
+    # Example:
+    #   Contract.override_validator(Array) do |contract|
+    #     lambda do |arg|
+    #       # .. implementation for Array contract ..
+    #     end
+    #   end
+    #
+    #   Contract.override_validator(:class) do |contract|
+    #     lambda do |arg|
+    #       arg.is_a?(contract) || arg.is_a?(RSpec::Mocks::Double)
+    #     end
+    #   end
+    def override_validator(name, &block)
+      validator_strategies[name] = block
+    end
+
+    # This is a little weird. For each contract
+    # we pre-make a proc to validate it so we
+    # don't have to go through this decision tree every time.
+    # Seems silly but it saves us a bunch of time (4.3sec vs 5.2sec)
+    def make_validator!(contract)
+      klass = contract.class
+      key = if validator_strategies.key?(klass)
+              klass
+            else
+              if contract.respond_to? :valid?
+                :valid
+              elsif klass == Class || klass == Module
+                :class
+              else
+                :default
+              end
+            end
+
+      validator_strategies[key].call(contract)
+    end
+
+    def make_validator(contract)
+      contract_id = Support.contract_id(contract)
+
+      if memoized_validators.key?(contract_id)
+        return memoized_validators[contract_id]
+      end
+
+      memoized_validators[contract_id] = make_validator!(contract)
+    end
+
+    # @private
+    def reset_validators
+      clean_memoized_validators
+      restore_validators
+    end
+
+    # @private
+    def validator_strategies
+      @_validator_strategies ||= restore_validators
+    end
+
+    # @private
+    def restore_validators
+      @_validator_strategies = DEFAULT_VALIDATOR_STRATEGIES.dup
+    end
+
+    # @private
+    def memoized_validators
+      @_memoized_validators ||= clean_memoized_validators
+    end
+
+    # @private
+    def clean_memoized_validators
+      @_memoized_validators = {}
+    end
+  end
+end

data/lib/contracts/version.rb

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

data/spec/builtin_contracts_spec.rb

@@ -12,14 +12,18 @@ RSpec.describe "Contracts:" do
       expect { @o.double(2.2) }.to_not raise_error
     end
 
-    it "should fail for Strings" do
-      expect { @o.double("bad") }.to raise_error(ContractError)
+    it "should fail for nil and other data types" do
+      expect { @o.double(nil) }.to raise_error(ContractError)
+      expect { @o.double(:x)  }.to raise_error(ContractError)
+      expect { @o.double("x") }.to raise_error(ContractError)
+      expect { @o.double(/x/) }.to raise_error(ContractError)
     end
   end
 
   describe "Pos:" do
     it "should pass for positive numbers" do
       expect { @o.pos_test(1) }.to_not raise_error
+      expect { @o.pos_test(1.6) }.to_not raise_error
     end
 
     it "should fail for 0" do
@@ -28,12 +32,21 @@ RSpec.describe "Contracts:" do
 
     it "should fail for negative numbers" do
       expect { @o.pos_test(-1) }.to raise_error(ContractError)
+      expect { @o.pos_test(-1.6) }.to raise_error(ContractError)
+    end
+
+    it "should fail for nil and other data types" do
+      expect { @o.pos_test(nil) }.to raise_error(ContractError)
+      expect { @o.pos_test(:x)  }.to raise_error(ContractError)
+      expect { @o.pos_test("x") }.to raise_error(ContractError)
+      expect { @o.pos_test(/x/) }.to raise_error(ContractError)
     end
   end
 
   describe "Neg:" do
     it "should pass for negative numbers" do
       expect { @o.neg_test(-1) }.to_not raise_error
+      expect { @o.neg_test(-1.6) }.to_not raise_error
     end
 
     it "should fail for 0" do
@@ -42,6 +55,14 @@ RSpec.describe "Contracts:" do
 
     it "should fail for positive numbers" do
       expect { @o.neg_test(1) }.to raise_error(ContractError)
+      expect { @o.neg_test(1.6) }.to raise_error(ContractError)
+    end
+
+    it "should fail for nil and other data types" do
+      expect { @o.neg_test(nil) }.to raise_error(ContractError)
+      expect { @o.neg_test(:x)  }.to raise_error(ContractError)
+      expect { @o.neg_test("x") }.to raise_error(ContractError)
+      expect { @o.neg_test(/x/) }.to raise_error(ContractError)
     end
   end
 
@@ -60,6 +81,14 @@ RSpec.describe "Contracts:" do
 
     it "should fail for negative numbers" do
       expect { @o.nat_test(-1) }.to raise_error(ContractError)
+      expect { @o.nat_test(-1.6) }.to raise_error(ContractError)
+    end
+
+    it "should fail for nil and other data types" do
+      expect { @o.nat_test(nil) }.to raise_error(ContractError)
+      expect { @o.nat_test(:x)  }.to raise_error(ContractError)
+      expect { @o.nat_test("x") }.to raise_error(ContractError)
+      expect { @o.nat_test(/x/) }.to raise_error(ContractError)
     end
   end
 
@@ -215,6 +244,45 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "RangeOf:" do
+    require "date"
+    it "should pass for a range of nums" do
+      expect { @o.first_in_range_num(3..10) }.to_not raise_error
+    end
+
+    it "should pass for a range of dates" do
+      d1 = Date.today
+      d2 = d1 + 18
+      expect { @o.first_in_range_date(d1..d2) }.to_not raise_error
+    end
+
+    it "should fail for a non-range" do
+      expect { @o.first_in_range_num("foo") }.to raise_error(ContractError)
+      expect { @o.first_in_range_num(:foo) }.to raise_error(ContractError)
+      expect { @o.first_in_range_num(5) }.to raise_error(ContractError)
+      expect { @o.first_in_range_num(nil) }.to raise_error(ContractError)
+    end
+
+    it "should fail for a range with incorrect data type" do
+      expect { @o.first_in_range_num("a".."z") }.to raise_error(ContractError)
+    end
+
+    it "should fail for a badly-defined range" do
+      # For some reason, Ruby 2.0.0 allows (date .. number) as a range.
+      # Perhaps other Ruby versions do too.
+      # Note that (date .. string) gives ArgumentError.
+      # This test guards against ranges with inconsistent data types.
+      begin
+        d1 = Date.today
+        expect { @o.first_in_range_date(d1..10).to raise_error(ContractError) }
+        expect { @o.first_in_range_num(d1..10).to raise_error(ContractError) }
+      rescue ArgumentError
+        # If Ruby doesn't like the range, we ignore the test.
+        :nop
+      end
+    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
@@ -254,6 +322,14 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "Optional:" do
+    it "can't be used outside of KeywordArgs" do
+      expect do
+        BareOptionalContractUsed.new.something(3, 5)
+      end.to raise_error(ArgumentError, Contracts::Optional::UNABLE_TO_USE_OUTSIDE_OF_OPT_HASH)
+    end
+  end
+
   describe "HashOf:" do
     it "doesn't allow to specify multiple key-value pairs with pretty syntax" do
       expect do

data/spec/contracts_spec.rb

@@ -250,7 +250,6 @@ RSpec.describe "Contracts:" do
     let(:mod) do
       Module.new do
         include Contracts
-        include Contracts::Modules
 
         Contract String => String
         def greeting(name)
@@ -404,6 +403,26 @@ RSpec.describe "Contracts:" do
         @o.double_with_proc(4)
       end.to raise_error(ContractError, /Actual: nil/)
     end
+
+    it "should succeed for maybe proc with no proc" do
+      expect do
+        @o.maybe_call(5)
+      end.to_not raise_error
+    end
+
+    it "should succeed for maybe proc with proc" do
+      expect do
+        @o.maybe_call(5) do
+          2 + 2
+        end
+      end.to_not raise_error
+    end
+
+    it "should fail for maybe proc with invalid input" do
+      expect do
+        @o.maybe_call("bad")
+      end.to raise_error(ContractError)
+    end
   end
 
   describe "varargs" do
@@ -489,6 +508,18 @@ RSpec.describe "Contracts:" do
     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
+
+    it "should fail for a returned function that doesn't pass the contract" do
+      expect { @o.lambda_with_wrong_return.call("hello") }.to raise_error(ContractError)
+    end
+
+    it "should fail for a returned function that receives the wrong argument type" do
+      expect { @o.lambda_with_correct_return.call(123) }.to raise_error(ContractError)
+    end
+
+    it "should not fail for a returned function that passes the contract" do
+      expect { @o.lambda_with_correct_return.call("hello") }.to_not raise_error
+    end
   end
 
   describe "default args to functions" do
@@ -536,6 +567,38 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "module contracts" do
+    it "passes for instance of class including module" do
+      expect(
+        ModuleContractExample.hello(ModuleContractExample::AClassWithModule.new)
+      ).to eq(:world)
+    end
+
+    it "passes for instance of class including inherited module" do
+      expect(
+        ModuleContractExample.hello(ModuleContractExample::AClassWithInheritedModule.new)
+      ).to eq(:world)
+    end
+
+    it "does not pass for instance of class not including module" do
+      expect do
+        ModuleContractExample.hello(ModuleContractExample::AClassWithoutModule.new)
+      end.to raise_error(ContractError, /Expected: ModuleContractExample::AModule/)
+    end
+
+    it "does not pass for instance of class including another module" do
+      expect do
+        ModuleContractExample.hello(ModuleContractExample::AClassWithAnotherModule.new)
+      end.to raise_error(ContractError, /Expected: ModuleContractExample::AModule/)
+    end
+
+    it "passes for instance of class including both modules" do
+      expect(
+        ModuleContractExample.hello(ModuleContractExample::AClassWithBothModules.new)
+      ).to eq(:world)
+    end
+  end
+
   describe "Contracts to_s formatting in expected" do
     def not_s(match)
       Regexp.new "[^\"\']#{match}[^\"\']"

data/spec/fixtures/fixtures.rb

@@ -1,3 +1,5 @@
+require "date"
+
 class A
   include Contracts
 
@@ -120,8 +122,13 @@ class GenericExample
   end
 
   Contract Proc => Any
-  def do_call(&blk)
-    blk.call
+  def do_call(&block)
+    block.call
+  end
+
+  Contract Args[Num], Maybe[Proc] => Any
+  def maybe_call(*vals, &block)
+    block.call if block
   end
 
   Contract Args[Num] => Num
@@ -219,6 +226,16 @@ class GenericExample
     end
   end
 
+  Contract RangeOf[Num] => Num
+  def first_in_range_num(r)
+    r.first
+  end
+
+  Contract RangeOf[Date] => Date
+  def first_in_range_date(r)
+    r.first
+  end
+
   Contract Bool => nil
   def bool_test(x)
   end
@@ -262,6 +279,16 @@ class GenericExample
     end
   end
 
+  Contract None => Func[String => Num]
+  def lambda_with_wrong_return
+    lambda { |x| x }
+  end
+
+  Contract None => Func[String => Num]
+  def lambda_with_correct_return
+    lambda { |x| x.length }
+  end
+
   Contract Num => Num
   def default_args(x = 1)
     2
@@ -528,10 +555,7 @@ with_enabled_no_contracts do
 end
 
 module ModuleExample
-  # This inclusion is required to actually override `method_added`
-  # hooks for module.
   include Contracts
-  include Contracts::Modules
 
   Contract Num, Num => Num
   def plus(a, b)
@@ -567,3 +591,51 @@ end
 
 class SingletonInheritanceExampleSubclass < SingletonInheritanceExample
 end
+
+class BareOptionalContractUsed
+  include Contracts
+
+  Contract Num, Optional[Num] => nil
+  def something(a, b)
+    nil
+  end
+end
+
+module ModuleContractExample
+  include Contracts
+
+  module AModule
+  end
+
+  module AnotherModule
+  end
+
+  module InheritedModule
+    include AModule
+  end
+
+  class AClassWithModule
+    include AModule
+  end
+
+  class AClassWithoutModule
+  end
+
+  class AClassWithAnotherModule
+    include AnotherModule
+  end
+
+  class AClassWithInheritedModule
+    include InheritedModule
+  end
+
+  class AClassWithBothModules
+    include AModule
+    include AnotherModule
+  end
+
+  Contract AModule => Symbol
+  def self.hello(thing)
+    :world
+  end
+end