RubyGems - test-unit-ext - Versions diffs - 0.1.0 → 0.2.0 - Mend

test-unit-ext 0.1.0 → 0.2.0

Files changed (15) hide show

data/NEWS.en +6 -0
data/NEWS.ja +6 -0
data/html/news.html +9 -1
data/html/news.html.en +9 -1
data/html/news.html.ja +9 -1
data/lib/test-unit-ext.rb +2 -0
data/lib/test-unit-ext/assertions.rb +30 -0
data/lib/test-unit-ext/diff.rb +375 -83
data/lib/test-unit-ext/priority.rb +2 -2
data/lib/test-unit-ext/version.rb +1 -1
data/lib/test-unit-ext/xml-report.rb +226 -0
data/test/test_diff.rb +275 -34
data/test/test_metadata.rb +14 -5
data/test/test_xml_report.rb +163 -0
metadata +6 -2

data/NEWS.en CHANGED Viewed

@@ -2,6 +2,12 @@
 = NEWS
+== 0.2.0: 2008-03-03
+  * Supported XML report.
+    * Added --xml-report option.
+  * Supported diff output for assert_equal.
 == 0.1.0: 2008-02-21
   * Initial release.

data/NEWS.ja CHANGED Viewed

@@ -2,6 +2,12 @@
 = NEWS.ja
+== 0.2.0: 2008-03-03
+  * XML出力のサポート。
+    * --xml-reportオプションの追加。
+  * assert_equal時のdiff出力のサポート。
 == 0.1.0: 2008-02-21
   * 最初のリリース。

data/html/news.html CHANGED Viewed

@@ -9,7 +9,15 @@
 </head>
 <body>
 <h1><a name="label-0" id="label-0">NEWS</a></h1><!-- RDLabel: "NEWS" -->
-<h2><a name="label-1" id="label-1">0.1.0: 2008-02-21</a></h2><!-- RDLabel: "0.1.0: 2008-02-21" -->
+<h2><a name="label-1" id="label-1">0.2.0: 2008-03-03</a></h2><!-- RDLabel: "0.2.0: 2008-03-03" -->
+<ul>
+<li>Supported XML report.
+<ul>
+<li>Added --xml-report option.</li>
+</ul></li>
+<li>Supported diff output for assert_equal.</li>
+</ul>
+<h2><a name="label-2" id="label-2">0.1.0: 2008-02-21</a></h2><!-- RDLabel: "0.1.0: 2008-02-21" -->
 <ul>
 <li>Initial release.</li>
 </ul>

data/html/news.html.en CHANGED Viewed

@@ -9,7 +9,15 @@
 </head>
 <body>
 <h1><a name="label-0" id="label-0">NEWS</a></h1><!-- RDLabel: "NEWS" -->
-<h2><a name="label-1" id="label-1">0.1.0: 2008-02-21</a></h2><!-- RDLabel: "0.1.0: 2008-02-21" -->
+<h2><a name="label-1" id="label-1">0.2.0: 2008-03-03</a></h2><!-- RDLabel: "0.2.0: 2008-03-03" -->
+<ul>
+<li>Supported XML report.
+<ul>
+<li>Added --xml-report option.</li>
+</ul></li>
+<li>Supported diff output for assert_equal.</li>
+</ul>
+<h2><a name="label-2" id="label-2">0.1.0: 2008-02-21</a></h2><!-- RDLabel: "0.1.0: 2008-02-21" -->
 <ul>
 <li>Initial release.</li>
 </ul>

data/html/news.html.ja CHANGED Viewed

@@ -9,7 +9,15 @@
 </head>
 <body>
 <h1><a name="label-0" id="label-0">NEWS.ja</a></h1><!-- RDLabel: "NEWS.ja" -->
-<h2><a name="label-1" id="label-1">0.1.0: 2008-02-21</a></h2><!-- RDLabel: "0.1.0: 2008-02-21" -->
+<h2><a name="label-1" id="label-1">0.2.0: 2008-03-03</a></h2><!-- RDLabel: "0.2.0: 2008-03-03" -->
+<ul>
+<li>XML出力のサポート。
+<ul>
+<li>--xml-reportオプションの追加。</li>
+</ul></li>
+<li>assert_equal時のdiff出力のサポート。</li>
+</ul>
+<h2><a name="label-2" id="label-2">0.1.0: 2008-02-21</a></h2><!-- RDLabel: "0.1.0: 2008-02-21" -->
 <ul>
 <li>最初のリリース。</li>
 </ul>

data/lib/test-unit-ext.rb CHANGED Viewed

