Add ability to disable color

When using `super_diff/rspec` in a project that is tested on a service
like CircleCI, if a test fails, then the test output will contain color
sequences (because the gem produces them via the Csi module). This
commit provides a way to disable color by configuring the gem like so:

    SuperDiff::RSpec.configure do |config|
      config.color_enabled = false
    end

That said, this setting should take effect automatically if the output
stream is not a TTY, just like RSpec does. So everything should "just
work" on CI.

Author: mcmire

lib/super_diff.rb

@@ -3,7 +3,7 @@
 require "patience_diff"
 
 module SuperDiff
-  autoload :ColorizedDocument, "super_diff/colorized_document"
+  autoload :ColorizedDocumentExtensions, "super_diff/colorized_document_extensions"
   autoload :Csi, "super_diff/csi"
   autoload :DiffFormatter, "super_diff/diff_formatter"
   autoload :DiffFormatters, "super_diff/diff_formatters"

lib/super_diff/colorized_document.rb renamed to lib/super_diff/colorized_document_extensions.rb

@@ -1,8 +1,10 @@
 module SuperDiff
-  class ColorizedDocument < Csi::ColorizedDocument
-    alias_method :normal, :text
-    # FIXME: Backward compatibility
-    alias_method :plain, :normal
+  module ColorizedDocumentExtensions
+    def self.extended(extendee)
+      extendee.singleton_class.class_eval do
+        alias_method :normal, :text
+      end
+    end
 
     def deleted(*args, **opts, &block)
       colorize(*args, **opts, fg: :red, &block)

lib/super_diff/csi.rb

@@ -2,21 +2,32 @@
 module SuperDiff
   module Csi
     autoload :Color, "super_diff/csi/color"
+    autoload :ColorSequenceBlock, "super_diff/csi/color_sequence_block"
     autoload :ColorizedDocument, "super_diff/csi/colorized_document"
+    autoload :Document, "super_diff/csi/document"
     autoload :EightBitColor, "super_diff/csi/eight_bit_color"
     autoload :FourBitColor, "super_diff/csi/four_bit_color"
     autoload :ResetSequence, "super_diff/csi/reset_sequence"
     autoload :TwentyFourBitColor, "super_diff/csi/twenty_four_bit_color"
+    autoload :UncolorizedDocument, "super_diff/csi/uncolorized_document"
+
+    class << self
+      attr_writer :color_enabled
+    end
 
     def self.reset_sequence
       ResetSequence.new
     end
 
+    def self.color_enabled?
+      @color_enabled
+    end
+
     def self.colorize(*args, **opts, &block)
-      if block
-        ColorizedDocument.new(&block)
+      if color_enabled?
+        ColorizedDocument.new(*args, **opts, &block)
       else
-        ColorizedDocument.new { colorize(*args, **opts) }
+        UncolorizedDocument.new(*args, **opts, &block)
       end
     end
 
@@ -41,5 +52,7 @@ def self.inspect_colors_in(text)
           end
         end
     end
+
+    self.color_enabled = STDOUT.tty?
   end
 end

lib/super_diff/csi/color_sequence_block.rb

@@ -0,0 +1,28 @@
+module SuperDiff
+  module Csi
+    class ColorSequenceBlock
+      include Enumerable
+
+      def initialize(colors = [])
+        @colors = colors
+      end
+
+      def each(&block)
+        colors.each(&block)
+      end
+
+      def push(color)
+        colors.push(color)
+      end
+      alias_method :<<, :push
+
+      def to_s
+        colors.map(&:to_s).join
+      end
+
+      private
+
+      attr_reader :colors
+    end
+  end
+end

lib/super_diff/csi/colorized_document.rb

@@ -1,256 +1,72 @@
 module SuperDiff
   module Csi
-    class ColorizedDocument
-      def self.colorize(*args, **opts, &block)
-        if block
-          new(&block)
-        else
-          new { colorize(*args, **opts) }
-        end
-      end
-
-      include Enumerable
-
+    class ColorizedDocument < Document
       def initialize(&block)
-        @parts = []
         @color_sequences_open_in_parent = []
-        @indentation_stack = []
-
-        evaluate_block(&block)
-      end
-
-      def each(&block)
-        parts.each(&block)
-      end
-
-      def text(*contents, **, &block)
-        if block
-          evaluate_block(&block)
-        elsif contents.any?
-          parts.push(*contents)
-        else
-          raise ArgumentError.new(
-            "Must have something to add to the document!",
-          )
-        end
+        super
       end
 
