super_diff 0.1.0 → 0.2.0

data/lib/super_diff/csi/eight_bit_color.rb

@@ -1,8 +1,8 @@
 module SuperDiff
   module Csi
-    class EightBitColor
-      VALID_COMPONENT_RANGE = 0..6
-      VALID_CODE_RANGE = 0..255
+    class EightBitColor < Color
+      VALID_COMPONENT_RANGE = (0..6).freeze
+      VALID_CODE_RANGE = (0..255).freeze
       VALID_CODES_BY_NAME = {
         black: 0,
         red: 1,
@@ -32,49 +32,78 @@ module SuperDiff
         high_intensity: 0..7,
         grayscale: 0..23,
       }.freeze
-      LEADING_CODES_BY_LAYER = { fg: 38, bg: 48 }.freeze
+      LEADING_CODES_BY_LAYER = { foreground: 38, background: 48 }.freeze
+      LAYERS_BY_LEADING_CODE = LEADING_CODES_BY_LAYER.invert.freeze
       SERIAL_CODE = 5
+      OPENING_REGEX = /\e\[(\d+);#{SERIAL_CODE};(\d+)m/.freeze
 
-      def initialize(value)
-        @code =
+      def self.opening_regex
+        OPENING_REGEX
+      end
+
+      def initialize(
+        value = nil,
+        layer: nil,
+        red: nil,
+        green: nil,
+        blue: nil,
+        type: nil,
+        index: nil
+      )
+        if value
           case value
-          when Hash
-            interpret_triplet!(value)
           when Symbol
-            interpret_color_name!(value)
+            @code = interpret_color_name!(value)
+            @layer = interpret_layer!(layer)
           when Array
-            interpret_pair!(value)
+            @code = interpret_pair!(type: type, index: index)
+            @layer = interpret_layer!(layer)
           else
-            interpret_code!(value)
+            if value.is_a?(String) && value.start_with?("\e[")
+              pair = interpret_sequence!(value)
+              @code = pair.fetch(:code)
+              @layer = pair.fetch(:layer)
+            else
+              @code = interpret_code!(value)
+              @layer = interpret_layer!(layer)
+            end
           end
+        else
+          @code = interpret_triplet!(red: red, green: green, blue: blue)
+          @layer = interpret_layer!(layer)
+        end
       end
 
-      def sequence_for(layer)
-        leading_code = LEADING_CODES_BY_LAYER.fetch(layer)
+      def to_s
         "\e[#{leading_code};#{SERIAL_CODE};#{code}m"
       end
 
+      def to_foreground
+        self.class.new(code, layer: :foreground)
+      end
+
       private
 
       attr_reader :code
 
-      def interpret_triplet!(spec)
-        unless spec.include?(:r) && spec.include?(:g) && spec.include?(:b)
-          raise ArgumentError.new(
-            "#{spec.inspect} is not a valid color specification. " +
-            "Please provide a hash with :r, :g, and :b keys.",
-          )
-        end
+      def leading_code
+        LEADING_CODES_BY_LAYER.fetch(layer)
+      end
 
-        if spec.values.none? { |component| VALID_COMPONENT_RANGE.cover?(component) }
+      def interpret_triplet!(red:, green:, blue:)
+        if invalid_triplet?(red, green, blue)
           raise ArgumentError.new(
-            "(#{spec[:r]},#{spec[:g]},#{spec[:b]}) is not a valid color " +
+            "(#{red},#{green},#{blue}) is not a valid color " +
             "specification. All components must be between " +
             "#{VALID_COMPONENT_RANGE.begin} and #{VALID_COMPONENT_RANGE.end}.",
           )
         end
 
-        16 + 36 * spec[:r] + 6 * spec[:g] + spec[:b]
+        16 + 36 * red + 6 * green + blue
+      end
+
+      def invalid_triplet?(*values)
+        values.none? { |component| VALID_COMPONENT_RANGE.cover?(component) }
       end
 
       def interpret_color_name!(name)
@@ -93,9 +122,7 @@ module SuperDiff
         VALID_CODES_BY_NAME[name]
       end
 
-      def interpret_pair!(pair)
-        type, index = pair
-
+      def interpret_pair!(type:, index:)
         if !VALID_PAIR_TYPES.include?(type)
           raise ArgumentError.new(
             "Given pair did not have a valid type. " +
@@ -116,6 +143,25 @@ module SuperDiff
         STARTING_INDICES[type] + index
       end
 
+      def interpret_sequence!(sequence)
+        match = sequence.match(OPENING_REGEX)
+
+        if match
+          {
+            layer: interpret_layer!(match[1]),
+            code: interpret_code!(match[2].to_i),
+          }
+        end
+      end
+
+      def interpret_layer!(value)
+        if value.to_s.to_i > 0
+          LAYERS_BY_LEADING_CODE.fetch(value.to_s.to_i)
+        else
+          super
+        end
+      end
+
       def interpret_code!(code)
         if !VALID_CODE_RANGE.cover?(code)
           raise ArgumentError.new(

data/lib/super_diff/csi/four_bit_color.rb

@@ -1,45 +1,69 @@
 module SuperDiff
   module Csi
-    class FourBitColor
-      VALID_TYPES = [:fg, :bg].freeze
+    class FourBitColor < Color
+      VALID_TYPES = [:foreground, :background].freeze
       VALID_CODES_BY_NAME = {
-        black: { fg: 30, bg: 40 },
-        red: { fg: 31, bg: 41 },
-        green: { fg: 32, bg: 42 },
-        yellow: { fg: 33, bg: 43 },
-        blue: { fg: 34, bg: 44 },
-        magenta: { fg: 35, bg: 45 },
-        cyan: { fg: 36, bg: 46 },
-        white: { fg: 37, bg: 47 },
-        bright_black: { fg: 90, bg: 100 },
-        bright_red: { fg: 91, bg: 101 },
-        bright_green: { fg: 92, bg: 102 },
-        bright_yellow: { fg: 93, bg: 103 },
-        bright_blue: { fg: 94, bg: 104 },
-        bright_magenta: { fg: 95, bg: 105 },
-        bright_cyan: { fg: 96, bg: 106 },
-        bright_white: { fg: 97, bg: 107 },
+        black: { foreground: 30, background: 40 },
+        red: { foreground: 31, background: 41 },
+        green: { foreground: 32, background: 42 },
+        yellow: { foreground: 33, background: 43 },
+        blue: { foreground: 34, background: 44 },
+        magenta: { foreground: 35, background: 45 },
+        cyan: { foreground: 36, background: 46 },
+        white: { foreground: 37, background: 47 },
+        bright_black: { foreground: 90, background: 100 },
+        bright_red: { foreground: 91, background: 101 },
+        bright_green: { foreground: 92, background: 102 },
+        bright_yellow: { foreground: 93, background: 103 },
+        bright_blue: { foreground: 94, background: 104 },
+        bright_magenta: { foreground: 95, background: 105 },
+        bright_cyan: { foreground: 96, background: 106 },
+        bright_white: { foreground: 97, background: 107 },
       }.freeze
-      NAMES_BY_CODE = VALID_CODES_BY_NAME.reduce({}) do |hash, (key, value)|
-        hash.merge(value[:fg] => key, value[:bg] => key)
+      COLORS_BY_CODE = VALID_CODES_BY_NAME.reduce({}) do |hash, (name, value)|
+        hash.merge(
+          value[:foreground] => { name: name, layer: :foreground },
+          value[:background] => { name: name, layer: :background },
+        )
       end
       VALID_NAMES = VALID_CODES_BY_NAME.keys
       VALID_CODE_RANGES = [30..37, 40..47, 90..97, 100..107].freeze
+      OPENING_REGEX = /\e\[(\d+)m/.freeze
 
-      def initialize(value)
-        @name =
-          if value.is_a?(Symbol)
-            interpret_name!(value)
-          else
-            interpret_code!(value)
-          end
+      def self.exists?(name)
+        VALID_CODES_BY_NAME.has_key?(name)
+      end
+
+      def self.opening_regex
+        OPENING_REGEX
+      end
+
+      def initialize(value, layer: nil)
+        if value.is_a?(Symbol)
+          @name = interpret_name!(value)
+          @layer = interpret_layer!(layer)
+        else
+          pair =
+            if value.start_with?("\e[")
+              interpret_sequence!(value)
+            else
+              interpret_code!(value)
+            end
+
+          @name = pair.fetch(:name)
+          @layer = pair.fetch(:layer)
+        end
       end
 
-      def sequence_for(layer)
+      def to_s
         code = VALID_CODES_BY_NAME.fetch(name).fetch(layer)
         "\e[#{code}m"
       end
 
+      def to_foreground
+        self.class.new(name, layer: :foreground)
+      end
+
       private
 
       attr_reader :name
@@ -60,6 +84,16 @@ module SuperDiff
         name
       end
 
+      def interpret_sequence!(sequence)
+        match = sequence.match(OPENING_REGEX)
+
+        # binding.pry
+
+        if match
+          interpret_code!(match[1].to_i)
+        end
+      end
+
       def interpret_code!(code)
         if VALID_CODE_RANGES.none? { |range| range.cover?(code) }
           message =
@@ -73,7 +107,7 @@ module SuperDiff
           raise ArgumentError.new(message)
         end
 
-        NAMES_BY_CODE.fetch(code)
+        COLORS_BY_CODE.fetch(code)
       end
     end
   end

data/lib/super_diff/csi/twenty_four_bit_color.rb

@@ -1,40 +1,101 @@
 module SuperDiff
   module Csi
-    class TwentyFourBitColor
-      VALID_COMPONENT_RANGE = 0..255
-      LEADING_CODES_BY_LAYER = { fg: 38, bg: 48 }.freeze
+    class TwentyFourBitColor < Color
+      VALID_COMPONENT_RANGE = (0..255).freeze
+      LEADING_CODES_BY_LAYER = { foreground: 38, background: 48 }.freeze
+      LAYERS_BY_LEADING_CODE = LEADING_CODES_BY_LAYER.invert.freeze
       SERIAL_CODE = 2
+      OPENING_REGEX = /\e\[(\d+);#{SERIAL_CODE};(\d+);(\d+);(\d+)m/.freeze
 
-      def initialize(value)
-        @code = interpret_triplet!(value)
+      def self.opening_regex
+        OPENING_REGEX
       end
 
-      def sequence_for(layer)
-        leading_code = LEADING_CODES_BY_LAYER.fetch(layer)
-        "\e[#{leading_code};#{SERIAL_CODE};#{code}m"
+      def initialize(value = nil, layer: nil, red: nil, green: nil, blue: nil)
+        if value
+          pair = interpret_sequence!(value)
+          @triplet = pair.fetch(:triplet)
+          @layer = pair.fetch(:layer)
+        else
+          @triplet = interpret_triplet!(red: red, green: green, blue: blue)
+          @layer = interpret_layer!(layer)
+        end
+      end
+
+      def to_s
+        [
+          "\e[#{leading_code}",
+          SERIAL_CODE,
+          triplet.red,
+          triplet.blue,
+          triplet.green,
+        ].join(";") + "m"
+      end
+
+      def to_foreground
+        self.class.new(
+          red: triplet.red,
+          green: triplet.green,
+          blue: triplet.blue,
+          layer: :foreground,
+        )
       end
 
       private
 
-      attr_reader :code
+      attr_reader :triplet
 
-      def interpret_triplet!(spec)
-        if !spec.include?(:r) || !spec.include?(:g) || !spec.include?(:b)
-          raise ArgumentError.new(
-            "#{spec.inspect} is not a valid color specification. " +
-            "Please provide a hash with :r, :g, and :b keys.",
-          )
+      def leading_code
+        LEADING_CODES_BY_LAYER.fetch(layer)
+      end
+
+      def interpret_sequence!(sequence)
+        match = sequence.match(OPENING_REGEX)
+
+        if match
+          {
+            layer: interpret_layer!(match[1]),
+            triplet: interpret_triplet!(
+              red: match[2].to_i,
+              green: match[3].to_i,
+              blue: match[4].to_i,
+            ),
+          }
         end
+      end
 
-        if spec.values.any? { |component| !VALID_COMPONENT_RANGE.cover?(component) }
+      def interpret_triplet!(red:, green:, blue:)
+        if invalid_triplet?(red, green, blue)
           raise ArgumentError.new(
-            "(#{spec[:r]},#{spec[:g]},#{spec[:b]}) is not a valid color " +
+            "(#{red},#{green},#{blue}) is not a valid color " +
             "specification. All components must be between " +
             "#{VALID_COMPONENT_RANGE.begin} and #{VALID_COMPONENT_RANGE.end}.",
           )
         end
 
-        "#{spec[:r]};#{spec[:g]};#{spec[:b]}"
+        Triplet.new(red: red, green: green, blue: blue)
+      end
+
+      def invalid_triplet?(*values)
+        values.none? { |component| VALID_COMPONENT_RANGE.cover?(component) }
+      end
+
+      def interpret_layer!(value)
+        if value.to_s.to_i > 0
+          LAYERS_BY_LEADING_CODE.fetch(value.to_s.to_i)
+        else
+          super
+        end
+      end
+
+      class Triplet
+        attr_reader :red, :green, :blue
+
+        def initialize(red:, green:, blue:)
+          @red = red
+          @green = green
+          @blue = blue
+        end
       end
     end
   end

data/lib/super_diff/csi/uncolorized_document.rb

@@ -0,0 +1,29 @@
+module SuperDiff
+  module Csi
+    class UncolorizedDocument < Document
+      protected
+
+      def colorize_block(*, &block)
+        evaluate_block(&block)
+      end
+
+      def colorize_inline(contents, *)
+        contents.each do |content|
+          if content.is_a?(self.class)
+            content.each do |part|
+              add_part(part)
+            end
+          else
+            add_part(content)
+          end
+        end
+      end
+
+      def add_part(part)
+        if !part.is_a?(ResetSequence) && !part.is_a?(ColorSequenceBlock)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/diff_formatter.rb

@@ -1,32 +1,27 @@
 module SuperDiff
   class DiffFormatter
-    def self.call(*args)
-      new(*args).call
-    end
+    extend AttrExtras.mixin
 
-    def initialize(
-      operations,
-      indent_level:,
-      add_comma: false,
-      extra_classes: []
+    method_object(
+      :operations,
+      [
+        :indent_level!,
+        add_comma: false,
+        extra_classes: [],
+      ],
     )
-      @operations = operations
-      @indent_level = indent_level
-      @add_comma = add_comma
-      @extra_classes = extra_classes
-    end
 
     def call
       resolved_class.call(
         operations,
         indent_level: indent_level,
-        add_comma: add_comma,
+        add_comma: add_comma?,
       )
     end
 
     private
 
-    attr_reader :operations, :indent_level, :add_comma, :extra_classes
+    attr_query :add_comma?
 
     def resolved_class
       (DiffFormatters::DEFAULTS + extra_classes).find do |klass|