rhodes 3.2.0.beta.4 → 3.2.0.beta.5

data/spec/framework_spec/extensions/test-libs/test/unit/testresult.rb

@@ -0,0 +1,125 @@
+#--
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/util/observable'
+require 'test/unit/failure'
+require 'test/unit/error'
+require 'test/unit/omission'
+require 'test/unit/pending'
+require 'test/unit/notification'
+
+module Test
+  module Unit
+    module NullResultContainerInitializer
+      private
+      def initialize_containers
+      end
+    end
+
+    # Collects Test::Unit::Failure and Test::Unit::Error so that
+    # they can be displayed to the user. To this end, observers
+    # can be added to it, allowing the dynamic updating of, say, a
+    # UI.
+    class TestResult
+      include Util::Observable
+      include NullResultContainerInitializer
+      include TestResultFailureSupport
+      include TestResultErrorSupport
+      include TestResultPendingSupport
+      include TestResultOmissionSupport
+      include TestResultNotificationSupport
+
+      FINISHED = name + "::FINISHED"
+      CHANGED = name + "::CHANGED"
+      PASS_ASSERTION = name + "::PASS_ASSERTION"
+      FAULT = name + "::FAULT"
+
+      attr_reader :run_count, :pass_count, :assertion_count, :faults
+
+      # Constructs a new, empty TestResult.
+      def initialize
+        @run_count, @pass_count, @assertion_count = 0, 0, 0
+        @summary_generators = []
+        @problem_checkers = []
+        @faults = []
+        initialize_containers
+      end
+
+      # Records a test run.
+      def add_run
+        @run_count += 1
+        notify_listeners(FINISHED, self)
+        notify_changed
+      end
+
+      def add_pass
+        @pass_count += 1
+      end
+
+      # Records an individual assertion.
+      def add_assertion
+        @assertion_count += 1
+        notify_listeners(PASS_ASSERTION, self)
+        notify_changed
+      end
+
+      # Returns a string contain the recorded runs, assertions,
+      # failures and errors in this TestResult.
+      def summary
+        ["#{run_count} tests",
+         "#{assertion_count} assertions",
+         *@summary_generators.collect {|generator| send(generator)}].join(", ")
+      end
+
+      # Returnes a string that shows result status.
+      def status
+        if passed?
+          if pending_count > 0
+            "pending"
+          elsif omission_count > 0
+            "omission"
+          elsif notification_count > 0
+            "notification"
+          else
+            "pass"
+          end
+        elsif error_count > 0
+          "error"
+        elsif failure_count > 0
+          "failure"
+        end
+      end
+
+      def to_s
+        summary
+      end
+
+      # Returns whether or not this TestResult represents
+      # successful completion.
+      def passed?
+        @problem_checkers.all? {|checker| not send(checker)}
+      end
+
+      def pass_percentage
+        n_tests = @run_count - omission_count
+        if n_tests.zero?
+          0
+        else
+          100.0 * (@pass_count / n_tests.to_f)
+        end
+      end
+
+      private
+      def notify_changed
+        notify_listeners(CHANGED, self)
+      end
+
+      def notify_fault(fault)
+        @faults << fault
+        notify_listeners(FAULT, fault)
+      end
+    end
+  end
+end

data/spec/framework_spec/extensions/test-libs/test/unit/testsuite.rb

