contracts-lite 0.14.0

data/lib/contracts/method_reference.rb

@@ -0,0 +1,100 @@
+module Contracts
+  # MethodReference represents original method reference that was
+  # decorated by contracts.ruby. Used for instance methods.
+  class MethodReference
+    attr_reader :name
+
+    # name - name of the method
+    # method - method object
+    def initialize(name, method)
+      @name = name
+      @method = method
+    end
+
+    # Returns method_position, delegates to Support.method_position
+    def method_position
+      Support.method_position(@method)
+    end
+
+    # Makes a method re-definition in proper way
+    def make_definition(this, &blk)
+      is_private = private?(this)
+      is_protected = protected?(this)
+      alias_target(this).send(:define_method, name, &blk)
+      make_private(this) if is_private
+      make_protected(this) if is_protected
+    end
+
+    # Aliases original method to a special unique name, which is known
+    # only to this class. Usually done right before re-defining the
+    # method.
+    def make_alias(this)
+      _aliased_name = aliased_name
+      original_name = name
+
+      alias_target(this).class_eval do
+        alias_method _aliased_name, original_name
+      end
+    end
+
+    # Calls original method on specified `this` argument with
+    # specified arguments `args` and block `&blk`.
+    def send_to(this, *args, &blk)
+      this.send(aliased_name, *args, &blk)
+    end
+
+    private
+
+    # Makes a method private
+    def make_private(this)
+      original_name = name
+      alias_target(this).class_eval { private original_name }
+    end
+
+    def private?(this)
+      this.private_instance_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_instance_methods.map(&:to_sym).include?(name)
+    end
+
+    # Makes a method protected
+    def make_protected(this)
+      original_name = name
+      alias_target(this).class_eval { protected original_name }
+    end
+
+    # Returns alias target for instance methods, subject to be
+    # overriden in subclasses.
+    def alias_target(this)
+      this
+    end
+
+    def aliased_name
+      @_original_name ||= construct_unique_name
+    end
+
+    def construct_unique_name
+      :"__contracts_ruby_original_#{name}_#{Support.unique_id}"
+    end
+  end
+
+  # The same as MethodReference, but used for singleton methods.
+  class SingletonMethodReference < MethodReference
+    private
+
+    def private?(this)
+      this.private_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_methods.map(&:to_sym).include?(name)
+    end
+
+    # Return alias target for singleton methods.
+    def alias_target(this)
+      Support.eigenclass_of this
+    end
+  end
+end

data/lib/contracts/support.rb

@@ -0,0 +1,59 @@
+module Contracts
+  module Support
+    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
+          else
+            method.inspect
+          end
+        else
+          file, line = method.source_location
+          file + ":" + line.to_s
+        end
+      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 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 contract_id(contract)
+        contract.object_id
+      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 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,139 @@
+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,
+
+      Range => lambda do |contract|
+        lambda do |arg|
+          contract.include?(arg)
+        end
+      end,
+
+      Regexp => lambda do |contract|
+        lambda do |arg|
+          arg =~ contract
+        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

@@ -0,0 +1,3 @@
+module Contracts
+  VERSION = "0.14.0"
+end

data/script/rubocop

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+if RUBY_VERSION.to_f > 2.1
+  puts "running rubocop..."
+  puts `bundle exec rubocop -D spec/ lib/`
+  exit $?.exitstatus
+end

data/spec/builtin_contracts_spec.rb

