super_diff 0.12.1 → 0.14.0

data/lib/super_diff/csi/eight_bit_color.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class EightBitColor < Color
-      VALID_COMPONENT_RANGE = (0..6).freeze
-      VALID_CODE_RANGE = (0..255).freeze
+      VALID_COMPONENT_RANGE = (0..6)
+      VALID_CODE_RANGE = (0..255)
       VALID_CODES_BY_NAME = {
         black: 0,
         red: 1,
@@ -35,7 +37,7 @@ module SuperDiff
       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
+      OPENING_REGEX = /\e\[(\d+);#{SERIAL_CODE};(\d+)m/
 
       def self.opening_regex
         OPENING_REGEX
@@ -50,6 +52,7 @@ module SuperDiff
         type: nil,
         index: nil
       )
+        super()
         if value
           case value
           when Symbol
@@ -92,14 +95,12 @@ module SuperDiff
 
       def interpret_triplet!(red:, green:, blue:)
         if invalid_triplet?(red, green, blue)
-          raise ArgumentError.new(
-                  "(#{red},#{green},#{blue}) is not a valid color " +
-                    "specification. All components must be between " +
-                    "#{VALID_COMPONENT_RANGE.begin} and #{VALID_COMPONENT_RANGE.end}."
-                )
+          raise ArgumentError, "(#{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 * red + 6 * green + blue
+        16 + (36 * red) + (6 * green) + blue
       end
 
       def invalid_triplet?(*values)
@@ -107,37 +108,33 @@ module SuperDiff
       end
 
       def interpret_color_name!(name)
-        if !VALID_CODES_BY_NAME.include?(name)
+        unless VALID_CODES_BY_NAME.include?(name)
           message =
-            "#{name.inspect} is not a valid color name.\n" +
-              "Valid names are:\n"
+            "#{name.inspect} is not a valid color name.\n" \
+            "Valid names are:\n"
 
-          VALID_CODES_BY_NAME.keys.each do |valid_name|
+          VALID_CODES_BY_NAME.each_key do |valid_name|
             message << "- #{valid_name}\n"
           end
 
-          raise ArgumentError.new(message)
+          raise ArgumentError, message
         end
 
         VALID_CODES_BY_NAME[name]
       end
 
       def interpret_pair!(type:, index:)
-        if !VALID_PAIR_TYPES.include?(type)
-          raise ArgumentError.new(
-                  "Given pair did not have a valid type. " +
-                    "Type must be one of: #{VALID_PAIR_TYPES}"
-                )
+        unless VALID_PAIR_TYPES.include?(type)
+          raise ArgumentError, 'Given pair did not have a valid type. ' \
+                               "Type must be one of: #{VALID_PAIR_TYPES}"
         end
 
         valid_range = VALID_PAIR_INDEX_RANGES[type]
 
-        if !valid_range.cover?(index)
-          raise ArgumentError.new(
-                  "Given pair did not have a valid index. " +
-                    "For #{type}, index must be between #{valid_range.begin} and " +
-                    "#{valid_range.end}."
-                )
+        unless valid_range.cover?(index)
+          raise ArgumentError, 'Given pair did not have a valid index. ' \
+                               "For #{type}, index must be between #{valid_range.begin} and " \
+                               "#{valid_range.end}."
         end
 
         STARTING_INDICES[type] + index
@@ -146,16 +143,16 @@ module SuperDiff
       def interpret_sequence!(sequence)
         match = sequence.match(OPENING_REGEX)
 
-        if match
-          {
-            layer: interpret_layer!(match[1]),
-            code: interpret_code!(match[2].to_i)
-          }
-        end
+        return unless match
+
+        {
+          layer: interpret_layer!(match[1]),
+          code: interpret_code!(match[2].to_i)
+        }
       end
 
       def interpret_layer!(value)
-        if value.to_s.to_i > 0
+        if value.to_s.to_i.positive?
           LAYERS_BY_LEADING_CODE.fetch(value.to_s.to_i)
         else
           super
@@ -163,11 +160,9 @@ module SuperDiff
       end
 
       def interpret_code!(code)
-        if !VALID_CODE_RANGE.cover?(code)
-          raise ArgumentError.new(
-                  "#{code.inspect} is not a valid color code " +
-                    "(must be between 0 and 255)."
-                )
+        unless VALID_CODE_RANGE.cover?(code)
+          raise ArgumentError, "#{code.inspect} is not a valid color code " \
+                               '(must be between 0 and 255).'
         end
 
         code

data/lib/super_diff/csi/four_bit_color.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class FourBitColor < Color
@@ -83,10 +85,10 @@ module SuperDiff
         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
+      OPENING_REGEX = /\e\[(\d+)m/
 
       def self.exists?(name)
-        VALID_CODES_BY_NAME.has_key?(name)
+        VALID_CODES_BY_NAME.key?(name)
       end
 
       def self.opening_regex
@@ -94,6 +96,7 @@ module SuperDiff
       end
 
       def initialize(value, layer: nil)
+        super()
         if value.is_a?(Symbol)
           @name = interpret_name!(value)
           @layer = interpret_layer!(layer)
@@ -124,14 +127,14 @@ module SuperDiff
       attr_reader :name
 
       def interpret_name!(name)
-        if !VALID_NAMES.include?(name)
+        unless VALID_NAMES.include?(name)
           message =
-            "#{name.inspect} is not a valid color name.\n" +
-              "Valid names are:\n"
+            "#{name.inspect} is not a valid color name.\n" \
+            "Valid names are:\n"
 
           VALID_NAMES.each { |valid_name| message << "- #{valid_name}" }
 
-          raise ArgumentError.new(message)
+          raise ArgumentError, message
         end
 
         name
@@ -146,14 +149,14 @@ module SuperDiff
       def interpret_code!(code)
         if VALID_CODE_RANGES.none? { |range| range.cover?(code) }
           message =
-            "#{code.inspect} is not a valid color code.\n" +
-              "Valid codes are:\n"
+            "#{code.inspect} is not a valid color code.\n" \
+            "Valid codes are:\n"
 
           VALID_CODE_RANGES.each do |range|
             message << "- #{range.begin} through #{range.end}\n"
           end
 
-          raise ArgumentError.new(message)
+          raise ArgumentError, message
         end
 
         COLORS_BY_CODE.fetch(code)

data/lib/super_diff/csi/reset_sequence.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class ResetSequence

data/lib/super_diff/csi/twenty_four_bit_color.rb

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class TwentyFourBitColor < Color
-      VALID_COMPONENT_RANGE = (0..255).freeze
+      VALID_COMPONENT_RANGE = (0..255)
       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
+      OPENING_REGEX = /\e\[(\d+);#{SERIAL_CODE};(\d+);(\d+);(\d+)m/
 
       def self.opening_regex
         OPENING_REGEX
       end
 
       def initialize(value = nil, layer: nil, red: nil, green: nil, blue: nil)
+        super()
         if value
           pair = interpret_sequence!(value)
           @triplet = pair.fetch(:triplet)
@@ -23,13 +26,13 @@ module SuperDiff
       end
 
       def to_s
-        [
+        [ # rubocop:disable Style/StringConcatenation
           "\e[#{leading_code}",
           SERIAL_CODE,
           triplet.red,
           triplet.blue,
           triplet.green
-        ].join(";") + "m"
+        ].join(';') + 'm'
       end
 
       def to_foreground
@@ -52,26 +55,24 @@ module SuperDiff
       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
+        return unless 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
 
       def interpret_triplet!(red:, green:, blue:)
         if invalid_triplet?(red, green, blue)
-          raise ArgumentError.new(
-                  "(#{red},#{green},#{blue}) is not a valid color " +
-                    "specification. All components must be between " +
-                    "#{VALID_COMPONENT_RANGE.begin} and #{VALID_COMPONENT_RANGE.end}."
-                )
+          raise ArgumentError, "(#{red},#{green},#{blue}) is not a valid color " \
+                               'specification. All components must be between ' \
+                               "#{VALID_COMPONENT_RANGE.begin} and #{VALID_COMPONENT_RANGE.end}."
         end
 
         Triplet.new(red: red, green: green, blue: blue)
@@ -82,7 +83,7 @@ module SuperDiff
       end
 
       def interpret_layer!(value)
-        if value.to_s.to_i > 0
+        if value.to_s.to_i.positive?
           LAYERS_BY_LEADING_CODE.fetch(value.to_s.to_i)
         else
           super

data/lib/super_diff/csi/uncolorized_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class UncolorizedDocument < Document

data/lib/super_diff/csi.rb

@@ -1,37 +1,23 @@
+# frozen_string_literal: true
+
 # 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
+    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'
 
     def self.reset_sequence
       ResetSequence.new
     end
 
-    def self.color_enabled?
-      @color_enabled
-    end
-
-    def self.colorize(*args, **opts, &block)
-      if color_enabled?
-        ColorizedDocument.new(*args, **opts, &block)
-      else
-        UncolorizedDocument.new(*args, **opts, &block)
-      end
-    end
-
     def self.decolorize(text)
       text.gsub(/\e\[\d+(?:;\d+)*m(.+?)\e\[0m/, '\1')
     end
@@ -39,21 +25,5 @@ module SuperDiff
     def self.already_colorized?(text)
       text.match?(/\e\[\d+m/)
     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)
-
-          layer_indicator = (color.foreground? ? "(fg)" : "(bg)")
-
-          "#{color_block} #{layer_indicator} ❮#{area}❯"
-        end
-      end
-    end
-
-    self.color_enabled = false
   end
 end

data/lib/super_diff/differs.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Differs
     def self.const_missing(missing_const_name)
       if missing_const_name == :Base
-        warn <<~EOT
+        warn <<~WARNING
           WARNING: SuperDiff::Differs::#{missing_const_name} is deprecated and will be removed in the next major release.
           Please use SuperDiff::Core::AbstractDiffer instead.
           #{caller_locations.join("\n")}
-        EOT
+        WARNING
         Core::AbstractDiffer
       elsif Basic::Differs.const_defined?(missing_const_name)
-        warn <<~EOT
+        warn <<~WARNING
           WARNING: SuperDiff::Differs::#{missing_const_name} is deprecated and will be removed in the next major release.
           Please use SuperDiff::Basic::Differs::#{missing_const_name} instead.
           #{caller_locations.join("\n")}
-        EOT
+        WARNING
         Basic::Differs.const_get(missing_const_name)
       else
         super

data/lib/super_diff/equality_matchers/array.rb

@@ -1,30 +1,32 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class Array < Base
       def self.applies_to?(value)
-        value.class == ::Array
+        value.instance_of?(::Array)
       end
 
       def fail
         <<~OUTPUT.strip
-          Differing arrays.
+            Differing arrays.
 
-          #{
-          Core::Helpers.style(
-            :expected,
-            "Expected: " + SuperDiff.inspect_object(expected, as_lines: false)
-          )
-        }
-          #{
-          Core::Helpers.style(
-            :actual,
-            "  Actual: " + SuperDiff.inspect_object(actual, as_lines: false)
-          )
-        }
+            #{
+            Core::Helpers.style(
+              :expected,
+              "Expected: #{SuperDiff.inspect_object(expected, as_lines: false)}"
+            )
+          }
+            #{
+            Core::Helpers.style(
+              :actual,
+              "  Actual: #{SuperDiff.inspect_object(actual, as_lines: false)}"
+            )
+          }
 
-          Diff:
+            Diff:
 
-          #{diff}
+            #{diff}
         OUTPUT
       end
 

data/lib/super_diff/equality_matchers/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class Base
@@ -11,14 +13,14 @@ module SuperDiff
         [
           :expected!,
           :actual!,
-          extra_operation_tree_builder_classes: [],
-          extra_diff_formatter_classes: []
+          { extra_operation_tree_builder_classes: [],
+            extra_diff_formatter_classes: [] }
         ]
       )
 
       def call