@@ -0,0 +1,134 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# Copyright:: Copyright (c) 2008-2011 Kouhei Sutou. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/error'
+
+module Test
+  module Unit
+
+    # A collection of tests which can be #run.
+    #
+    # Note: It is easy to confuse a TestSuite instance with
+    # something that has a static suite method; I know because _I_
+    # have trouble keeping them straight. Think of something that
+    # has a suite method as simply providing a way to get a
+    # meaningful TestSuite instance.
+    class TestSuite
+      attr_reader :name, :tests, :test_case, :start_time, :elapsed_time
+
+      # Test suite that has higher priority is ran prior to
+      # test suites that have lower priority.
+      attr_accessor :priority
+
+      STARTED = name + "::STARTED"
+      STARTED_OBJECT = name + "::STARTED::OBJECT"
+      FINISHED = name + "::FINISHED"
+      FINISHED_OBJECT = name + "::FINISHED::OBJECT"
+
+      # Creates a new TestSuite with the given name.
+      def initialize(name="Unnamed TestSuite", test_case=nil)
+        @name = name
+        @tests = []
+        @test_case = test_case
+        @n_tests = 0
+        @priority = 0
+        @start_time = nil
+        @elapsed_time = nil
+        @passed = true
+      end
+
+      # Runs the tests and/or suites contained in this
+      # TestSuite.
+      def run(result, &progress_block)
+        @start_time = Time.now
+        yield(STARTED, name)
+        yield(STARTED_OBJECT, self)
+        run_startup(result)
+        while test = @tests.shift
+          @n_tests += test.size
+          test.run(result, &progress_block)
+          @passed = false unless test.passed?
+        end
+        run_shutdown(result)
+      ensure
+        @elapsed_time = Time.now - @start_time
+        yield(FINISHED, name)
+        yield(FINISHED_OBJECT, self)
+      end
+
+      # Adds the test to the suite.
+      def <<(test)
+        @tests << test
+        self
+      end
+
+      def delete(test)
+        @tests.delete(test)
+      end
+
+      # Retuns the rolled up number of tests in this suite;
+      # i.e. if the suite contains other suites, it counts the
+      # tests within those suites, not the suites themselves.
+      def size
+        total_size = @n_tests
+        @tests.each { |test| total_size += test.size }
+        total_size
+      end
+      
+      def empty?
+        tests.empty?
+      end
+
+      # Overridden to return the name given the suite at
+      # creation.
+      def to_s
+        @name
+      end
+      
+      # It's handy to be able to compare TestSuite instances.
+      def ==(other)
+        return false unless(other.kind_of?(self.class))
+        return false unless(@name == other.name)
+        @tests == other.tests
+      end
+
+      def passed?
+        @passed
+      end
+
+      private
+      def run_startup(result)
+        return if @test_case.nil? or !@test_case.respond_to?(:startup)
+        begin
+          @test_case.startup
+        rescue Exception
+          raise unless handle_exception($!, result)
+        end
+      end
+
+      def run_shutdown(result)
+        return if @test_case.nil? or !@test_case.respond_to?(:shutdown)
+        begin
+          @test_case.shutdown
+        rescue Exception
+          raise unless handle_exception($!, result)
+        end
+      end
+
+      def handle_exception(exception, result)
+        case exception
+        when *ErrorHandler::PASS_THROUGH_EXCEPTIONS
+          false
+        else
+          result.add_error(Error.new(@test_case.name, exception))
+          @passed = false
+          true
+        end
+      end
+    end
+  end
+end

data/spec/framework_spec/extensions/test-libs/test/unit/testsuitecreator.rb

@@ -0,0 +1,79 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <tt><kou@clear-code.com></tt>
+# License:: Ruby license.
+
+module Test
+  module Unit
+    class TestSuiteCreator # :nodoc:
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def create
+        suite = TestSuite.new(@test_case.name, @test_case)
+        collect_test_names.each do |test_name|
+          data_sets = @test_case.attributes(test_name)[:data]
+          if data_sets
+            data_sets.each do |data_set|
+              data_set = data_set.call if data_set.respond_to?(:call)
+              data_set.each do |label, data|
+                append_test(suite, test_name) do |test|
+                  test.assign_test_data(label, data)
+                end
+              end
+            end
+          else
+            append_test(suite, test_name)
+          end
+        end
+        append_test(suite, "default_test") if suite.empty?
+        suite
+      end
+
+      private
+      def append_test(suite, test_name)
+        test = @test_case.new(test_name)
+        yield(test) if block_given?
+        suite << test if test.valid?
+      end
+
+      def collect_test_names
+        method_names = @test_case.public_instance_methods(true).collect do |name|
+          name.to_s
+        end
+        test_names = method_names.find_all do |method_name|
+          method_name =~ /^test./ or @test_case.attributes(method_name)[:test]
+        end
+        send("sort_test_names_in_#{@test_case.test_order}_order", test_names)
+      end
+
+      def sort_test_names_in_alphabetic_order(test_names)
+        test_names.sort
+      end
+
+      def sort_test_names_in_random_order(test_names)
+        test_names.sort_by {rand(test_names.size)}
+      end
+
+      def sort_test_names_in_defined_order(test_names)
+        added_methods = @test_case.added_methods
+        test_names.sort do |test1, test2|
+          test1_defined_order = added_methods.index(test1)
+          test2_defined_order = added_methods.index(test2)
+          if test1_defined_order and test2_defined_order
+            test1_defined_order <=> test2_defined_order
+          elsif test1_defined_order
+            1
+          elsif test2_defined_order
+            -1
+          else
+            test1 <=> test2
+          end
+        end
+      end
+    end
+  end
+end

