ruby_contracts 0.2.5 → 0.3.0

data/lib/ruby_contracts/contract.rb

@@ -0,0 +1,19 @@
+module Contracts
+  class Contract
+    def satisfied?(context, arguments, result=nil)
+      raise "Contract.satisfied? must be implemented in subclasses."
+    end
+
+    def message
+      raise "Contract.message must be implemented in subclasses."
+    end
+
+    def before?
+      raise "Contract.before? must be implemented in subclasses."
+    end
+
+    def after?
+      raise "Contract.after? must be implemented in subclasses."
+    end
+  end
+end

data/lib/ruby_contracts/dsl.rb

@@ -0,0 +1,131 @@
+module Contracts
+  module DSL
+    def self.included(base)
+      if ENV['ENABLE_ASSERTION']
+        base.extend Contracts::DSL::ClassMethods
+        base.__contracts_initialize
+      else
+        base.extend Contracts::DSL::EmptyClassMethods
+      end
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        super
+        subclass.__contracts_initialize
+      end
+
+      def __contracts_initialize
+        @__contracts = Contracts::List.new
+        @__contracts_for = {}
+      end
+
+      def __contracts_for(name, current_contracts=nil)
+        if @__contracts_for.has_key?(name) && !current_contracts
+          @__contracts_for[name]
+        else
+          contracts = ancestors[1..-1].reverse.reduce([]) do |c, klass|
+            ancestor_hash = klass.instance_variable_get('@__contracts_for')
+            c += ancestor_hash[name] if ancestor_hash && ancestor_hash.has_key?(name)
+            c
+          end
+          contracts << current_contracts if current_contracts
+          @__contracts_for[name] = contracts
+        end
+      end
+
+      def __contract_failure!(name, message, result, *args)
+        args.pop if args.last.kind_of?(Proc)
+        raise Contracts::Error.new("#{self}##{name}(#{args.join ', '}) => #{result || "?"} ; #{message}.")
+      end
+
+      def type(options)
+        @__contracts << Contracts::InputType.new(options[:in].kind_of?(Array) ? options[:in] : [options[:in]])   if options.has_key?(:in)
+        @__contracts << Contracts::OutputType.new(options[:out]) if options.has_key?(:out)
+      end
+
+      def pre(message=nil, &block)
+        @__contracts << Contracts::Precondition.new(message, block)
+      end
+
+      def post(message=nil, &block)
+        @__contracts << Contracts::Postcondition.new(message, block)
+      end
+
+      def method_added(name)
+        super
+
+        return if @__skip_other_contracts_definitions
+
+        __contracts = __contracts_for(name.to_s, @__contracts)
+        @__contracts = Contracts::List.new
+
+        if !__contracts.empty?
+          @__skip_other_contracts_definitions = true
+          original_method_name = "#{name}_without_contracts"
+          define_method(original_method_name, instance_method(name))
+
+          method = <<-EOM
+            def #{name}(*args, &block)
+              __args = block.nil? ? args : args + [block]
+              self.class.__eval_before_contracts("#{name}", self, __args)
+              result = #{original_method_name}(*args, &block)
+              self.class.__eval_after_contracts("#{name}", self, __args, result)
+              return result
+            end
+          EOM
+
+          class_eval method
+
+          @__skip_other_contracts_definitions = false
+        end
+      end
+
+      def __eval_before_contracts(name, context, arguments)
+        last_failure_msg = nil
+        __contracts_for(name).each do |contracts|
+          next if contracts.empty?
+          success = true
+          contracts.before_contracts.each do |contract|
+            begin
+              unless satisfied = contract.satisfied?(context, arguments)
+                last_failure_msg = contract.message
+                success = false
+                break
+              end
+            rescue
+              last_failure_msg = "Contract evaluation failed with #{$!} for #{contract.class} #{contract.message}"
+              success = false
+              break
+            end
+          end
+          return if success
+        end
+
+        __contract_failure!(name, last_failure_msg, nil, arguments) if last_failure_msg
+      end
+
+      def __eval_after_contracts(name, context, arguments, result)
+        __contracts_for(name).each do |contracts|
+          next if contracts.empty?
+          contracts.after_contracts.each do |contract|
+            begin
+              unless satisfied = contract.satisfied?(context, arguments, result)
+              __contract_failure!(name, contract.message, result, arguments)
+                break
+              end
+            rescue
+              __contract_failure!(name, "Contract evaluation failed with #{$!} for #{contract.class} #{contract.message}", result, arguments)
+            end
+          end
+        end
+      end
+    end
+
+    module EmptyClassMethods
+      def type(*args) ; end
+      def pre(*args) ; end
+      def post(*args) ; end
+    end
+  end
+end

