contracts 0.4 → 0.5

data/lib/contracts/invariants.rb

@@ -0,0 +1,75 @@
+class InvariantError < StandardError
+  def to_contract_error
+    self
+  end
+end
+
+module Contracts
+  module Invariants
+    def self.included(base)
+      common base
+    end
+
+    def self.extended(base)
+      common base
+    end
+
+    def self.common(base)
+      return if base.respond_to?(:Invariant)
+
+      base.extend(InvariantExtension)
+    end
+
+    def verify_invariants!(method)
+      return unless self.class.respond_to?(:invariants)
+
+      self.class.invariants.each do |invariant|
+        invariant.check_on(self, method)
+      end
+    end
+
+    module InvariantExtension
+      def Invariant(name, &condition)
+        return if ENV["NO_CONTRACTS"]
+
+        invariants << Invariant.new(self, name, &condition)
+      end
+
+      def invariants
+        @invariants ||= []
+      end
+    end
+
+    class Invariant
+      def initialize(klass, name, &condition)
+        @klass, @name, @condition = klass, name, condition
+      end
+
+      def expected
+        "#{@name} condition to be true"
+      end
+
+      def check_on(target, method)
+        return if target.instance_eval(&@condition)
+
+        self.class.failure_callback(:expected => expected,
+                                    :actual => false,
+                                    :target => target,
+                                    :method => method)
+      end
+
+      def self.failure_callback(data)
+        raise InvariantError, failure_msg(data)
+      end
+
+      def self.failure_msg(data)
+%{Invariant violation:
+    Expected: #{data[:expected]}
+    Actual: #{data[:actual]}
+    Value guarded in: #{data[:target].class}::#{Support.method_name(data[:method])}
+    At: #{Support.method_position(data[:method])}}
+      end
+    end
+
+  end
+end

data/lib/contracts/support.rb

@@ -0,0 +1,22 @@
+module Contracts
+  module Support
+
+    def self.method_position(method)
+      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 self.method_name(method)
+      method.is_a?(Proc) ? "Proc" : method.name
+    end
+
+  end
+end

data/lib/contracts/version.rb

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

data/spec/builtin_contracts_spec.rb

@@ -0,0 +1,216 @@
+include Contracts
+
+RSpec.describe "Contracts:" do
+  before :all do
+    @o = Object.new
+  end
+
+  describe "Num:" do
+    it "should pass for Fixnums" do
+      expect { @o.double(2) }.to_not raise_error
+    end
+
+    it "should pass for Floats" 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)
+    end
+  end
+
+  describe "Pos:" do
+    it "should pass for positive numbers" do
+      expect { @o.pos_test(1) }.to_not raise_error
+    end
+
+    it "should fail for negative numbers" do
+      expect { @o.pos_test(-1) }.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
+    end
+
+    it "should fail for positive numbers" do
+      expect { @o.neg_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
+    end
+    it "should pass for strings" do
+      expect { @o.show("bad") }.to_not raise_error
+    end
+    it "should pass for procs" do
+      expect { @o.show(lambda {}) }.to_not raise_error
+    end
+    it "should pass for nil" do
+      expect { @o.show(nil) }.to_not raise_error
+    end
+  end
+
+  describe "None:" do
+    it "should fail for numbers" do
+      expect { @o.fail_all(1) }.to raise_error(ContractError)
+    end
+    it "should fail for strings" do
+      expect { @o.fail_all("bad") }.to raise_error(ContractError)
+    end
+    it "should fail for procs" do
+      expect { @o.fail_all(lambda {}) }.to raise_error(ContractError)
+    end
+    it "should fail for nil" do
+      expect { @o.fail_all(nil) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Or:" do
+    it "should pass for nums" do
+      expect { @o.num_or_string(1) }.to_not raise_error
+    end
+
+    it "should pass for strings" do
+      expect { @o.num_or_string("bad") }.to_not raise_error
+    end
+
+    it "should fail for nil" do
+      expect { @o.num_or_string(nil) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Xor:" do
+    it "should pass for an object with a method :good" do
+      expect { @o.xor_test(A.new) }.to_not raise_error
+    end
+
+    it "should pass for an object with a method :bad" do
+      expect { @o.xor_test(B.new) }.to_not raise_error
+    end
+
+    it "should fail for an object with neither method" do
+      expect { @o.xor_test(1) }.to raise_error(ContractError)
+    end
+
+    it "should fail for an object with both methods :good and :bad" do
+      expect { @o.xor_test(C.new) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "And:" do
+    it "should pass for an object of class A that has a method :good" do
+      expect { @o.and_test(A.new) }.to_not raise_error
+    end
+
+    it "should fail for an object that has a method :good but isn't of class A" do
+      expect { @o.and_test(C.new) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "RespondTo:" do
+    it "should pass for an object that responds to :good" do
+      expect { @o.responds_test(A.new) }.to_not raise_error
+    end
+
+    it "should fail for an object that doesn't respond to :good" do
+      expect { @o.responds_test(B.new) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Send:" do
+    it "should pass for an object that returns true for method :good" do
+      expect { @o.send_test(A.new) }.to_not raise_error
+    end
+
+    it "should fail for an object that returns false for method :good" do
+      expect { @o.send_test(C.new) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Exactly:" do
+    it "should pass for an object that is exactly a Parent" do
+      expect { @o.exactly_test(Parent.new) }.to_not raise_error
+    end
+
+    it "should fail for an object that inherits from Parent" do
+      expect { @o.exactly_test(Child.new) }.to raise_error(ContractError)
+    end
+
+    it "should fail for an object that is not related to Parent at all" do
+      expect { @o.exactly_test(A.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
+    end
+
+    it "should fail for nil" do
+      expect { @o.not_nil(nil) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "ArrayOf:" do
+    it "should pass for an array of nums" do
+      expect { @o.product([1, 2, 3]) }.to_not raise_error
+    end
+
+    it "should fail for an array with one non-num" do
+      expect { @o.product([1, 2, 3, "bad"]) }.to raise_error(ContractError)
+    end
+
+    it "should fail for a non-array" do
+      expect { @o.product(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
+      expect { @o.bool_test(false) }.to_not raise_error
+    end
+
+    it "should fail for nil" do
+      expect { @o.bool_test(nil) }.to raise_error(ContractError)
+    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
+      expect { @o.maybe_double("foo") }.to raise_error(ContractError)
+    end
+  end
+
+  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) }
+    end
+
+    describe '#to_s' do
+      context 'given Symbol => String' do
+        it { expect(HashOf[Symbol, String].to_s).to eq('Hash<Symbol, String>') }
+      end
+
+      context 'given String => Num' do
+        it { expect(HashOf[String, Num].to_s).to eq('Hash<String, Contracts::Num>') }
+      end
+    end
+  end
+end

data/spec/contracts_spec.rb

@@ -0,0 +1,273 @@
+include Contracts
+
+RSpec.describe "Contracts:" do
+  before :all do
+    @o = Object.new
+  end
+
+  describe "basic" do
+    it "should fail for insufficient arguments" do
+      expect {
+        @o.hello
+      }.to raise_error
+    end
+
+    it "should fail for insufficient contracts" do
+      expect { @o.bad_double(2) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "pattern matching" do
+    let(:string_with_hello) { "Hello, world" }
+    let(:string_without_hello) { "Hi, world" }
+    let(:expected_decorated_string) { "Hello, world!" }
+    subject { PatternMatchingExample.new }
+
+    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])
+
+      expect(
+        subject.process_request(PatternMatchingExample::Failure.new)
+      ).to be_a(PatternMatchingExample::Failure)
+    end
+
+    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)
+    end
+
+    it "should fail when the pattern-matched method's contract fails" do
+      expect {
+        subject.process_request("bad input")
+      }.to raise_error(ContractError)
+    end
+
+    context "when failure_callback was overriden" do
+      before do
+        ::Contract.override_failure_callback do |_data|
+          raise RuntimeError, "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])
+      end
+
+      it "falls through to 2nd pattern when first pattern does not match" do
+        expect(
+          subject.process_request(PatternMatchingExample::Failure.new)
+        ).to be_a(PatternMatchingExample::Failure)
+      end
+
+      it "uses overriden failure_callback when pattern matching fails" do
+        expect {
+          subject.process_request("hello")
+        }.to raise_error(RuntimeError, /contract violation/)
+      end
+    end
+  end
+
+  describe "instance methods" do
+    it "should allow two classes to have the same method with different contracts" do
+      a = A.new
+      b = B.new
+      expect {
+        a.triple(5)
+        b.triple("a string")
+      }.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 {
+        a.instance_and_class_method(5)
+        A.instance_and_class_method("a string")
+      }.to_not raise_error
+    end
+  end
+
+  describe "class methods" do
+    it "should pass for correct input" do
+      expect { Object.a_class_method(2) }.to_not raise_error
+    end
+
+    it "should fail for incorrect input" do
+      expect { Object.a_class_method("bad") }.to raise_error(ContractError)
+    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
+    end
+
+    it "should fail for incorrect input" do
+      expect { @o.hello(1) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "classes with a valid? class method" do
+    it "should pass for correct input" do
+      expect { @o.double(2) }.to_not raise_error
+    end
+
+    it "should fail for incorrect input" do
+      expect { @o.double("bad") }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Procs" do
+    it "should pass for correct input" do
+      expect { @o.square(2) }.to_not raise_error
+    end
+
+    it "should fail for incorrect input" do
+      expect { @o.square("bad") }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Arrays" do
+    it "should pass for correct input" do
+      expect { @o.sum_three([1, 2, 3]) }.to_not raise_error
+    end
+
+    it "should fail for insufficient items" do
+      expect { @o.square([1, 2]) }.to raise_error(ContractError)
+    end
+
+    it "should fail for some incorrect elements" do
+      expect { @o.sum_three([1, 2, "three"]) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "Hashes" do
+    it "should pass for exact correct input" do
+      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
+    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)
+    end
+
+    it "should fail for incorrect input" do
+      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
+    end
+
+    it "should fail for incorrect input" do
+      expect { @o.do_call(nil) }.to raise_error(ContractError)
+    end
+  end
+
+  describe "varargs" do
+    it "should pass for correct input" do
+      expect { @o.sum(1, 2, 3) }.to_not raise_error
+    end
+
+    it "should fail for incorrect input" do
+      expect { @o.sum(1, 2, "bad") }.to raise_error(ContractError)
+    end
+  end
+
+  describe "contracts on functions" do
+    it "should pass for a function that passes the contract" do
+      expect { @o.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)
+    end
+  end
+
+  describe "default args to functions" do
+    it "should work for a function call that relies on default args" do
+      expect { @o.default_args }.to_not raise_error
+      expect { @o.default_args("foo") }.to raise_error(ContractError)
+    end
+  end
+
+  describe "classes" do
+    it "should not fail for an object that is the exact type as the contract" do
+      p = Parent.new
+      expect { @o.id_(p) }.to_not raise_error
+    end
+
+    it "should not fail for an object that is a subclass of the type in the contract" do
+      c = Child.new
+      expect { @o.id_(c) }.to_not raise_error
+    end
+  end
+
+  describe "failure callbacks" do
+    before :each do
+      ::Contract.override_failure_callback do |_data|
+        should_call
+      end
+    end
+
+    context "when failure_callback returns false" do
+      let(:should_call) { false }
+
+      it "does not call a function for which the contract fails" do
+        res = @o.double("bad")
+        expect(res).to eq(nil)
+      end
+    end
+
+    context "when failure_callback returns true" do
+      let(:should_call) { true }
+
+      it "calls a function for which the contract fails" do
+        res = @o.double("bad")
+        expect(res).to eq("badbad")
+      end
+    end
+  end
+
+  describe "functype" do
+    it "should correctly print out a instance method's type" do
+      expect(@o.functype(:double)).not_to eq("")
+    end
+
+    it "should correctly print out a class method's type" do
+      expect(A.functype(:a_class_method)).not_to eq("")
+    end
+  end
+
+  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
+    end
+  end
+
+  describe "inherited methods" do
+    it "should apply the contract to an inherited method" do
+      c = Child.new
+      expect { c.double(2) }.to_not raise_error
+      expect { c.double("asd") }.to raise_error
+    end
+  end
+end