@@ -9,3 +9,5 @@ require "test-unit-ext/priority"
 require "test-unit-ext/backtrace-filter"
 require "test-unit-ext/long-display-for-emacs"
 require "test-unit-ext/metadata"
+require "test-unit-ext/xml-report"
+require "test-unit-ext/assertions"

data/lib/test-unit-ext/assertions.rb ADDED Viewed

@@ -0,0 +1,30 @@
+require "test/unit/testcase"
+module Test
+  module Unit
+    module AssertionsWithDiff
+      def assert_equal(expected, actual, message=nil)
+        super
+      rescue AssertionFailedError
+        expected = PP.pp(expected, "") unless expected.is_a?(String)
+        actual = PP.pp(actual, "") unless actual.is_a?(String)
+        diff = Diff.readable(expected, actual)
+        if /^[\?\-\+].{79}/ =~ diff
+          folded_diff = Diff.readable(fold(expected), fold(actual))
+          diff = "#{diff}\nfolded diff:\n#{folded_diff}"
+        end
+        raise $!, "#{$!.message}\ndiff:\n#{diff}", $@
+      end
+      def fold(string)
+        string.split(/\n/).collect do |line|
+          line.gsub(/(.{78})/, "\\1\n")
+        end.join("\n")
+      end
+    end
+    class TestCase
+      include AssertionsWithDiff
+    end
+  end
+end

data/lib/test-unit-ext/diff.rb CHANGED Viewed

@@ -1,102 +1,59 @@
-# port of ndiff in Python's difflib.
+# port of Python's difflib.
 module Test
   module Diff
     class SequenceMatcher
-      def initialize(from, to)
+      def initialize(from, to, &junk_predicate)
         @from = from
         @to = to
+        @junk_predicate = junk_predicate
         update_to_indexes
       end
       def longest_match(from_start, from_end, to_start, to_end)
-        best_from, best_to, best_size = from_start, to_start, 0
-        lengths = {}
-        from_start.upto(from_end) do |i|
-          new_lengths = {}
-          (@to_indexes[@from[i]] || []).each do |j|
-            next if j < to_start
-            break if j >= to_end
-            k = new_lengths[j] = (lengths[j - 1] || 0) + 1
-            if k > best_size
-              best_from, best_to, best_size = i - k + 1, j - k + 1, k
-            end
-          end
-          lengths = new_lengths
-        end
-        while best_from > from_start and best_to > to_start and
-            @from[best_from - 1] == @to[best_to - 1]
-          best_from -= 1
-          best_to -= 1
-          best_size += 1
-        end
-        while best_from + best_size <= from_end and
-            best_to + best_size <= to_end and
-            @from[best_from + best_size] == @to[best_to + best_size]
-          best_size += 1
+        best_info = find_best_match_position(from_start, from_end,
+                                             to_start, to_end)
+        unless @junks.empty?
+          args = [from_start, from_end, to_start, to_end]
+          best_info = adjust_best_info_with_junk_predicate(false, best_info,
+                                                           *args)
+          best_info = adjust_best_info_with_junk_predicate(true, best_info,
+                                                           *args)
         end
-        [best_from, best_to, best_size]
+        best_info
       end
-      def matching_blocks
-        queue = [[0, @from.size - 1, 0, @to.size - 1]]
-        blocks = []
-        until queue.empty?
-          from_start, from_end, to_start, to_end = queue.pop
-          match_info = longest_match(from_start, from_end, to_start, to_end)
-          match_from_index, match_to_index, size = match_info
-          unless size.zero?
-            blocks << match_info
-            if from_start < match_from_index and to_start < match_to_index
-              queue.push([from_start, match_from_index,
-                          to_start, match_to_index])
-            end
-            if match_from_index + size < from_end and
-                match_to_index + size < to_end
-              queue.push([match_from_index + size, from_end,
-                          match_to_index + size, to_end])
-            end
-          end
-        end
-        non_adjacent = []
+      def blocks
+        _blocks = []
         prev_from_index = prev_to_index = prev_size = 0
-        blocks.sort.each do |from_index, to_index, size|
+        matches.sort.each do |from_index, to_index, size|
           if prev_from_index + prev_size == from_index and
               prev_to_index + prev_size == to_index
             prev_size += size
           else
             unless prev_size.zero?
-              non_adjacent << [prev_from_index, prev_to_index, prev_size]
+              _blocks << [prev_from_index, prev_to_index, prev_size]
             end
-            prev_from_index, prev_to_index, prev_size =
-              from_index, to_index, size
+            prev_from_index = from_index
+            prev_to_index = to_index
+            prev_size = size
           end
         end
         unless prev_size.zero?