data/lib/ruby_contracts/input_type.rb

@@ -0,0 +1,41 @@
+module Contracts
+  class InputType < Precondition
+    attr_reader :message
+
+    def initialize(expected_classes)
+      @expected_classes = expected_classes
+      @expected_argument_count = expected_classes.size
+    end
+
+    def satisfied?(context, arguments, result=nil)
+      if !match_size?(arguments)
+        @message = "the method expect #{@expected_argument_count} arguments when #{arguments.size} was given"
+        false
+      elsif unmatched = unmatched_type_from(arguments)
+        i, arg, expected_klass = unmatched
+        @message = "the method expect a kind of #{expected_klass} for argument ##{i} when a kind of #{arg.class} was given"
+        false
+      else
+        true
+      end
+    end
+
+    private
+
+      def match_size?(arguments)
+        arguments.size == @expected_argument_count
+      end
+
+      def unmatched_type_from(arguments)
+        unmatched = nil
+        arguments.zip(@expected_classes).each_with_index do |(arg, klass), i|
+          unless arg.kind_of?(klass)
+            unmatched = [i, arg, klass]
+            break
+          end
+        end
+        unmatched
+      end
+  end
+end
+

data/lib/ruby_contracts/list.rb

@@ -0,0 +1,11 @@
+module Contracts
+  class List < Array
+    def before_contracts
+      self.class.new(select{ |contract| contract.before? })
+    end
+
+    def after_contracts
+      self.class.new(select{ |contract| contract.after? })
+    end
+  end
+end

data/lib/ruby_contracts/output_type.rb

@@ -0,0 +1,16 @@
+module Contracts
+  class OutputType < Postcondition
+    def initialize(expected_class)
+      @expected_class = expected_class
+    end
+
+    def message
+      "the result must be an kind of #{@expected_class}"
+    end
+
+    def satisfied?(context, arguments, result=nil)
+      result.kind_of? @expected_class
+    end
+  end
+end
+

data/lib/ruby_contracts/postcondition.rb

@@ -0,0 +1,22 @@
+module Contracts
+  class Postcondition < Contract
+    attr_reader :message
+
+    def initialize(message, block)
+      @message = "invalid postcondition: #{message || 'no message given'}"
+      @block = block
+    end
+
+    def satisfied?(context, arguments, result=nil)
+      context.instance_exec(result, *arguments, &@block)
+    end
+
+    def before?
+      false
+    end
+
+    def after?
+      true
+    end
+  end
+end

data/lib/ruby_contracts/precondition.rb

@@ -0,0 +1,22 @@
+module Contracts
+  class Precondition < Contract
+    attr_reader :message
+
+    def initialize(message, block)
+      @message = "invalid precondition: #{message || 'no message given'}"
+      @block = block
+    end
+
+    def satisfied?(context, arguments, result=nil)
+      context.instance_exec(*arguments, &@block)
+    end
+
+    def before?
+      true
+    end
+
+    def after?
+      false
+    end
+  end
+end

data/lib/ruby_contracts/version.rb

@@ -1,3 +1,3 @@
 module RubyContracts
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

data/lib/ruby_contracts.rb

@@ -3,163 +3,11 @@ require "ruby_contracts/version"
 module Contracts
   class Error < Exception ; end
 
