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

test-unit-ext 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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