-          non_adjacent << [prev_from_index, prev_to_index, prev_size]
+          _blocks << [prev_from_index, prev_to_index, prev_size]
         end
-        non_adjacent << [@from.size, @to.size, 0]
-        non_adjacent
+        _blocks << [@from.size, @to.size, 0]
+        _blocks
       end
       def operations
         from_index = to_index = 0
         operations = []
-        matching_blocks.each do |match_from_index, match_to_index, size|
-          tag = nil
-          if from_index < match_from_index and to_index < match_to_index
-            tag = :replace
-          elsif from_index < match_from_index
-            tag = :delete
-          elsif to_index < match_to_index
-            tag = :insert
-          end
+        blocks.each do |match_from_index, match_to_index, size|
+          tag = determine_tag(from_index, to_index,
+                              match_from_index, match_to_index)
           if tag
             operations << [tag,
                            from_index, match_from_index,
@@ -110,16 +67,166 @@ module Test
                            match_to_index, to_index]
           end
         end
         operations
       end
+      def grouped_operations(context_size=nil)
+        context_size ||= 3
+        _operations = operations
+        _operations = [[:equal, 0, 0, 0, 0]] if _operations.empty?
+        expand_edge_equal_operations!(_operations, context_size)
+        group_window = context_size * 2
+        groups = []
+        group = []
+        _operations.each do |tag, from_start, from_end, to_start, to_end|
+          if tag == :equal and from_end - from_start > group_window
+            group << [tag,
+                      from_start,
+                      [from_end, from_start + context_size].min,
+                      to_start,
+                      [to_end, to_start + context_size].min]
+            groups << group
+            group = []
+            from_start = [from_start, from_end - context_size].max
+            to_start = [to_start, to_end - context_size].max
+          end
+          group << [tag, from_start, from_end, to_start, to_end]
+        end
+        groups << group unless group.empty?
+        groups
+      end
+      def ratio
+        matches = blocks.inject(0) {|result, block| result + block[-1]}
+        length = @from.length + @to.length
+        if length.zero?
+          1.0
+        else
+          2.0 * matches / length
+        end
+      end
       private
       def update_to_indexes
         @to_indexes = {}
-        @to.each_with_index do |line, i|
-          @to_indexes[line] ||= []
-          @to_indexes[line] << i
+        @junks = {}
+        each = @to.is_a?(String) ? :each_byte : :each
+        i = 0
+        @to.send(each) do |item|
+          @to_indexes[item] ||= []
+          @to_indexes[item] << i
+          i += 1
+        end
+        return if @junk_predicate.nil?
+        @to_indexes = @to_indexes.reject do |key, value|
+          junk = @junk_predicate.call(key)
+          @junks[key] = true if junk
+          junk
+        end
+      end
+      def find_best_match_position(from_start, from_end, to_start, to_end)
+        best_from, best_to, best_size = from_start, to_start, 0
+        sizes = {}
+        from_start.upto(from_end) do |from_index|
+          _sizes = {}
+          (@to_indexes[@from[from_index]] || []).each do |to_index|
+            next if to_index < to_start
+            break if to_index > to_end
+            size = _sizes[to_index] = (sizes[to_index - 1] || 0) + 1
+            if size > best_size
+              best_from = from_index - size + 1
+              best_to = to_index - size + 1
+              best_size = size
+            end
+          end
+          sizes = _sizes
+        end
+        [best_from, best_to, best_size]
+      end
+      def adjust_best_info_with_junk_predicate(should_junk, best_info,
+                                               from_start, from_end,
+                                               to_start, to_end)
+        best_from, best_to, best_size = best_info
+        while best_from > from_start and best_to > to_start and
+            (should_junk ?
+             @junks.has_key?(@to[best_to]) :
+             !@junks.has_key?(@to[best_to])) and
+            @from[best_from] == @to[best_to]
+          best_from -= 1
+          best_to -= 1
+          best_size += 1
+        end
+        while best_from + best_size < from_end and
+            best_to + best_size < to_end and
+            (should_junk ?
+             @junks.has_key?(@to[best_to + best_size]) :
+             !@junks.has_key?(@to[best_to + best_size])) and
+            @from[best_from + best_size] == @to[best_to + best_size]
+          best_size += 1
+        end
+        [best_from, best_to, best_size]
+      end
+      def matches
+        _matches = []
+        queue = [[0, @from.size - 1, 0, @to.size - 1]]
+        until queue.empty?
+          from_start, from_end, to_start, to_end = queue.pop
+          match = longest_match(from_start, from_end, to_start, to_end)
+          match_from_index, match_to_index, size = match
+          unless size.zero?
+            _matches << match
+            if from_start < match_from_index and
+                to_start < match_to_index
+              queue.push([from_start, match_from_index - 1,
+                          to_start, match_to_index - 1])
+            end
+            if match_from_index + size <= from_end and
+                match_to_index + size <= to_end
+              queue.push([match_from_index + size, from_end,
+                          match_to_index + size, to_end])
+            end
+          end
+        end
+        _matches
+      end
+      def determine_tag(from_index, to_index,
+                        match_from_index, match_to_index)
+        if from_index < match_from_index and to_index < match_to_index
+          :replace
+        elsif from_index < match_from_index
+          :delete
+        elsif to_index < match_to_index
+          :insert
+        else
+          nil
+        end
+      end
+      def expand_edge_equal_operations!(_operations, context_size)
+        tag, from_start, from_end, to_start, to_end = _operations[0]
+        if tag == :equal
+          _operations[0] = [tag,
+                            [from_start, from_end - context_size].max,
+                            from_end,
+                            [to_start, to_end - context_size].max,
+                            to_end]
+        end
+        tag, from_start, from_end, to_start, to_end = _operations[-1]
+        if tag == :equal
+          _operations[-1] = [tag,
+                             from_start,
+                             [from_end, from_start + context_size].min,
+                             to_start,
+                             [to_end, to_start + context_size].min]
         end
       end
     end