-  # When it is used with @__contracts_for:
-  #   before key must contain a disjunction of conjunction with preconditions
-  #   after key must contain a conjunction with postconditions
-  #
-  # When it is used with @__contracts:
-  #   before key must contain a conjunction
-  #   after key must contain a conjunction
-  def self.empty_contracts
-    {:before => [], :after => []}
-  end
-
-  module DSL
-    def self.included(base)
-      base.extend Contracts::DSL::ClassMethods
-      base.__contracts_initialize
-    end
-
-    module ClassMethods
-      def inherited(subclass)
-        super
-        subclass.__contracts_initialize
-      end
-
-      def __contracts_initialize
-        @__contracts = Contracts.empty_contracts
-        @__contracts_for = {}
-      end
-
-      def __contracts_for(name, current_contracts=nil)
-        inherited_contracts = ancestors[1..-1].reduce(Contracts.empty_contracts) do |c, klass|
-          ancestor_hash = klass.instance_variable_get('@__contracts_for') || {}
-          c[:before] += ancestor_hash[name][:before] if ancestor_hash.has_key?(name)
-          c[:after] += ancestor_hash[name][:after] if ancestor_hash.has_key?(name)
-          c
-        end
-
-        if current_contracts
-          inherited_contracts[:before] << current_contracts[:before] unless current_contracts[:before].empty?
-          inherited_contracts[:after] += current_contracts[:after] unless current_contracts[:after].empty?
-        end
-
-        inherited_contracts
-      end
-
-      def __contract_failure!(name, message, result, *args)
-        args.pop if args.last.kind_of?(Proc)
-        raise Contracts::Error.new("#{self}##{name}(#{args.join ', '}) => #{result || "?"} ; #{message}.")
-      end
-
-      def type(options)
-        @__contracts[:before] << [:type, options[:in]] if ENV['ENABLE_ASSERTION'] && options.has_key?(:in)
-        @__contracts[:after] << [:type, options[:out]] if ENV['ENABLE_ASSERTION'] && options.has_key?(:out)
-      end
-
-      def pre(message=nil, &block)
-        @__contracts[:before] << [:params, message, block] if ENV['ENABLE_ASSERTION']
-      end
-
-      def post(message=nil, &block)
-        @__contracts[:after] << [:result, message, block] if ENV['ENABLE_ASSERTION']
-      end
-
-      def method_added(name)
-        super
-
-        return unless ENV['ENABLE_ASSERTION']
-        return if @__skip_other_contracts_definitions
-        return if @__contracts_for.has_key?(name)
-
-        __contracts = @__contracts_for[name] ||= __contracts_for(name, @__contracts)
-        @__contracts = Contracts.empty_contracts
-
-        if !__contracts[:before].empty? || !__contracts[:after].empty?
-          @__skip_other_contracts_definitions = true
-          original_method_name = "#{name}__with_contracts"
-          define_method(original_method_name, instance_method(name))
-
-          count = 0
-          before_contracts = __contracts[:before].reduce("__before_contracts_disjunction = []\n") do |code, contracts_disjunction|
-            contracts_conjunction = contracts_disjunction.reduce("__before_contracts_conjunction = []\n") do |code, contract|
-              type, *args = contract
-              case type
-              when :type
-                classes = args[0]
-                code << "if __before_contracts_conjunction.empty? then\n"
-                code << "  if __args.size < #{classes.size} then\n"
-                code << "    __before_contracts_conjunction << ['#{name}', \"need at least #{classes.size} arguments (%i given)\" % [__args.size], nil, *args]\n"
-                code << "  else\n"
-                conditions = []
-                classes.each_with_index{ |klass, i| conditions << "__args[#{i}].kind_of?(#{klass})" }
-                code << "    if !(#{conditions.join(' && ')}) then\n"
-                code << "      __before_contracts_conjunction << ['#{name}', 'input type error', nil, *__args]\n"
-                code << "    end\n"
-                code << "  end\n"
-                code << "end\n"
-                code
-
-              when :params
-                # Define a method that verify the assertion
-                contract_method_name = "__verify_contract_#{name}_in_#{count = count + 1}"
-                define_method(contract_method_name) { |*params| self.instance_exec(*params, &args[1]) }
-
-                code << "if __before_contracts_conjunction.empty? then\n"
-                code << "  if !#{contract_method_name}(*__args) then\n"
-                code << "    __before_contracts_conjunction << ['#{name}', \"invalid precondition: #{args[0]}\", nil, *__args]\n"
-                code << "  end\n"
-                code << "end\n"
-                code
-              else
-                code
-              end
-            end
-            code << contracts_conjunction
-            code << "__before_contracts_disjunction << __before_contracts_conjunction\n"
-            code
-          end
-          before_contracts << "unless __before_contracts_disjunction.any?{|conj| conj.empty?} then\n"
-          before_contracts << "  self.class.__contract_failure!(*__before_contracts_disjunction.find{|conj| !conj.empty?}.first)\n"
-          before_contracts << "end\n"
-
-          after_contracts = __contracts[:after].reduce("") do |code, contract|
-            type, *args = contract
-            case type
-            when :type
-              code << "if !result.kind_of?(#{args[0]}) then\n"
-              code << "  self.class.__contract_failure!(name, \"result must be a kind of '#{args[0]}' not '%s'\" % [result.class.to_s], result, *__args)\n"
-              code << "end\n"
-              code
-            when :result
-              # Define a method that verify the assertion
-              contract_method_name = "__verify_contract_#{name}_out_#{count = count + 1}"
-              define_method(contract_method_name) { |*params| self.instance_exec(*params, &args[1]) }
-
-              code << "if !#{contract_method_name}(result, *__args) then\n"
-              code << "  self.class.__contract_failure!('#{name}', \"invalid postcondition: #{args[0]}\", result, *__args)\n"
-              code << "end\n"
-              code
-            else
-              code
-            end
-          end
-
-          method = <<-EOM
-            def #{name}(*args, &block)
-              __args = block.nil? ? args : args + [block]
-              #{before_contracts}
-              result = #{original_method_name}(*args, &block)
-              #{after_contracts}
-              return result
-            end
-          EOM
-
-          class_eval method
-
-          @__skip_other_contracts_definitions = false
-        end
-      end
-    end
-  end
+  autoload :List,          'ruby_contracts/list'
+  autoload :Contract,      'ruby_contracts/contract'
+  autoload :Precondition,  'ruby_contracts/precondition'
+  autoload :Postcondition, 'ruby_contracts/postcondition'
+  autoload :InputType,     'ruby_contracts/input_type'
+  autoload :OutputType,    'ruby_contracts/output_type'
+  autoload :DSL,           'ruby_contracts/dsl'
 end