-        if expected == actual
-          ""
+        if expected == actual # rubocop:disable Style/GuardClause `fail` is not Kernel#fail
+          ''
         else
           fail
         end

data/lib/super_diff/equality_matchers/default.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class Default < Base
@@ -20,20 +22,20 @@ module SuperDiff
       def expected_line
         Core::Helpers.style(
           :expected,
-          "Expected: " + SuperDiff.inspect_object(expected, as_lines: false)
+          "Expected: #{SuperDiff.inspect_object(expected, as_lines: false)}"
         )
       end
 
       def actual_line
         Core::Helpers.style(
           :actual,
-          "  Actual: " + SuperDiff.inspect_object(actual, as_lines: false)
+          "  Actual: #{SuperDiff.inspect_object(actual, as_lines: false)}"
         )
       end
 
       def diff_section
         if diff.empty?
-          ""
+          ''
         else
           <<~SECTION
 

data/lib/super_diff/equality_matchers/defaults.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     DEFAULTS = [
-      Primitive,
       Array,
       Hash,
       MultilineString,
       SinglelineString,
+      Primitive,
       Default
     ].freeze
   end

data/lib/super_diff/equality_matchers/hash.rb

@@ -1,30 +1,32 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class Hash < Base
       def self.applies_to?(value)
-        value.class == ::Hash
+        value.instance_of?(::Hash)
       end
 
       def fail
         <<~OUTPUT.strip
