super_diff 0.1.0 → 0.2.0

data/lib/super_diff/active_support/operation_sequences.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module ActiveSupport
+    module OperationSequences
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/active_support/operation_sequences/hash_with_indifferent_access",
+      )
+    end
+  end
+end

data/lib/super_diff/active_support/operation_sequences/hash_with_indifferent_access.rb

@@ -0,0 +1,16 @@
+module SuperDiff
+  module ActiveSupport
+    module OperationSequences
+      class HashWithIndifferentAccess < SuperDiff::OperationSequences::Base
+        def to_diff(indent_level:, collection_prefix:, add_comma:)
+          DiffFormatters::HashWithIndifferentAccess.call(
+            self,
+            indent_level: indent_level,
+            collection_prefix: collection_prefix,
+            add_comma: add_comma,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_support/operational_sequencers.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module ActiveSupport
+    module OperationalSequencers
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/active_support/operational_sequencers/hash_with_indifferent_access",
+      )
+    end
+  end
+end

data/lib/super_diff/active_support/operational_sequencers/hash_with_indifferent_access.rb

@@ -0,0 +1,21 @@
+module SuperDiff
+  module ActiveSupport
+    module OperationalSequencers
+      class HashWithIndifferentAccess < SuperDiff::OperationalSequencers::Hash
+        def initialize(expected:, actual:, **rest)
+          super
+
+          if expected.is_a?(::HashWithIndifferentAccess)
+            @expected = expected.to_h
+            @actual = actual.transform_keys(&:to_s)
+          end
+
+          if actual.is_a?(::HashWithIndifferentAccess)
+            @expected = expected.transform_keys(&:to_s)
+            @actual = actual.to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/colorized_document_extensions.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module ColorizedDocumentExtensions
+    def self.extended(extendee)
+      extendee.singleton_class.class_eval do
+        alias_method :normal, :text
+      end
+    end
+
+    def alpha(*args, **opts, &block)
+      colorize(*args, **opts, fg: SuperDiff::COLORS.fetch(:alpha), &block)
+    end
+
+    def beta(*args, **opts, &block)
+      colorize(*args, **opts, fg: SuperDiff::COLORS.fetch(:beta), &block)
+    end
+  end
+end

data/lib/super_diff/csi.rb

@@ -1,29 +1,59 @@
-require_relative "csi/reset_sequence"
-
 # Source: <https://en.wikipedia.org/wiki/ANSI_escape_code>
 module SuperDiff
   module Csi
+    autoload :BoldSequence, "super_diff/csi/bold_sequence"
+    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.colorize(text, fg: nil, bg: nil)
-      parts = []
+    def self.color_enabled?
+      @color_enabled
+    end
 
-      if fg
-        parts << fg.sequence_for(:fg)
+    def self.colorize(*args, **opts, &block)
+      if color_enabled?
+        ColorizedDocument.new(*args, **opts, &block)
+      else
+        UncolorizedDocument.new(*args, **opts, &block)
       end
+    end
 