@@ -130,20 +237,27 @@ module Test
         @to = to
       end
-      def compare
+      private
+      def tag(mark, contents)
+        contents.collect {|content| "#{mark}#{content}"}
+      end
+    end
+    class ReadableDiffer < Differ
+      def diff(options={})
         result = []
         matcher = SequenceMatcher.new(@from, @to)
         matcher.operations.each do |args|
           tag, from_start, from_end, to_start, to_end = args
           case tag
           when :replace
-            result.concat(fancy_replace(from_start, from_end, to_start, to_end))
+            result.concat(diff_lines(from_start, from_end, to_start, to_end))
           when :delete
-            result.concat(tagging('-', @from[from_start..from_end]))
+            result.concat(tag_deleted(@from[from_start...from_end]))
           when :insert
-            result.concat(tagging('+', @to[to_start..to_end]))
+            result.concat(tag_inserted(@to[to_start...to_end]))
           when :equal
-            result.concat(tagging(' ', @from[from_start..from_end]))
+            result.concat(tag_equal(@from[from_start...from_end]))
           else
             raise "unknown tag: #{tag}"
           end
@@ -152,8 +266,98 @@ module Test
       end
       private
-      def tagging(tag, contents)
-        contents.collect {|content| "#{tag} #{content}"}
+      def tag_deleted(contents)
+        tag("- ", contents)
+      end
+      def tag_inserted(contents)
+        tag("+ ", contents)
+      end
+      def tag_equal(contents)
+        tag("  ", contents)
+      end
+      def diff_lines(from_start, from_end, to_start, to_end)
+        best_ratio, cut_off = 0.74, 0.75
+        from_equal_index = to_equal_index = nil
+        best_from_index = best_to_index = nil
+        to_start.upto(to_end - 1) do |to_index|
+          from_start.upto(from_end - 1) do |from_index|
+            if @from[from_index] == @to[to_index]
+              from_equal_index ||= from_index
+              to_equal_index ||= to_index
+              next
+            end
+            matcher = SequenceMatcher.new(@from[from_index], @to[to_index],
+                                          &method(:space_character?))
+            if matcher.ratio > best_ratio
+              best_ratio = matcher.ratio
+              best_from_index = from_index
+              best_to_index = to_index
+            end
+          end
+        end
+        if best_ratio < cut_off
+          if from_equal_index.nil?
+            tagged_from = tag_deleted(@from[from_start...from_end])
+            tagged_to = tag_inserted(@to[to_start...to_end])
+            if to_end - to_start < from_end - from_start
+              return tagged_to + tagged_from
+            else
+              return tagged_from + tagged_to
+            end
+          end
+          best_from_index = from_equal_index
+          best_to_index = to_equal_index
+          best_ratio = 1.0
+        else
+          from_equal_index = nil
+        end
+        _diff_lines(from_start, best_from_index, to_start, best_to_index) +
+          diff_line(@from[best_from_index], @to[best_to_index]) +
+          _diff_lines(best_from_index + 1, from_end, best_to_index + 1, to_end)
+      end
+      def _diff_lines(from_start, from_end, to_start, to_end)
+        if from_start < from_end
+          if to_start < to_end
+            diff_lines(from_start, from_end, to_start, to_end)
+          else
+            tag_deleted(@from[from_start...from_end])
+          end
+        else
+          tag_inserted(@to[to_start...to_end])
+        end
+      end
+      def diff_line(from_line, to_line)
+        from_tags = ""
+        to_tags = ""
+        matcher = SequenceMatcher.new(from_line, to_line,
+                                      &method(:space_character?))
+        matcher.operations.each do |tag, from_start, from_end, to_start, to_end|
+          from_length = from_end - from_start
+          to_length = to_end - to_start
+          case tag
+          when :replace
+            from_tags << "^" * from_length
+            to_tags << "^" * to_length
+          when :delete
+            from_tags << "-" * from_length
+          when :insert
+            to_tags << "+" * to_length
+          when :equal
+            from_tags << " " * from_length
+            to_tags << " " * to_length
+          else
+            raise "unknown tag: #{tag}"
+          end
+        end
+        format_diff_point(from_line, to_line, from_tags, to_tags)
       end
       def format_diff_point(from_line, to_line, from_tags, to_tags)