-          Differing hashes.
+            Differing hashes.
 
-          #{
-          Core::Helpers.style(
-            :expected,
-            "Expected: " + SuperDiff.inspect_object(expected, as_lines: false)
-          )
-        }
-          #{
-          Core::Helpers.style(
-            :actual,
-            "  Actual: " + SuperDiff.inspect_object(actual, as_lines: false)
-          )
-        }
+            #{
+            Core::Helpers.style(
+              :expected,
+              "Expected: #{SuperDiff.inspect_object(expected, as_lines: false)}"
+            )
+          }
+            #{
+            Core::Helpers.style(
+              :actual,
+              "  Actual: #{SuperDiff.inspect_object(actual, as_lines: false)}"
+            )
+          }
 
-          Diff:
+            Diff:
 
-          #{diff}
+            #{diff}
         OUTPUT
       end
 

data/lib/super_diff/equality_matchers/main.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class Main
       extend AttrExtras.mixin
 
-      method_object [:expected!, :actual!, extra_classes: []]
+      method_object [:expected!, :actual!, { extra_classes: [] }]
 
       def call
         resolved_class.call(expected: expected, actual: actual)

data/lib/super_diff/equality_matchers/multiline_string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class MultilineString < Base
@@ -7,25 +9,25 @@ module SuperDiff
 
       def fail
         <<~OUTPUT.strip