-      def line(*contents, indent_by: 0, &block)
-        indent(by: indent_by) do
-          parts << indentation_stack.join
-
-          if block
-            evaluate_block(&block)
-          elsif contents.any?
-            text(*contents)
-          else
-            raise ArgumentError.new(
-              "Must have something to add to the document!",
-            )
-          end
-        end
-
-        parts << "\n"
-      end
-
-      def newline
-        parts << "\n"
-      end
-
-      def indent(by:, &block)
-        # TODO: This won't work if using `text` manually to add lines
-        indentation_stack << (by.is_a?(String) ? by : " " * by)
-        evaluate_block(&block)
-        indentation_stack.pop
-      end
-
-      def colorize(*args, **opts, &block)
-        contents, colors = args.partition do |arg|
-          arg.is_a?(String) || arg.is_a?(self.class)
-        end
-
-        if colors[0].is_a?(Symbol)
-          if colors[0] == :colorize
-            raise ArgumentError, "#colorize can't call itself!"
-          else
-            public_send(colors[0], *contents, *colors[1..-1], **opts, &block)
-          end
-        elsif !block && colors.empty? && opts.empty?
-          text(*contents)
-        elsif block
-          colorize_block(colors, opts, &block)
-        elsif contents.any?
-          colorize_inline(contents, colors, opts)
-        else
-          raise ArgumentError, "Must have something to colorize!"
-        end
-      end
-      alias_method :colored, :colorize
-
-      def method_missing(name, *args, **opts, &block)
-        request = derive_color_request_from(name)
-
-        if request
-          request.resolve(self, args, opts, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        request = derive_color_request_from(name)
-        !request.nil? || super
-      end
-
-      def to_s
-        parts.map(&:to_s).join.rstrip
-      end
-
-      private
-
-      attr_reader :parts, :color_sequences_open_in_parent, :indentation_stack
-
-      def derive_color_request_from(name)
-        match = name.to_s.match(/\A(.+)_line\Z/)
-
-        if match
-          if respond_to?(match[1].to_sym)
-            return MethodRequest.new(name: match[1].to_sym, line: true)
-          elsif Csi::Color.exists?(match[1].to_sym)
-            return ColorRequest.new(name: match[1].to_sym, line: true)
-          end
-        elsif Csi::Color.exists?(name.to_sym)
-          return ColorRequest.new(name: name.to_sym, line: false)
-        end
-      end
+      protected
 
       def colorize_block(colors, opts, &block)
         color_sequence = build_initial_color_sequence_from(colors, opts)
 
         if color_sequences_open_in_parent.any?
-          parts << Csi.reset_sequence
+          add_part(Csi.reset_sequence)
         end
 
-        parts << color_sequence
+        add_part(color_sequence)
         color_sequences_open_in_parent << color_sequence
         evaluate_block(&block)
-        parts << Csi.reset_sequence
+        add_part(Csi.reset_sequence)
 
         color_sequence_to_reopen = color_sequences_open_in_parent.pop
         if color_sequences_open_in_parent.any?
-          parts << color_sequence_to_reopen
+          add_part(color_sequence_to_reopen)
         end
       end
 
       def colorize_inline(contents, colors, opts)
         color_sequence = build_initial_color_sequence_from(colors, opts)
 
-        parts << color_sequence
+        add_part(color_sequence)
 
         contents.each do |content|
           if content.is_a?(self.class)
             content.each do |part|
-              if part.is_a?(ColorSequence)
-                parts << Csi.reset_sequence
+              if part.is_a?(ColorSequenceBlock)
+                add_part(Csi.reset_sequence)
               end
 
-              parts << part
+              add_part(part)
 
-              if part.is_a?(Csi::ResetSequence)
-                parts << color_sequence
+              if part.is_a?(ResetSequence)
+                add_part(color_sequence)
               end
             end
           else
-            parts << content
+            add_part(content)
           end
         end
 
-        parts << Csi.reset_sequence
+        add_part(Csi.reset_sequence)
       end
 
+      private
+
+      attr_reader :color_sequences_open_in_parent
+
       def build_initial_color_sequence_from(colors, opts)
-        ColorSequence.new(colors).tap do |sequence|
+        ColorSequenceBlock.new(colors).tap do |sequence|
           if opts[:fg]
-            sequence << Csi::Color.resolve(opts[:fg], layer: :foreground)
+            sequence << Color.resolve(opts[:fg], layer: :foreground)
           end
 
           if opts[:bg]
-            sequence << Csi::Color.resolve(opts[:bg], layer: :background)
-          end
-        end
-      end
-
-      def evaluate_block(&block)
-        if block.arity > 0
-          block.call(self)
-        else
-          instance_eval(&block)
-        end
-      end
-
-      class Request
-        def initialize(name:, line:)
-          @name = name
-          @line = line
-        end
-
-        protected
-
-        attr_reader :name
-
-        def for_line?
-          @line
-        end
-
-        def wrapper
-          if for_line?
-            :line
-          else
-            :text
+            sequence << Color.resolve(opts[:bg], layer: :background)
           end
         end
       end
-
-      class ColorRequest < Request
-        def resolve(doc, args, opts, &block)
-          doc.public_send(wrapper) do |d|
-            d.colorize(*args, **opts, fg: name, &block)
-          end
-        end
-      end
-
-      class MethodRequest < Request
-        def resolve(doc, args, opts, &block)
-          doc.public_send(wrapper) do |d|
-            d.public_send(name, *args, **opts, &block)
-          end
-        end
-      end
-
-      class ColorSequence
-        include Enumerable
-
-        def initialize(colors = [])
-          @colors = colors
-        end
-
-        def each(&block)
-          colors.each(&block)
-        end
-
-        def push(color)
-          colors.push(color)
-        end
-        alias_method :<<, :push
-
-        def to_s
-          colors.map(&:to_s).join
-        end
-
-        private
-
-        attr_reader :colors
-      end
     end
   end
 end