contracts 0.5 → 0.6

data/lib/contracts/eigenclass.rb

@@ -0,0 +1,41 @@
+module Contracts
+  module Eigenclass
+
+    def self.extended(eigenclass)
+      return if eigenclass.respond_to?(:owner_class=)
+
+      class << eigenclass
+        attr_accessor :owner_class
+      end
+    end
+
+    def self.lift(base)
+      return NullEigenclass if base.singleton_class?
+
+      eigenclass = base.singleton_class
+
+      unless eigenclass.respond_to?(:owner_class=)
+        eigenclass.extend(Eigenclass)
+      end
+
+      unless eigenclass.respond_to?(:pop_decorators)
+        eigenclass.extend(MethodDecorators)
+      end
+
+      eigenclass.owner_class = base
+
+      eigenclass
+    end
+
+    module NullEigenclass
+      def self.owner_class
+        self
+      end
+
+      def self.pop_decorators
+        []
+      end
+    end
+
+  end
+end

data/lib/contracts/errors.rb

@@ -0,0 +1,65 @@
+# @private
+# Base class for Contract errors
+#
+# If default failure callback is used it stores failure data
+class ContractBaseError < ArgumentError
+  attr_reader :data
+
+  def initialize(message, data)
+    super(message)
+    @data = data
+  end
+
+  # Used to convert to simple ContractError from other contract errors
+  def to_contract_error
+    self
+  end
+end
+
+# Default contract error
+#
+# If default failure callback is used, users normally see only these contract errors
+class ContractError < ContractBaseError
+end
+
+# @private
+# Special contract error used internally to detect pattern failure during pattern matching
+class PatternMatchingError < ContractBaseError
+  # Used to convert to ContractError from PatternMatchingError
+  def to_contract_error
+    ContractError.new(to_s, data)
+  end
+end
+
+# Base invariant violation error
+class InvariantError < StandardError
+  def to_contract_error
+    self
+  end
+end
+
+module Contracts
+  # Error issued when user haven't included Contracts in original class but used Contract definition in singleton class
+  #
+  # Provides useful description for user of the gem and an example of correct usage.
+  class ContractsNotIncluded < TypeError
+    DEFAULT_MESSAGE = %{In order to use contracts in singleton class, please include Contracts module in original class
+    Example:
+
+    ```ruby
+    class Example
+      include Contracts  # this line is required
+      class << self
+        # you can use `Contract` definition here now
+      end
+    end
+    ```}
+
+    attr_reader :message
+    alias_method :to_s, :message
+
+    def initialize(message=DEFAULT_MESSAGE)
+      @message = message
+    end
+  end
+end

data/lib/contracts/invariants.rb

@@ -1,9 +1,3 @@
-class InvariantError < StandardError
-  def to_contract_error
-    self
-  end
-end
-
 module Contracts
   module Invariants
     def self.included(base)

data/lib/contracts/method_reference.rb

@@ -0,0 +1,75 @@
+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)
+      alias_target(this).send(:define_method, name, &blk)
+    end
+
+    # Makes a method private
+    def make_private(this)
+      alias_target(this).class_eval { private name }
+    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
+
+    # 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
+
+    # Return alias target for singleton methods.
+    def alias_target(this)
+      this.singleton_class
+    end
+  end
+end

data/lib/contracts/modules.rb

@@ -0,0 +1,17 @@
+module Contracts
+  module Modules
+    def self.included(base)
+      common(base)
+    end
+
+    def self.extended(base)
+      common(base)
+    end
+
+    def self.common(base)
+      return unless base.instance_of?(Module)
+      base.extend(MethodDecorators)
+      Eigenclass.lift(base)
+    end
+  end
+end

data/lib/contracts/support.rb

@@ -2,6 +2,8 @@ module Contracts
   module Support
 
     def self.method_position(method)
+      return method.method_position if MethodReference === method
+
       if RUBY_VERSION =~ /^1\.8/
         if method.respond_to?(:__file__)
           method.__file__ + ":" + method.__line__.to_s
@@ -18,5 +20,19 @@ module Contracts
       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(1000000).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
+
   end
 end

data/lib/contracts/version.rb

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

data/spec/builtin_contracts_spec.rb

@@ -1,8 +1,6 @@
-include Contracts
-
 RSpec.describe "Contracts:" do
   before :all do
-    @o = Object.new
+    @o = GenericExample.new
   end
 
   describe "Num:" do
@@ -205,11 +203,11 @@ RSpec.describe "Contracts:" do
 
     describe '#to_s' do
       context 'given Symbol => String' do