-      if bg
-        parts << bg.sequence_for(:bg)
-      end
+    def self.decolorize(text)
+      text.gsub(/\e\[\d+(?:;\d+)*m(.+?)\e\[0m/, '\1')
+    end
+
+    def self.inspect_colors_in(text)
+      [FourBitColor, EightBitColor, TwentyFourBitColor].
+        reduce(text) do |str, klass|
+          klass.sub_colorized_areas_in(str) do |area, color|
+            color_block = colorize("◼︎", color.to_foreground)
 
-      (parts + [text, reset_sequence]).join
+            layer_indicator =
+              if color.foreground?
+                "(fg)"
+              else
+                "(bg)"
+              end
+
+            "#{color_block} #{layer_indicator} ❮#{area}❯"
+          end
+        end
     end
+
+    self.color_enabled = STDOUT.tty?
   end
 end
-
-require_relative "csi/four_bit_color"
-require_relative "csi/eight_bit_color"
-require_relative "csi/twenty_four_bit_color"
-require_relative "csi/color_helper"

data/lib/super_diff/csi/bold_sequence.rb

@@ -0,0 +1,9 @@
+module SuperDiff
+  module Csi
+    class BoldSequence
+      def to_s
+        "\e[1m"
+      end
+    end
+  end
+end

data/lib/super_diff/csi/color.rb

@@ -0,0 +1,62 @@
+module SuperDiff
+  module Csi
+    class Color
+      def self.exists?(name)
+        FourBitColor.exists?(name)
+      end
+
+      def self.resolve(value, layer:)
+        if value.is_a?(Symbol)
+          FourBitColor.new(value, layer: layer)
+        else
+          TwentyFourBitColor.new(value, layer: layer)
+        end
+      end
+
+      def self.sub_colorized_areas_in(text)
+        regex = /(#{opening_regex.source.gsub(/\((.+?)\)/, '\1')})(.+?)\e\[0m/
+
+        text.gsub(regex) do
+          match = Regexp.last_match
+
+          if match[1] == "\e[0m"
+            match[0]
+          else
+            yield match[2], new(match[1])
+          end
+        end
+      end
+
+      def to_s
+        raise NotImplementedError
+      end
+
+      def foreground?
+        layer == :foreground
+      end
+
+      def background?
+        layer == :background
+      end
+
+      def to_foreground
+        raise NotImplementedError
+      end
+
+      protected
+
+      attr_reader :layer
+
+      def interpret_layer!(layer)
+        if [:foreground, :background].include?(layer)
+          layer
+        else
+          raise ArgumentError.new(
+            "Invalid layer #{layer.inspect}. " +
+            "Layer must be :foreground or :background.",
+          )
+        end
+      end
+    end
+  end
+end

data/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

data/lib/super_diff/csi/colorized_document.rb

@@ -0,0 +1,72 @@
+module SuperDiff
+  module Csi
+    class ColorizedDocument < Document
+      def initialize(&block)
+        @color_sequences_open_in_parent = []
+        super
+      end
+
+      protected
+
+      def colorize_block(colors, opts, &block)
+        color_sequence = build_initial_color_sequence_from(colors, opts)
+
+        if color_sequences_open_in_parent.any?
+          add_part(Csi.reset_sequence)
+        end
+
+        add_part(color_sequence)
+        color_sequences_open_in_parent << color_sequence
+        evaluate_block(&block)
+        add_part(Csi.reset_sequence)
+
+        color_sequence_to_reopen = color_sequences_open_in_parent.pop
+        if color_sequences_open_in_parent.any?
+          add_part(color_sequence_to_reopen)
+        end
+      end
+
+      def colorize_inline(contents, colors, opts)
+        color_sequence = build_initial_color_sequence_from(colors, opts)
+
+        add_part(color_sequence)
+
+        contents.each do |content|
+          if content.is_a?(self.class)
+            content.each do |part|
+              if part.is_a?(ColorSequenceBlock)
+                add_part(Csi.reset_sequence)
+              end
+
+              add_part(part)
+
+              if part.is_a?(ResetSequence)
+                add_part(color_sequence)
+              end
+            end
+          else
+            add_part(content)
+          end
+        end
+
+        add_part(Csi.reset_sequence)
+      end
+
+      private
+
+      attr_reader :color_sequences_open_in_parent
+
+      def build_initial_color_sequence_from(colors, opts)
+        ColorSequenceBlock.new(colors).tap do |sequence|
+          if opts[:fg]
+            sequence << Color.resolve(opts[:fg], layer: :foreground)
+          end
+
+          if opts[:bg]
+            sequence << Color.resolve(opts[:bg], layer: :background)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/csi/document.rb

@@ -0,0 +1,183 @@
+module SuperDiff
+  module Csi
+    class Document
+      include Enumerable
+
+      def initialize(&block)
+        @parts = []
+        @indentation_stack = []
+
+        if block
+          evaluate_block(&block)
+        end
+      end
+
+      def each(&block)
+        parts.each(&block)
+      end
+
+      def bold(*args, **opts, &block)
+        colorize(BoldSequence.new, *args, **opts, &block)
+      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 text(*contents, **, &block)
+        if block
+          evaluate_block(&block)
+        elsif contents.any?
+          contents.each do |part|
+            add_part(part)
+          end
+        else
+          raise ArgumentError.new(
+            "Must have something to add to the document!",
+          )
+        end
+      end
+      alias_method :plain, :text
+
+      def line(*contents, indent_by: 0, &block)
+        indent(by: indent_by) do
+          add_part(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
+
+        add_part("\n")
+      end
+
+      def newline
+        add_part("\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 method_missing(name, *args, **opts, &block)
+        request = derive_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_request_from(name)
+        !request.nil? || super
+      end
+
+      def to_s
+        parts.map(&:to_s).join.rstrip
+      end
+
+      protected
+
+      attr_reader :parts, :indentation_stack
+
+      def derive_request_from(name)
+        match = name.to_s.match(/\A(.+)_line\Z/)
+
+        if match
+          color_name = match[1].to_sym
+
+          if respond_to?(color_name)
+            MethodRequest.new(name: color_name, line: true)
+          elsif Csi::Color.exists?(color_name)
+            ColorRequest.new(name: color_name, line: true)
+          end
+        elsif Csi::Color.exists?(name.to_sym)
+          ColorRequest.new(name: name.to_sym, line: false)
+        else
+          nil
+        end
+      end
+
+      def evaluate_block(&block)
+        if block.arity > 0
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+
+      def add_part(part)
+        parts.push(part)
+      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
+          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 ColorRequest < Request
+        def resolve(doc, args, opts, &block)
+          doc.public_send(wrapper) do |d|
+            d.colorize(*args, **opts, fg: name, &block)
+          end
+        end
+      end
+    end
+  end
+end