data/spec/framework_spec/extensions/test-libs/test/unit/ui/console/outputlevel.rb

@@ -0,0 +1,15 @@
+module Test
+  module Unit
+    module UI
+      module Console
+        module OutputLevel
+          SILENT = 0
+          PROGRESS_ONLY = 1
+          IMPORTANT_FAULTS_ONLY = 2
+          NORMAL = 3
+          VERBOSE = 4
+        end
+      end
+    end
+  end
+end

data/spec/framework_spec/extensions/test-libs/test/unit/ui/console/testrunner.rb

@@ -0,0 +1,561 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright::
+#   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+#   * Copyright (c) 2008-2011 Kouhei Sutou <kou@clear-code.com>
+# License:: Ruby license.
+
+require 'test/unit/color-scheme'
+require 'test/unit/ui/testrunner'
+require 'test/unit/ui/testrunnermediator'
+require 'test/unit/ui/console/outputlevel'
+
+module Test
+  module Unit
+    module UI
+      module Console
+
+        # Runs a Test::Unit::TestSuite on the console.
+        class TestRunner < UI::TestRunner
+          include OutputLevel
+
+          # Creates a new TestRunner for running the passed
+          # suite. If quiet_mode is true, the output while
+          # running is limited to progress dots, errors and
+          # failures, and the final result. io specifies
+          # where runner output should go to; defaults to
+          # STDOUT.
+          def initialize(suite, options={})
+            super
+            @output_level = @options[:output_level] || NORMAL
+            @output = @options[:output] || STDOUT
+            @use_color = @options[:use_color]
+            @use_color = guess_color_availability if @use_color.nil?
+            @color_scheme = @options[:color_scheme] || ColorScheme.default
+            @reset_color = Color.new("reset")
+            @progress_row = 0
+            @progress_row_max = @options[:progress_row_max]
+            @progress_row_max ||= guess_progress_row_max
+            @show_detail_immediately = @options[:show_detail_immediately]
+            @show_detail_immediately = true if @show_detail_immediately.nil?
+            @already_outputted = false
+            @indent = 0
+            @top_level = true
+            @current_output_level = NORMAL
+            @faults = []
+          end
+
+          private
+          def change_output_level(level)
+            old_output_level = @current_output_level
+            @current_output_level = level
+            yield
+            @current_output_level = old_output_level
+          end
+
+          def setup_mediator
+            super
+            output_setup_end
+          end
+
+          def output_setup_end
+            suite_name = @suite.to_s
+            suite_name = @suite.name if @suite.kind_of?(Module)
+            output("Loaded suite #{suite_name}")
+          end
+
+          def attach_to_mediator
+            @mediator.add_listener(TestResult::FAULT,
+                                   &method(:add_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED,
+                                   &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED,
+                                   &method(:finished))
+            @mediator.add_listener(TestCase::STARTED_OBJECT,
+                                   &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED_OBJECT,
+                                   &method(:test_finished))
+            @mediator.add_listener(TestSuite::STARTED_OBJECT,
+                                   &method(:test_suite_started))
+            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
+                                   &method(:test_suite_finished))
+          end
+
+          def add_fault(fault)
+            @faults << fault
+            output_progress(fault.single_character_display, fault_color(fault))
+            output_progress_in_detail(fault) if @show_detail_immediately
+            @already_outputted = true if fault.critical?
+          end
+
+          def started(result)
+            @result = result
+            output_started
+          end
+
+          def output_started
+            output("Started")
+          end
+
+          def finished(elapsed_time)
+            nl if output?(NORMAL) and !output?(VERBOSE)
+            output_faults unless @show_detail_immediately
+            nl(PROGRESS_ONLY)
+            change_output_level(IMPORTANT_FAULTS_ONLY) do
+              output_statistics(elapsed_time)
+            end
+          end
+
+          def output_faults
+            categorized_faults = categorize_faults
+            change_output_level(IMPORTANT_FAULTS_ONLY) do
+              output_faults_in_detail(categorized_faults[:need_detail_faults])
+            end
+            output_faults_in_short("Omissions", Omission,
+                                   categorized_faults[:omissions])
+            output_faults_in_short("Notifications", Notification,
+                                   categorized_faults[:notifications])
+          end
+
+          def max_digit(max_number)
+            (Math.log10(max_number) + 1).truncate
+          end
+
+          def output_faults_in_detail(faults)
+            return if faults.nil?
+            digit = max_digit(faults.size)
+            faults.each_with_index do |fault, index|
+              nl
+              output_single("%#{digit}d) " % (index + 1))
+              output_fault_in_detail(fault)
+            end
+          end
+
+          def output_faults_in_short(label, fault_class, faults)
+            return if faults.nil?
+            digit = max_digit(faults.size)
+            nl
+            output_single(label, fault_class_color(fault_class))
+            output(":")
+            faults.each_with_index do |fault, index|
+              output_single("%#{digit}d) " % (index + 1))
+              output_fault_in_short(fault)
+            end
+          end
+
+          def categorize_faults
+            faults = {}
+            @faults.each do |fault|
+              category = categorize_fault(fault)
+              faults[category] ||= []
+              faults[category] << fault
+            end
+            faults
+          end
+
+          def categorize_fault(fault)
+            case fault
+            when Omission
+              :omissions
+            when Notification
+              :notifications
+            else
+              :need_detail_faults
+            end
+          end
+
+          def output_fault_in_detail(fault)
+            if @use_color and fault.is_a?(Failure) and
+                fault.inspected_expected and fault.inspected_actual
+              output_single(fault.label, fault_color(fault))
+              output(":")
+              output_fault_backtrace(fault)
+              output_fault_message(fault)
+            else
+              label, detail = format_fault(fault).split(/\r?\n/, 2)
+              output(label, fault_color(fault))
+              output(detail)
+            end
+          end
+
+          def output_fault_backtrace(fault)
+            backtrace = fault.location
+            if backtrace.size == 1
+              output(fault.test_name +
+                     backtrace[0].sub(/\A(.+:\d+).*/, ' [\\1]') +
+                     ":")
+            else
+              output(fault.test_name)
+              backtrace.each_with_index do |entry, i|
+                if i.zero?
+                  prefix = "["
+                  postfix = ""
+                elsif i == backtrace.size - 1
+                  prefix = " "
+                  postfix = "]:"
+                else
+                  prefix = " "
+                  postfix = ""
+                end
+                output("    #{prefix}#{entry}#{postfix}")
+              end
+            end
+          end
+
+          def output_fault_message(fault)
+            if fault.expected.respond_to?(:encoding) and
+                fault.actual.respond_to?(:encoding) and
+                fault.expected.encoding != fault.actual.encoding
+              need_encoding = true
+            else
+              need_encoding = false
+            end
+            output(fault.user_message) if fault.user_message
+            output_single("<")
+            output_single(fault.inspected_expected, color("pass"))
+            output_single(">")
+            if need_encoding
+              output_single("(")
+              output_single(fault.expected.encoding.name, color("pass"))
+              output_single(")")
+            end
+            output(" expected but was")
+            output_single("<")
+            output_single(fault.inspected_actual, color("failure"))
+            output_single(">")
+            if need_encoding
+              output_single("(")
+              output_single(fault.actual.encoding.name, color("failure"))
+              output_single(")")
+            end
+            output("")
+            from, to = prepare_for_diff(fault.expected, fault.actual)
+            if from and to
+              from_lines = from.split(/\r?\n/)
+              to_lines = to.split(/\r?\n/)
+              if need_encoding
+                from_lines << ""
+                to_lines << ""
+                from_lines << "Encoding: #{fault.expected.encoding.name}"
+                to_lines << "Encoding: #{fault.actual.encoding.name}"
+              end
+              differ = ColorizedReadableDiffer.new(from_lines, to_lines, self)
+              if differ.need_diff?
+                output("")
+                output("diff:")
+                differ.diff
+              end
+            end
+          end
+
+          def output_fault_in_short(fault)
+            output_single(fault.message, fault_color(fault))
+            output(" [#{fault.test_name}]")
+            output(fault.location.first)
+          end
+
+          def format_fault(fault)
+            fault.long_display
+          end
+
+          def output_statistics(elapsed_time)
+            output("Finished in #{elapsed_time} seconds.")
+            nl
+            output(@result, result_color)
+            output("%g%% passed" % @result.pass_percentage, result_color)
+            unless elapsed_time.zero?
+              nl
+              test_throughput = @result.run_count / elapsed_time
+              assertion_throughput = @result.assertion_count / elapsed_time
+              throughput = [
+                "%.2f tests/s" % test_throughput,
+                "%.2f assertions/s" % assertion_throughput,
+              ]
+              output(throughput.join(", "))
+            end
+          end
+
+          def test_started(test)
+            return unless output?(VERBOSE)
+
+            name = test.name.sub(/\(.+?\)\z/, '')
+            right_space = 8 * 2
+            left_space = @progress_row_max - right_space
+            left_space = left_space - indent.size - name.size
+            tab_stop = "\t" * ([left_space - 1, 0].max / 8)
+            output_single("#{indent}#{name}:#{tab_stop}", nil, VERBOSE)
+            @test_start = Time.now
+          end
+
+          def test_finished(test)
+            unless @already_outputted
+              output_progress(".", color("pass"))
+            end
+            @already_outputted = false
+
+            return unless output?(VERBOSE)
+
+            output(": (%f)" % (Time.now - @test_start), nil, VERBOSE)
+          end
+
+          def test_suite_started(suite)
+            if @top_level
+              @top_level = false
+              return
+            end
+
+            output_single(indent, nil, VERBOSE)
+            if suite.test_case.nil?
+              _color = color("suite")
+            else
+              _color = color("case")
+            end
+            output_single(suite.name, _color, VERBOSE)
+            output(": ", nil, VERBOSE)
+            @indent += 2
+          end
+
+          def test_suite_finished(suite)
+            @indent -= 2
+          end
+
+          def indent
+            if output?(VERBOSE)
+              " " * @indent
+            else
+              ""
+            end
+          end
+
+          def nl(level=nil)
+            output("", nil, level)
+          end
+
+          def output(something, color=nil, level=nil)
+            return unless output?(level)
+            output_single(something, color, level)
+            @output.puts
+          end
+
+          def output_single(something, color=nil, level=nil)
+            return false unless output?(level)
+            if @use_color and color
+              something = "%s%s%s" % [color.escape_sequence,
+                                      something,
+                                      @reset_color.escape_sequence]
+            end
+            @output.write(something)
+            @output.flush
+            true
+          end
+
+          def output_progress(mark, color=nil)
+            if output_single(mark, color, PROGRESS_ONLY)
+              return unless @progress_row_max > 0
+              @progress_row += mark.size
+              if @progress_row >= @progress_row_max
+                nl unless @output_level == VERBOSE
+                @progress_row = 0
+              end
+            end
+          end
+
+          def output_progress_in_detail(fault)
+            return if @output_level == SILENT
+            nl
+            nl
+            if categorize_fault(fault) == :need_detail_faults
+              output_fault_in_detail(fault)
+            else
+              output_fault_in_short(fault)
+            end
+            nl
+          end
+
+          def output?(level)
+            (level || @current_output_level) <= @output_level
+          end
+
+          def color(name)
+            _color = @color_scheme[name]
+            _color ||= @color_scheme["success"] if name == "pass"
+            _color ||= ColorScheme.default[name]
+            _color
+          end
+
+          def fault_color(fault)
+            fault_class_color(fault.class)
+          end
+
+          def fault_class_color(fault_class)
+            color(fault_class.name.split(/::/).last.downcase)
+          end
+
+          def result_color
+            color(@result.status)
+          end
+
+          def guess_color_availability
+            return false unless @output.tty?
+            case ENV["TERM"]
+            when /term(?:-color)?\z/, "screen"
+              true
+            else
+              return true if ENV["EMACS"] == "t"
+              false
+            end
+          end
+
+          def guess_progress_row_max
+            term_width = guess_term_width
+            if term_width.zero?
+              if ENV["EMACS"] == "t"
+                -1
+              else
+                79
+              end
+            else
+              term_width
+            end
+          end
+
+          def guess_term_width
+            Integer(ENV["COLUMNS"] || ENV["TERM_WIDTH"] || 0)
+          rescue ArgumentError
+            0
+          end
+        end
+
+        class ColorizedReadableDiffer < Diff::ReadableDiffer
+          def initialize(from, to, runner)
+            @runner = runner
+            super(from, to)
+          end
+
+          def need_diff?(options={})
+            operations.each do |tag,|
+              return true if [:replace, :equal].include?(tag)
+            end
+            false
+          end
+
+          private
+          def output_single(something, color=nil)
+            @runner.send(:output_single, something, color)
+          end
+
+          def output(something, color=nil)
+            @runner.send(:output, something, color)
+          end
+
+          def color(name)
+            @runner.send(:color, name)
+          end
+
+          def cut_off_ratio
+            0
+          end
+
+          def default_ratio
+            0
+          end
+
+          def tag(mark, color_name, contents)
+            _color = color(color_name)
+            contents.each do |content|
+              output_single(mark, _color)
+              output_single(" ")
+              output(content)
+            end
+          end
+
+          def tag_deleted(contents)
+            tag("-", "diff-deleted-tag", contents)
+          end
+
+          def tag_inserted(contents)
+            tag("+", "diff-inserted-tag", contents)
+          end
+
+          def tag_equal(contents)
+            tag(" ", "normal", contents)
+          end
+
+          def tag_difference(contents)
+            tag("?", "diff-difference-tag", contents)
+          end
+
+          def diff_line(from_line, to_line)
+            to_operations = []
+            from_line, to_line, _operations = line_operations(from_line, to_line)
+
+            no_replace = true
+            _operations.each do |tag,|
+              if tag == :replace
+                no_replace = false
+                break
+              end
+            end
+
+            output_single("?", color("diff-difference-tag"))
+            output_single(" ")
+            _operations.each do |tag, from_start, from_end, to_start, to_end|
+              from_width = compute_width(from_line, from_start, from_end)
+              to_width = compute_width(to_line, to_start, to_end)
+              case tag
+              when :replace
+                output_single(from_line[from_start...from_end],
+                              color("diff-deleted"))
+                if (from_width < to_width)
+                  output_single(" " * (to_width - from_width))
+                end
+                to_operations << Proc.new do
+                  output_single(to_line[to_start...to_end],
+                                color("diff-inserted"))
+                  if (to_width < from_width)
+                    output_single(" " * (from_width - to_width))
+                  end
+                end
+              when :delete
+                output_single(from_line[from_start...from_end],
+                              color("diff-deleted"))
+                unless no_replace
+                  to_operations << Proc.new {output_single(" " * from_width)}
+                end
+              when :insert
+                if no_replace
+                  output_single(to_line[to_start...to_end],
+                                color("diff-inserted"))
+                else
+                  output_single(" " * to_width)
+                  to_operations << Proc.new do
+                    output_single(to_line[to_start...to_end],
+                                  color("diff-inserted"))
+                  end
+                end
+              when :equal
+                output_single(from_line[from_start...from_end])
+                unless no_replace
+                  to_operations << Proc.new {output_single(" " * to_width)}
+                end
+              else
+                raise "unknown tag: #{tag}"
+              end
+            end
+            output("")
+
+            unless to_operations.empty?
+              output_single("?", color("diff-difference-tag"))
+              output_single(" ")
+              to_operations.each do |operation|
+                operation.call
+              end
+              output("")
+            end
+          end
+        end
+      end
+    end
+  end
+end