data/test/inheritance_test.rb

@@ -35,6 +35,15 @@ describe 'the contracts behavior in an inheritance context' do
           child.increment(3)
           proc { child.increment(2) }.must_raise Contracts::Error
         end
+
+        it 'fails with the deepest failing precondition message' do
+          begin
+            child.increment(2)
+            true.must_equal false # Force a failure
+          rescue Contracts::Error
+            $!.message.must_include 'n >= minimum_incr'
+          end
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_contracts
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-15 00:00:00.000000000 Z
+date: 2013-06-16 00:00:00.000000000 Z
 dependencies: []
 description: Micro DSL to add pre & post condition to methods. It tries to bring some
   design by contract in the Ruby world.
@@ -25,6 +25,13 @@ files:
 - README.md
 - Rakefile
 - lib/ruby_contracts.rb
+- lib/ruby_contracts/contract.rb
+- lib/ruby_contracts/dsl.rb
+- lib/ruby_contracts/input_type.rb
+- lib/ruby_contracts/list.rb
+- lib/ruby_contracts/output_type.rb
+- lib/ruby_contracts/postcondition.rb
+- lib/ruby_contracts/precondition.rb
 - lib/ruby_contracts/version.rb
 - ruby_contracts.gemspec
 - test/fixtures/inheritance_classes.rb