-          Differing strings.
+            Differing strings.
 
-          #{
-          # TODO: This whole thing should not be red or green, just the values
-          Core::Helpers.style(
-            :expected,
-            "Expected: " + SuperDiff.inspect_object(expected, as_lines: false)
-          )
-        }
-          #{
-          Core::Helpers.style(
-            :actual,
-            "  Actual: " + SuperDiff.inspect_object(actual, as_lines: false)
-          )
-        }
+            #{
+            # TODO: This whole thing should not be red or green, just the values
+            Core::Helpers.style(
+              :expected,
+              "Expected: #{SuperDiff.inspect_object(expected, as_lines: false)}"
+            )
+          }
+            #{
+            Core::Helpers.style(
+              :actual,
+              "  Actual: #{SuperDiff.inspect_object(actual, as_lines: false)}"
+            )
+          }
 
-          Diff:
+            Diff:
 
-          #{diff}
+            #{diff}
         OUTPUT
       end
 

data/lib/super_diff/equality_matchers/primitive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module EqualityMatchers
     class Primitive < Base
@@ -8,20 +10,20 @@ module SuperDiff
 
       def fail
         <<~OUTPUT.strip
-          Differing #{Core::Helpers.plural_type_for(actual)}.
+            Differing #{Core::Helpers.plural_type_for(actual)}.
 
-          #{
-          Core::Helpers.style(
-            :expected,
-            "Expected: " + SuperDiff.inspect_object(expected, as_lines: false)
-          )
-        }
-          #{
-          Core::Helpers.style(
-            :actual,
-            "  Actual: " + SuperDiff.inspect_object(actual, as_lines: false)
-          )
-        }
+            #{
+            Core::Helpers.style(
+              :expected,
+              "Expected: #{SuperDiff.inspect_object(expected, as_lines: false)}"
+            )
+          }
+            #{
+            Core::Helpers.style(
+              :actual,
+              "  Actual: #{SuperDiff.inspect_object(actual, as_lines: false)}"
+            )
+          }
         OUTPUT
       end
     end