-        it { expect(HashOf[Symbol, String].to_s).to eq('Hash<Symbol, String>') }
+        it { expect(Contracts::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>') }
+        it { expect(Contracts::HashOf[String, Contracts::Num].to_s).to eq('Hash<String, Contracts::Num>') }
       end
     end
   end

data/spec/contracts_spec.rb

@@ -1,8 +1,6 @@
-include Contracts
-
 RSpec.describe "Contracts:" do
   before :all do
-    @o = Object.new
+    @o = GenericExample.new
   end
 
   describe "basic" do
@@ -73,6 +71,159 @@ RSpec.describe "Contracts:" do
     end
   end
 
+  describe "usage in singleton class" do
+    it "should work normally when there is no contract violation" do
+      expect(SingletonClassExample.hoge("hoge")).to eq("superhoge")
+    end
+
+    it "should fail with proper error when there is contract violation" do
+      expect {
+        SingletonClassExample.hoge(3)
+      }.to raise_error(ContractError, /Expected: String/)
+    end
+
+    context "when owner class does not include Contracts" do
+      let(:error) {
+        # 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
+        if Contracts::Support.eigenclass_hierarchy_supported?
+          [Contracts::ContractsNotIncluded, Contracts::ContractsNotIncluded::DEFAULT_MESSAGE]
+        else
+          [NoMethodError, /undefined method `Contract'/]
+        end
+      }
+
+      it "fails with descriptive error" do
+        expect {
+          Class.new(GenericExample) do
+            class << self
+              Contract String => String
+              def hoge(name)
+                "super#{name}"
+              end
+            end
+          end
+        }.to raise_error(*error)
+      end
+    end
+  end
+
+  describe "no contracts feature" do
+    it "disables normal contract checks" do
+      object = NoContractsSimpleExample.new
+      expect { object.some_method(3) }.not_to raise_error
+    end
+
+    it "disables invariants" do
+      object = NoContractsInvariantsExample.new
+      object.day = 7
+      expect { object.next_day }.not_to raise_error
+    end
+
+    it "does not disable pattern matching" do
+      object = NoContractsPatternMatchingExample.new
+
+      expect(object.on_response(200, "hello")).to eq("hello!")
+      expect(object.on_response(404, "Not found")).to eq("error 404: Not found")
+      expect { object.on_response(nil, "junk response") }.to raise_error(ContractError)
+    end
+  end
+
+  describe "module usage" do
+    context "with instance methods" do
+      it "should check contract" do
+        expect { KlassWithModuleExample.new.plus(3, nil) }.to raise_error(ContractError)
+      end
+    end
+
+    context "with singleton methods" do
+      it "should check contract" do
+        expect { ModuleExample.hoge(nil) }.to raise_error(ContractError)
+      end
+    end
+
+    context "with singleton class methods" do
+      it "should check contract" do
+        expect { ModuleExample.eat(:food) }.to raise_error(ContractError)
+      end
+    end
+  end
+
+  describe "singleton methods self in inherited methods" do
+    it "should be a proper self" do
+      expect(SingletonInheritanceExampleSubclass.a_contracted_self).to eq(SingletonInheritanceExampleSubclass)
+    end
+  end
+
+  describe "anonymous classes" do
+    let(:klass) do
+      Class.new do
+        include Contracts
+
+        Contract String => String
+        def greeting(name)
+          "hello, #{name}"
+        end
+      end
+    end
+
+    let(:obj) { klass.new }
+
+    it "does not fail when contract is satisfied" do
+      expect(obj.greeting("world")).to eq("hello, world")
+    end
+
+    it "fails with error when contract is violated" do
+      expect { obj.greeting(3) }.to raise_error(ContractError, /Actual: 3/)
+    end
+  end
+
+  describe "anonymous modules" do
+    let(:mod) do
+      Module.new do
+        include Contracts
+        include Contracts::Modules
+
+        Contract String => String
+        def greeting(name)
+          "hello, #{name}"
+        end
+
+        Contract String => String
+        def self.greeting(name)
+          "hello, #{name}"
+        end
+      end
+    end
+
+    let(:klass) do
+      Class.new.tap { |klass| klass.send(:include, mod) }
+    end
+
+    let(:obj) { klass.new }
+
+    it "does not fail when contract is satisfied" do
+      expect(obj.greeting("world")).to eq("hello, world")
+    end
+
+    it "fails with error when contract is violated" do
+      expect { obj.greeting(3) }.to raise_error(ContractError, /Actual: 3/)
+    end
+
+    context "when called on module itself" do
+      let(:obj) { mod }
+
+      it "does not fail when contract is satisfied" do
+        expect(obj.greeting("world")).to eq("hello, world")
+      end
+
+      it "fails with error when contract is violated" do
+        expect { obj.greeting(3) }.to raise_error(ContractError, /Actual: 3/)
+      end
+    end
+  end
+
   describe "instance methods" do
     it "should allow two classes to have the same method with different contracts" do
       a = A.new
@@ -96,11 +247,11 @@ RSpec.describe "Contracts:" do
 
   describe "class methods" do
     it "should pass for correct input" do
-      expect { Object.a_class_method(2) }.to_not raise_error
+      expect { GenericExample.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)
+      expect { GenericExample.a_class_method("bad") }.to raise_error(ContractError)
     end
   end
 
@@ -180,6 +331,10 @@ RSpec.describe "Contracts:" do
     it "should fail for incorrect input" do
       expect { @o.do_call(nil) }.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/)
+    end
   end
 
   describe "varargs" do
@@ -192,6 +347,39 @@ RSpec.describe "Contracts:" do
     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
+    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 {
+        @o.with_partial_sums(1, 2, 3)
+      }.to raise_error(ContractError, /Actual: nil/)
+
+      expect {
+        @o.with_partial_sums(1, 2, 3, lambda { |x| x })
+      }.to raise_error(ContractError, /Actual: #<Proc/)
+    end
+
+    context "when block has Func contract" do
+      it "should fail for incorrect input" do
+        expect {
+          @o.with_partial_sums_contracted(1, 2, "bad") { |partial_sum| 2 * partial_sum + 1 }
+        }.to raise_error(ContractError, /Actual: "bad"/)
+
+        expect {
+          @o.with_partial_sums_contracted(1, 2, 3)
+        }.to raise_error(ContractError, /Actual: nil/)
+      end
+    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