@@ -0,0 +1,461 @@
+RSpec.describe "Contracts:" do
+  before :all do
+    @o = GenericExample.new
+  end
+
+  def fails(&some)
+    expect { some.call }.to raise_error(ContractError)
+  end
+
+  def passes(&some)
+    expect { some.call }.to_not raise_error
+  end
+
+  describe "DescendantOf:" do
+    it "should pass for Array" do
+      passes { @o.enumerable_descendant_test(Array) }
+    end
+
+    it "should pass for a hash" do
+      passes { @o.enumerable_descendant_test(Hash) }
+    end
+
+    it "should fail for a number class" do
+      fails { @o.enumerable_descendant_test(Integer) }
+    end
+
+    it "should fail for a non-class" do
+      fails { @o.enumerable_descendant_test(1) }
+    end
+  end
+
+  describe "Num:" do
+    it "should pass for Fixnums" do
+      passes { @o.double(2) }
+    end
+
+    it "should pass for Floats" do
+      passes { @o.double(2.2) }
+    end
+
+    it "should fail for nil and other data types" do
+      fails { @o.double(nil) }
+      fails { @o.double(:x) }
+      fails { @o.double("x") }
+      fails { @o.double(/x/) }
+    end
+  end
+
+  describe "Pos:" do
+    it "should pass for positive numbers" do
+      passes { @o.pos_test(1) }
+      passes { @o.pos_test(1.6) }
+    end
+
+    it "should fail for 0" do
+      fails { @o.pos_test(0) }
+    end
+
+    it "should fail for negative numbers" do
+      fails { @o.pos_test(-1) }
+      fails { @o.pos_test(-1.6) }
+    end
+
+    it "should fail for nil and other data types" do
+      fails { @o.pos_test(nil) }
+      fails { @o.pos_test(:x)  }
+      fails { @o.pos_test("x") }
+      fails { @o.pos_test(/x/) }
+    end
+  end
+
+  describe "Neg:" do
+    it "should pass for negative numbers" do
+      passes { @o.neg_test(-1) }
+      passes { @o.neg_test(-1.6) }
+    end
+
+    it "should fail for 0" do
+      fails { @o.neg_test(0) }
+    end
+
+    it "should fail for positive numbers" do
+      fails { @o.neg_test(1) }
+      fails { @o.neg_test(1.6) }
+    end
+
+    it "should fail for nil and other data types" do
+      fails { @o.neg_test(nil) }
+      fails { @o.neg_test(:x)  }
+      fails { @o.neg_test("x") }
+      fails { @o.neg_test(/x/) }
+    end
+  end
+
+  describe "Nat:" do
+    it "should pass for 0" do
+      passes { @o.nat_test(0) }
+    end
+
+    it "should pass for positive whole numbers" do
+      passes { @o.nat_test(1) }
+    end
+
+    it "should fail for positive non-whole numbers" do
+      fails { @o.nat_test(1.5) }
+    end
+
+    it "should fail for negative numbers" do
+      fails { @o.nat_test(-1) }
+      fails { @o.nat_test(-1.6) }
+    end
+
+    it "should fail for nil and other data types" do
+      fails { @o.nat_test(nil) }
+      fails { @o.nat_test(:x)  }
+      fails { @o.nat_test("x") }
+      fails { @o.nat_test(/x/) }
+    end
+  end
+
+  describe "Any:" do
+    it "should pass for numbers" do
+      passes { @o.show(1) }
+    end
+    it "should pass for strings" do
+      passes { @o.show("bad") }
+    end
+    it "should pass for procs" do
+      passes { @o.show(lambda {}) }
+    end
+    it "should pass for nil" do
+      passes { @o.show(nil) }
+    end
+  end
+
+  describe "None:" do
+    it "should fail for numbers" do
+      fails { @o.fail_all(1) }
+    end
+    it "should fail for strings" do
+      fails { @o.fail_all("bad") }
+    end
+    it "should fail for procs" do
+      fails { @o.fail_all(lambda {}) }
+    end
+    it "should fail for nil" do
+      fails { @o.fail_all(nil) }
+    end
+  end
+
+  describe "Or:" do
+    it "should pass for nums" do
+      passes { @o.num_or_string(1) }
+    end
+
+    it "should pass for strings" do
+      passes { @o.num_or_string("bad") }
+    end
+
+    it "should fail for nil" do
+      fails { @o.num_or_string(nil) }
+    end
+  end
+
+  describe "Xor:" do
+    it "should pass for an object with a method :good" do
+      passes { @o.xor_test(A.new) }
+    end
+
+    it "should pass for an object with a method :bad" do
+      passes { @o.xor_test(B.new) }
+    end
+
+    it "should fail for an object with neither method" do
+      fails { @o.xor_test(1) }
+    end
+
+    it "should fail for an object with both methods :good and :bad" do
+      fails { @o.xor_test(F.new) }
+    end
+  end
+
+  describe "And:" do
+    it "should pass for an object of class A that has a method :good" do
+      passes { @o.and_test(A.new) }
+    end
+
+    it "should fail for an object that has a method :good but isn't of class A" do
+      fails { @o.and_test(F.new) }
+    end
+  end
+
+  describe "Enum:" do
+    it "should pass for an object that is included" do
+      passes { @o.enum_test(:a) }
+    end
+
+    it "should fail for an object that is not included" do
+      fails { @o.enum_test(:z) }
+    end
+  end
+
+  describe "RespondTo:" do
+    it "should pass for an object that responds to :good" do
+      passes { @o.responds_test(A.new) }
+    end
+
+    it "should fail for an object that doesn't respond to :good" do
+      fails { @o.responds_test(B.new) }
+    end
+  end
+
+  describe "Send:" do
+    it "should pass for an object that returns true for method :good" do
+      passes { @o.send_test(A.new) }
+    end
+
+    it "should fail for an object that returns false for method :good" do
+      fails { @o.send_test(F.new) }
+    end
+  end
+
+  describe "Exactly:" do
+    it "should pass for an object that is exactly a Parent" do
+      passes { @o.exactly_test(Parent.new) }
+    end
+
+    it "should fail for an object that inherits from Parent" do
+      fails { @o.exactly_test(Child.new) }
+    end
+
+    it "should fail for an object that is not related to Parent at all" do
+      fails { @o.exactly_test(A.new) }
+    end
+  end
+
+  describe "Eq:" do
+    it "should pass for a class" do
+      passes { @o.eq_class_test(Foo) }
+    end
+
+    it "should pass for a module" do
+      passes { @o.eq_module_test(Bar) }
+    end
+
+    it "should pass for other values" do
+      passes { @o.eq_value_test(Baz) }
+    end
+
+    it "should fail when not equal" do
+      fails { @o.eq_class_test(Bar) }
+    end
+
+    it "should fail when given instance of class" do
+      fails { @o.eq_class_test(Foo.new) }
+    end
+  end
+
+  describe "Not:" do
+    it "should pass for an argument that isn't nil" do
+      passes { @o.not_nil(1) }
+    end
+
+    it "should fail for nil" do
+      fails { @o.not_nil(nil) }
+    end
+  end
+
+  describe "ArrayOf:" do
+    it "should pass for an array of nums" do
+      passes { @o.product([1, 2, 3]) }
+    end
+
+    it "should fail for an array with one non-num" do
+      fails { @o.product([1, 2, 3, "bad"]) }
+    end
+
+    it "should fail for a non-array" do
+      fails { @o.product(1) }
+    end
+  end
+
+  describe "RangeOf:" do
+    require "date"
+    it "should pass for a range of nums" do
+      passes { @o.first_in_range_num(3..10) }
+    end
+
+    it "should pass for a range of dates" do
+      d1 = Date.today
+      d2 = d1 + 18
+      passes { @o.first_in_range_date(d1..d2) }
+    end
+
+    it "should fail for a non-range" do
+      fails { @o.first_in_range_num("foo") }
+      fails { @o.first_in_range_num(:foo) }
+      fails { @o.first_in_range_num(5) }
+      fails { @o.first_in_range_num(nil) }
+    end
+
+    it "should fail for a range with incorrect data type" do
+      fails { @o.first_in_range_num("a".."z") }
+    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
+        fails { @o.first_in_range_date(d1..10) }
+        fails { @o.first_in_range_num(d1..10) }
+      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
+      passes { @o.product_from_set(Set.new([1, 2, 3])) }
+    end
+
+    it "should fail for an array with one non-num" do
+      fails { @o.product_from_set(Set.new([1, 2, 3, "bad"])) }
+    end
+
+    it "should fail for a non-array" do
+      fails { @o.product_from_set(1) }
+    end
+  end
+
+  describe "Bool:" do
+    it "should pass for an argument that is a boolean" do
+      passes { @o.bool_test(true) }
+      passes { @o.bool_test(false) }
+    end
+
+    it "should fail for nil" do
+      fails { @o.bool_test(nil) }
+    end
+  end
+
+  describe "Maybe:" do
+    it "should pass for nums" do
+      expect(@o.maybe_double(1)).to eq(2)
+    end
+
+    it "should pass for nils" do
+      expect(@o.maybe_double(nil)).to eq(nil)
+    end
+
+    it "should fail for strings" do
+      fails { @o.maybe_double("foo") }
+    end
+  end
+
+  describe "KeywordArgs:" do
+    it "should pass for exact correct input" do
+      passes { @o.person_keywordargs(:name => "calvin", :age => 10) }
+    end
+
+    it "should fail if some keys don't have contracts" do
+      fails { @o.person_keywordargs(:name => "calvin", :age => 10, :foo => "bar") }
+    end
+
+    it "should fail if a key with a contract on it isn't provided" do
+      fails { @o.person_keywordargs(:name => "calvin") }
+    end
+
+    it "should fail for incorrect input" do
+      fails { @o.person_keywordargs(:name => 50, :age => 10) }
+      fails { @o.hash_keywordargs(:hash => nil) }
+      fails { @o.hash_keywordargs(:hash => 1) }
+    end
+
+    it "should pass if a method is overloaded with non-KeywordArgs" do
+      passes { @o.person_keywordargs("name", 10) }
+    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
+        Class.new do
+          include Contracts::Core
+
+          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 { fails { @o.gives_max_value(:panda => "1", :bamboo => "2") }  }
+      it { fails { @o.gives_max_value(nil) } }
+      it { fails { @o.gives_max_value(1) } }
+      it { fails { @o.pretty_gives_max_value(:panda => "1", :bamboo => "2") } }
+    end
+
+    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::Builtin::Num>") }
+      end
+    end
+  end
+
+  describe "StrictHash:" do
+    context "when given an exact correct input" do
+      it "does not raise an error" do
+        passes { @o.strict_person(:name => "calvin", :age => 10) }
+      end
+    end
+
+    context "when given an input with correct keys but wrong types" do
+      it "raises an error" do
+        fails { @o.strict_person(:name => "calvin", :age => "10") }
+      end
+    end
+
+    context "when given an input with missing keys" do
+      it "raises an error" do
+        fails { @o.strict_person(:name => "calvin") }
+      end
+    end
+
+    context "when given an input with extra keys" do
+      it "raises an error" do
+        fails { @o.strict_person(:name => "calvin", :age => "10", :soft => true) }
+      end
+    end
+
+    context "when given not a hash" do
+      it "raises an error" do
+        fails { @o.strict_person(1337) }
+      end
+    end
+  end
+end