unified_matchers 0.1.5.0

data/lib/unified_matchers/matcher_result.rb

@@ -0,0 +1,71 @@
+# Copyright:: Copyright (c) 2006  Uttk Team. All rights reserved.
+# Author::    Gaelle Champarnaud  <gallooo@gmail.com>
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers/matcher_result.rb 23455 2006-05-09T10:59:14.845424Z pouillar  $
+
+module UnifiedMatchers
+
+  class MatcherResult
+
+    attr_reader :name, :data, :ref, :my
+
+    def initialize name, ref, my, message_ref, message_my, default_message, status, data=nil, message=nil
+      if status == true or status == false
+        @name = name
+        @status = status
+        @data = data
+        @ref = ref
+        @my = my
+        @message_ref = message_ref
+        @message_my = message_my
+        if message.nil?
+          message = default_message
+        end
+        @message_template = message
+      else
+        raise ArgumentError,
+          "The status must be true or false, not #{status}."
+      end
+    end
+
+    def success?
+      @status
+    end
+
+    def failure?
+      ! @status
+    end
+
+    def message
+      if defined? @message
+        @message
+      else
+        str = ''
+        str << 'not ' if failure?
+        str << @message_template
+        str.gsub!('%ref', compute_messages(@message_ref))
+        str.gsub!('%my',  compute_messages(@message_my))
+        @message = str
+      end
+    end
+
+    def compute_messages message
+      x = message.shift.inspect_for_unified_matchers
+      message.inject(x) { |accu, y| y.gsub('%x', accu) }
+    end
+
+    def to_s
+      if @name.nil?
+        message
+      else
+        "#@name: #{message}"
+      end
+    end
+
+    def method_missing *a, &b
+      @data.send(*a, &b)
+    end
+
+  end # class MatcherResult
+
+end # module UnifiedMatchers

data/lib/unified_matchers/matcher_results.rb

@@ -0,0 +1,46 @@
+# Copyright:: Copyright (c) 2006  Uttk Team. All rights reserved.
+# Author::    Gaelle Champarnaud  <gallooo@gmail.com>
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers/matcher_results.rb 23455 2006-05-09T10:59:14.845424Z pouillar  $
+
+module UnifiedMatchers
+
+  class MatcherResults
+
+    def initialize *matcher_results
+      @elements = matcher_results.flatten
+    end
+
+    def success?
+      @elements.all? { |x| x.success? }
+    end
+
+    def failure?
+      @elements.any? { |x| x.failure? }
+    end
+
+    def each &block
+      @elements.each(&block)
+    end
+
+    def first
+      @elements.first
+    end
+
+    def to_s
+      s = ''
+      each { |x| s << x.to_s << "\n" }
+      s
+    end
+
+    def << result
+      if result.respond_to? :each
+        result.each { |x| @elements << x }
+      else
+        @elements << result
+      end
+    end
+
+  end # class MatcherResults
+
+end # module UnifiedMatchers

data/lib/unified_matchers/stream_matcher.rb