@@ -163,9 +367,9 @@ module Test
         from_tags = from_tags[common..-1].rstrip
         to_tags = to_tags[common..-1].rstrip
-        result = ["- #{from_line}"]
+        result = tag_deleted([from_line])
         result << "? #{"\t" * common}#{from_tags}" unless from_tags.empty?
-        result << "+ #{to_line}"
+        result.concat(tag_inserted([to_line]))
         result << "? #{"\t" * common}#{to_tags}" unless to_tags.empty?
         result
       end
@@ -177,11 +381,99 @@ module Test
         end
         n
       end
+      def space_character?(character)
+        [" "[0], "\t"[0]].include?(character)
+      end
+    end
+    class UnifiedDiffer < Differ
+      def diff(options={})
+        groups = SequenceMatcher.new(@from, @to).grouped_operations
+        return [] if groups.empty?
+        return [] if same_content?(groups)
+        show_context = options[:show_context]
+        show_context = true if show_context.nil?
+        result = ["--- #{options[:from_label]}".rstrip,
+                  "+++ #{options[:to_label]}".rstrip]
+        groups.each do |operations|
+          result << format_summary(operations, show_context)
+          operations.each do |args|
+            operation_tag, from_start, from_end, to_start, to_end = args
+            case operation_tag
+            when :replace
+              result.concat(tag("-", @from[from_start...from_end]))
+              result.concat(tag("+", @to[to_start...to_end]))
+            when :delete
+              result.concat(tag("-", @from[from_start...from_end]))
+            when :insert
+              result.concat(tag("+", @to[to_start...to_end]))
+            when :equal
+              result.concat(tag(" ", @from[from_start...from_end]))
+            end
+          end
+        end
+        result
+      end
+      private
+      def same_content?(groups)
+        return false if groups.size != 1
+        group = groups[0]
+        return false if group.size != 1
+        tag, from_start, from_end, to_start, to_end = group[0]
+        tag == :equal and [from_start, from_end] == [to_start, to_end]
+      end
+      def format_summary(operations, show_context)
+        _, first_from_start, _, first_to_start, _ = operations[0]
+        _, _, last_from_end, _, last_to_end = operations[-1]
+        summary = "@@ -%d,%d +%d,%d @@" % [first_from_start + 1,
+                                           last_from_end - first_from_start,
+                                           first_to_start + 1,
+                                           last_to_end - first_to_start,]
+        if show_context
+          interesting_line = find_interesting_line(first_from_start,
+                                                   first_to_start,
+                                                   :define_line?)
+          summary << " #{interesting_line}" if interesting_line
+        end
+        summary
+      end
+      def find_interesting_line(from_start, to_start, predicate)
+        from_index = from_start
+        to_index = to_start
+        while from_index >= 0 or to_index >= 0
+          [@from[from_index], @to[to_index]].each do |line|
+            return line if line and send(predicate, line)
+          end
+          from_index -= 1
+          to_index -= 1
+        end
+        nil
+      end
+      def define_line?(line)
+        /\A(?:[_a-zA-Z$]|\s*(?:class|module|def)\b)/ =~ line
+      end
     end
     module_function
-    def ndiff(from, to)
-      Differ.new(from, to).compare.join("\n")
+    def readable(from, to, options={})
+      diff(ReadableDiffer, from, to, options)
+    end
+    def unified(from, to, options={})
+      diff(UnifiedDiffer, from, to, options)
+    end
+    def diff(differ_class, from, to, options={})
+      differ = differ_class.new(from.split(/\r?\n/), to.split(/\r?\n/))
+      differ.diff(options).join("\n")
     end
   end
 end