@@ -0,0 +1,78 @@
+# Copyright:: Copyright (c) 2005  Uttk Team. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers/stream_matcher.rb 23258 2006-04-09T09:46:24.223538Z ertai  $
+
+
+module UnifiedMatchers
+
+  class StreamMatcher < UnifiedMatcher
+    make Concrete
+
+    rule :open
+    rule :io, :all => [ :rewind, :read ], :message => '%x.{rewind ; read}' do
+      rewind ; read
+    end
+    rule :to_s
+    final(String, String, :message => '%ref == %my') { |ref, my| ref == my }
+    final(Class, Object, :message => '%my.is_a? %ref') { |ref, my| my.is_a?(ref) }
+    final Regexp, String, :message => '%ref.match %my' do |ref, my|
+      r = ref.match(my) ; [ !! r, r ]
+    end
+
+  end # class StreamMatcher
+
+
+
+  test_section __FILE__ do
+
+    class TestStreamMatchers < ::Test::Unit::TestCase
+      include UnifiedMatchers::Assertions
+
+      def setup
+        self.matcher = StreamMatcher.new
+      end
+
+      def teardown
+      end
+
+      def test_stream_matcher
+        assert_failure 'a', 'b'
+        assert_success(/^a$/, 'a')
+        assert_success 'a', 'a'
+        assert_failure(/^a$/, /^a$/)
+        assert_success "(?-mix:^a$)", /^a$/
+        assert_success(/\d/, 4)
+        assert_success '42', 42
+        assert_success 42, '42'
+        s = StringIO.new
+        s << 'foo'
+        assert_success 'foo', s
+        assert_failure 'bar', s
+        assert_success 'foo', s
+        assert_success Integer, 42
+        assert_failure String, 42
+        assert_failure 42, Integer
+        TempPath.new do |t|
+          t.overwrite 'foo'
+          assert_success 'foo', t
+          assert_success(/fo+/, t.open)
+          assert_success t, t
+          f = t.open
+          assert_success f, f
+        end
+      end
+
+      def test_with_a_new_class
+        c = Class.new
+        assert_success(/^#<#<Class:.*>.*>$/, c.new)
+        StreamMatcher.rule(:test_with_a_new_class, c, :before => :to_s) { object_id }
+        assert_failure(/^#<#<Class:.*>.*>$/, c.new)
+        assert_success(/^\d+$/, c.new)
+      end
+
+    end # class TestStreamMatchers
+
+  end
+
+end # module UnifiedMatchers

data/lib/unified_matchers/strict_equality_based_matcher.rb

@@ -0,0 +1,44 @@
+# Copyright:: Copyright (c) 2005  Uttk Team. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers/strict_equality_based_matcher.rb 23258 2006-04-09T09:46:24.223538Z ertai  $
+
+
+module UnifiedMatchers
+
+  class StrictEqualityBasedMatcher < UnifiedMatcher
+    make Concrete
+
+    final(Object, Object, :message => '%ref.equal? %my') { |ref, my| ref.equal? my }
+
+  end # class StrictEqualityBasedMatcher
+
+
+
+  test_section __FILE__ do
+
+    class TestStrictEqualityBasedMatcher < ::Test::Unit::TestCase
+      include UnifiedMatchers::Assertions
+
+      def setup
+        self.matcher = StrictEqualityBasedMatcher.new
+      end
+
+      def teardown
+      end
+
+      def test_equality_based_matcher
+        assert_success 42, 42
+        assert_failure 42, 43
+        assert_failure '42', '42'
+        s = '42'
+        assert_success s, s
+        assert_failure '42', 42
+        assert_failure '42', '43'
+      end
+
+    end # class TestStrictEqualityBasedMatcher
+
+  end
+
+end # module UnifiedMatchers

data/lib/unified_matchers/unified_matcher.rb

@@ -0,0 +1,260 @@
+# Copyright:: Copyright (c) 2005  Uttk Team. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers/unified_matcher.rb 23455 2006-05-09T10:59:14.845424Z pouillar  $
+
+
+# @UnifiedMatcher@ is an abstract class. It contains the key-definitions:
+# list do
+#  * the class @Rule@,
+#
+#  * the methods @rule@ and @final@,
+#
+#  * the methods @delete_rule@, @delete_final@, @redefine_rule@ and
+#    @replace_rule@,
+#
+#  * the method @[]@, which is used when the user wants to compare two objects
+#    with an operator of UnifiedMatchers. This method first searches the final
+#    rule which suits to the class of the first object (@ref@), and eventually
+#    applies to this object a change (using the intermediate rules).
+#    Then it changes the second object (@my@) until its class is that that the
+#    final rule need.
+#    The result is an object of class MatcherResults.
+# end
+module UnifiedMatchers
+
+  class UnifiedMatcher
+    make Abstract
+
+    class_inheritable_hash :rules, :ref_triggers
+    class_inheritable_accessor :last_defined_rule, :order
+    self.rules = {}
+    self.ref_triggers = {}
+    self.order = []
+
+    class Rule
+
+      attr_reader :name, :message
+
+      def initialize matcher, name, *args, &block
+        unless name.is_a? Symbol
+          raise ArgumentError, "The name must be a symbol, not: #{name}"
+        end
+        @name = name
+        @conditions = {}
+        @message = nil
+        @pos = 0
+        for arg in args.flatten do
+          setup_arg arg, matcher
+        end
+        if @conditions.empty?
+          @conditions[:respond_to] = @name
+        end
+        case @pos
+        when 0
+          update_order name, matcher.last_defined_rule, 1, matcher #after
+        when 1
+        else raise ArgumentError,
+                "Don't define more than one position (:before or :after)"
+        end
+        if block.nil?
+          meth = @conditions[:respond_to]
+          @block = lambda { |x| x.send meth }
+          @message ||= "%x.#{meth}"
+        else
+          @block = block
+          @message ||= "%x.<rule #@name>"
+        end
+        matcher.last_defined_rule = name
+        matcher.rules = {@name => self}
+      end
+
+      def setup_arg arg, matcher
+        case arg
+        when Class then @conditions[:is_a] = arg
+        when Symbol then @conditions[:respond_to] = arg
+        when Hash
+          for k,v in arg do
+            case k
+            when :after
+              @pos += 1
+              update_order name, v, 1, matcher
+            when :before
+              @pos += 1
+              update_order name, v, 0, matcher
+            when :message
+              @message = v
+            else @conditions[k] = v
+            end
+          end
+        end
+      end
+      private :setup_arg
+
+      def update_order new, ref, offset, m
+        m.order = m.order - [new]
+        i = m.order.index ref
+        if i.nil?
+          if m.last_defined_rule.nil?
+            m.order = [new]
+          else
+            raise ArgumentError, "Undefined rule: #{ref}"
+          end
+        else
+          m.order = m.order[0..i-1+offset] + [new] + m.order[i+offset..-1]
+        end
+      end
+
+      def activable? anObject
+        activable_rec @conditions, anObject
+      end
+
+      def activable_rec condition, anObject
+        case condition
+        when Class then anObject.is_a? condition
+        when Symbol then anObject.respond_to? condition
+        when Hash
+          if condition.size != 1
+            raise ArgumentError, "Too much conditions, use :all or :any to" +
+            "combine them. (rule: #{name})"
+          end
+          k,v = condition.to_a.first
+          case k
+          when :is_a then anObject.is_a? v
+          when :respond_to then anObject.respond_to? v
+          when :all then v.all? { |x| activable_rec x, anObject }
+          when :any then v.any? { |x| activable_rec x, anObject }
+          else raise ArgumentError, "Bad key: #{k}"
+          end
+        else raise ArgumentError, "Bad condition: #{condition}"
+        end
+      end
+
+      def activate x
+        case @block.arity
+        when -1 then x.instance_eval(&@block)
+        when  1 then @block[x]
+        else raise ArgumentError, "Bad block arity: #{@block.arity}"
+        end
+      end
+
+    end # class Rule
+
+    Rule.new(self, :unified_matchers_first)
+
+    class << self
+
+      def rule *args, &block
+        Rule.new(self, *args, &block)
+      end
+
+      def final ref_class, my_class, options=nil, &block
+        raise ArgumentError, 'Need a block' if block.nil?
+        raise ArgumentError, "Need a class, not: #{ref_class}" unless ref_class.is_a? Class
+        raise ArgumentError, "Need a class, not: #{my_class}" unless my_class.is_a? Class
+        options = {} if options.nil?
+        raise ArgumentError, "Need a Hash, not: #{options.inspect}" unless options.is_a? Hash
+        options[:message] ||= "#{self}.final(#{ref_class} = %ref, #{my_class} = %my)"
+        self.ref_triggers = { ref_class => [my_class, options, block] }
+      end
+
+      def delete_rule aRuleName
+        self.last_defined_rule = nil if last_defined_rule == aRuleName
+        self.order = order - [aRuleName]
+        self.rules = {aRuleName => nil}
+      end
+
+      def delete_final aClass
+        self.ref_triggers = {aClass => nil}
+      end
+
+      def replace_rule old_name, new_name, *args, &block
+        #FIXME verify that there is no before or after
+        i = order.index old_name
+        delete_rule old_name
+        Rule.new(self, new_name, *args, &block)
+        self.order = order - [new_name]
+        self.order = order[0..i-1] + [new_name] + order[i..-1]
+      end
+
+      def redefine_rule name, *args, &block
+        replace_rule name, name, *args, &block
+      end
+
+    end # class << self
+
+    def [] ( ref, my, name=nil )
+      my_target_class, options, ref_trigger = nil, nil
+      message_ref = [ref]
+      rule_i = 0
+      rule = rules[order[rule_i]]
+      first = true
+      done = []
+      until (rule.nil? and not first) or ref_trigger do
+        first = false
+        ref_class = ref.class
+        ref_class.ancestors.each do |aModule|
+          if ref_triggers.has_key? aModule
+            my_target_class, options, ref_trigger = ref_triggers[aModule]
+            break
+          end
+        end
+        if ref_trigger.nil?
+          if rule.activable? ref
+            check_done rule, done
+            message_ref << rule.message
+            ref = rule.activate ref
+            rule_i = 0
+          else
+            rule_i += 1
+          end
+          rule = rules[order[rule_i]]
+        end
+      end
+      if ref_trigger.nil?
+        raise ArgumentError, "No final rule with this class #{ref.class}"
+      end
+      message_my = [my]
+      rule_i = 0
+      rule = rules[order[rule_i]]
+      done.clear
+      until my.class <= my_target_class or rule.nil? do
+        if rule.activable? my
+          check_done rule, done
+          message_my << rule.message
+          my = rule.activate my
+          rule_i = 0
+        else
+          rule_i += 1
+        end
+        rule = rules[order[rule_i]]
+      end
+      unless my.class <= my_target_class
+        raise ArgumentError, "No activable rule for #{my}"
+      end
+      if ref_trigger.arity == 3
+        result = ref_trigger[ref, my, self]
+      else
+        result = ref_trigger[ref, my]
+      end
+      case result
+      when MatcherResults then return result
+      else
+        result = [result] unless result.is_a? Array
+        m = MatcherResult.new(name, ref, my, message_ref, message_my,
+                              options[:message], *result)
+        return MatcherResults.new(m)
+      end
+    end # def []
+
+    def check_done rule, done
+      if done.include? rule
+        raise RuntimeError, "Possibly infinite rule activation" +
+          " (#{rule.name}). Perhaps you should use :before or :after."
+      end
+      done << rule
+    end
+
+  end # class UnifiedMatcher
+
+end # module UnifiedMatchers

data/lib/unified_matchers/version_id.rb

@@ -0,0 +1,10 @@
+# Copyright:: Copyright (c) 2006  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <nicolas.pouillard@gmail.com>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers/version_id.rb 53948 2007-01-14T14:04:05.765192Z ertai  $
+
+module UnifiedMatchers
+
+  VersionId = Version.parse("dev-ruby/unified_matchers-0.1")
+
+end # module UnifiedMatchers

data/lib/unified_matchers.rb

@@ -0,0 +1,41 @@
+# Copyright:: Copyright (c) 2005  Uttk Team. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: /w/fey/um/trunk/lib/unified_matchers.rb 24390 2006-07-09T20:59:27.061458Z ertai  $
+
+require 'pathname'
+
+lib = Pathname.new(__FILE__).dirname
+vendor = lib.parent + 'vendor'
+unless defined? CoreEx
+  $CORE_EX_VENDORS ||= []
+  $CORE_EX_VENDORS << vendor
+  file = vendor + 'core_ex' + 'lib' + 'core_ex'
+  if file.exist?
+    require file.to_s
+  else
+    require 'rubygems' unless ENV['NO_GEM']
+    require_gem 'core_ex'
+    require 'core_ex'
+  end
+end
+lib.load_path!
+suppress(LoadError) { require 'diff/lcs' }
+
+unless defined? RubyEx
+  module Abstract
+  end
+  module Concrete
+  end
+end
+
+module UnifiedMatchers
+
+  mattr_accessor :dir, :fixtures
+
+end # module UnifiedMatchers
+
+UM = UnifiedMatchers unless defined? UM
+UnifiedMatchers.dir = lib
+UnifiedMatchers.fixtures = lib.parent/'test'/'fixtures'
+UnifiedMatchers::Helpers.import!

data/test/check-pkg-unified_matchers.yml

@@ -0,0 +1,14 @@
+---
+
+# Run this suite with -S 'url: scheme://the/url/to/the/ruby_ex/package'
+UnifiedMatchers Package Test Suite: !S::Suite
+  contents:
+
+    - Checkout: !S::Checkout
+        url: <<url>>
+        fatal: true
+        weight: 0
+
+    - Check the package: !S::Import
+        import: <<checkout_dir>>/test/check.yml
+

data/test/check.yml

@@ -0,0 +1,8 @@
+---
+
+UnifiedMatchers test suite: !S::Iterate
+  over: !pathlist <<pwd>>/(*-suite).yml
+  iter: [it_file, it_name]
+  test:
+    Run the <<it_name>> test suite: !S::Import
+      import: !path <<it_file>>

data/test/fixtures/bird.txt

@@ -0,0 +1 @@
+bird

data/test/fixtures/birds.txt

@@ -0,0 +1 @@
+birds

data/test/fixtures/my.file

@@ -0,0 +1 @@
+foo/bar

data/test/fixtures/pluralizer

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+
+def main()
+  if (ARGV.length == 0)
+    word = STDIN.gets.chomp
+  else
+    word = ARGV[0]
+  end
+  if word =~ /\d/
+    STDERR.puts "bad word: #{word}"
+    exit 1
+  else
+    puts word + "s"
+  end
+end
+
+main

data/test/sanity/multiple-requires.yml

@@ -0,0 +1,62 @@
+---
+
+UnifiedMatchers Sanity Multiple Requires Test Suite: !S::Suite
+
+  attributes: !S::Cmd
+    command: <<ruby>>
+    exit: 0
+    error: ""
+    output: !re 0 failures, 0 errors$
+    args: -I<<pwd>>/../../lib
+
+  contents:
+    - require:
+        input: |
+          require 'unified_matchers'
+          Dependencies.mechanism = :require
+          require 'test/unit'
+          class TC_ < Test::Unit::TestCase
+            def test_definitions
+              path_list = PathList['<<pwd>>/../../lib/(**/*).rb']
+              path_list.each do |_, path|
+                require path
+                path += '.rb'
+                assert($LOADED_FEATURES.include?(path),
+                      "#{path} not in $LOADED_FEATURES #{$LOADED_FEATURES.inspect}")
+              end
+            end
+          end
+
+    - require dependency:
+        input: |
+          require 'unified_matchers'
+          require 'test/unit'
+          class TC_ < Test::Unit::TestCase
+            def test_definitions
+              lib_dir = '<<pwd>>/../../lib'.to_path
+              lib_dir.load_path!
+              path_list = PathList[lib_dir/'(**/*).rb']
+              path_list.each do |_, path|
+                require_dependency path
+                assert(Dependencies.loaded.include?(path),
+                      "#{path} not in Dependencies.loaded #{Dependencies.loaded.inspect}")
+              end
+            end
+          end
+
+    - lazy loading:
+        input: |
+          require 'unified_matchers'
+          require 'test/unit'
+          class TC_ < Test::Unit::TestCase
+            def test_definitions
+              PathList['<<pwd>>/../../lib/(**/*).rb'].each do |path, name|
+                assert_nothing_raised("cannot camelize #{name}") do
+                  @camel = name.camelize
+                end
+                assert_nothing_raised("#@camel not defined?") do
+                  @camel.constantize
+                end
+              end
+            end
+          end