super_diff 0.13.0 → 0.14.0

data/lib/super_diff/core/tiered_lines_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Core
     class TieredLinesFormatter
@@ -29,8 +31,8 @@ module SuperDiff
       class FormattableLine
         extend AttrExtras.mixin
 
-        INDENTATION_UNIT = "  ".freeze
-        ICONS = { delete: "-", insert: "+", elision: " ", noop: " " }.freeze
+        INDENTATION_UNIT = '  '
+        ICONS = { delete: '-', insert: '+', elision: ' ', noop: ' ' }.freeze
         COLORS = {
           delete: :expected,
           insert: :actual,
@@ -41,7 +43,7 @@ module SuperDiff
         pattr_initialize :line
 
         def content
-          icon + " " + indentation + line.prefix + line.value + possible_comma
+          "#{icon} #{indentation}#{line.prefix}#{line.value}#{possible_comma}"
         end
 
         def color
@@ -69,7 +71,7 @@ module SuperDiff
         end
 
         def possible_comma
-          line.add_comma? ? "," : ""
+          line.add_comma? ? ',' : ''
         end
       end
     end

data/lib/super_diff/core/unary_operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Core
     class UnaryOperation

data/lib/super_diff/core.rb

@@ -1,69 +1,71 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Core
-    autoload :AbstractDiffer, "super_diff/core/abstract_differ"
+    autoload :AbstractDiffer, 'super_diff/core/abstract_differ'
     autoload(
       :AbstractInspectionTreeBuilder,
-      "super_diff/core/abstract_inspection_tree_builder"
+      'super_diff/core/abstract_inspection_tree_builder'
     )
-    autoload :AbstractOperationTree, "super_diff/core/abstract_operation_tree"
+    autoload :AbstractOperationTree, 'super_diff/core/abstract_operation_tree'
     autoload(
       :AbstractOperationTreeBuilder,
-      "super_diff/core/abstract_operation_tree_builder"
+      'super_diff/core/abstract_operation_tree_builder'
     )
     autoload(
       :AbstractOperationTreeFlattener,
-      "super_diff/core/abstract_operation_tree_flattener"
+      'super_diff/core/abstract_operation_tree_flattener'
     )
-    autoload :BinaryOperation, "super_diff/core/binary_operation"
+    autoload :BinaryOperation, 'super_diff/core/binary_operation'
     autoload(
       :ColorizedDocumentExtensions,
-      "super_diff/core/colorized_document_extensions"
+      'super_diff/core/colorized_document_extensions'
     )
-    autoload :Configuration, "super_diff/core/configuration"
-    autoload :DifferDispatcher, "super_diff/core/differ_dispatcher"
-    autoload :GemVersion, "super_diff/core/gem_version"
-    autoload :Helpers, "super_diff/core/helpers"
-    autoload :ImplementationChecks, "super_diff/core/implementation_checks"
-    autoload :InspectionTree, "super_diff/core/inspection_tree"
+    autoload :Configuration, 'super_diff/core/configuration'
+    autoload :DifferDispatcher, 'super_diff/core/differ_dispatcher'
+    autoload :GemVersion, 'super_diff/core/gem_version'
+    autoload :Helpers, 'super_diff/core/helpers'
+    autoload :ImplementationChecks, 'super_diff/core/implementation_checks'
+    autoload :InspectionTree, 'super_diff/core/inspection_tree'
     autoload(
       :InspectionTreeBuilderDispatcher,
-      "super_diff/core/inspection_tree_builder_dispatcher"
+      'super_diff/core/inspection_tree_builder_dispatcher'
     )
-    autoload :InspectionTreeNodes, "super_diff/core/inspection_tree_nodes"
-    autoload :Line, "super_diff/core/line"
+    autoload :InspectionTreeNodes, 'super_diff/core/inspection_tree_nodes'
+    autoload :Line, 'super_diff/core/line'
     autoload(
       :OperationTreeBuilderDispatcher,
-      "super_diff/core/operation_tree_builder_dispatcher"
+      'super_diff/core/operation_tree_builder_dispatcher'
     )
     autoload(
       :NoDifferAvailableError,
-      "super_diff/core/no_differ_available_error"
+      'super_diff/core/no_differ_available_error'
     )
     autoload(
       :NoInspectionTreeAvailableError,
-      "super_diff/core/no_inspection_tree_builder_available_error"
+      'super_diff/core/no_inspection_tree_builder_available_error'
     )
     autoload(
       :NoOperationTreeBuilderAvailableError,
-      "super_diff/core/no_operation_tree_builder_available_error"
+      'super_diff/core/no_operation_tree_builder_available_error'
     )
     autoload(
       :NoOperationTreeAvailableError,
-      "super_diff/core/no_operation_tree_available_error"
+      'super_diff/core/no_operation_tree_available_error'
     )
-    autoload :OperationTreeFinder, "super_diff/core/operation_tree_finder"
+    autoload :OperationTreeFinder, 'super_diff/core/operation_tree_finder'
     autoload(
       :PrefixForNextInspectionTreeNode,
-      "super_diff/core/prefix_for_next_inspection_tree_node"
+      'super_diff/core/prefix_for_next_inspection_tree_node'
     )
     autoload(
       :PreludeForNextInspectionTreeNode,
-      "super_diff/core/prelude_for_next_inspection_tree_node"
+      'super_diff/core/prelude_for_next_inspection_tree_node'
     )
-    autoload :RecursionGuard, "super_diff/core/recursion_guard"
-    autoload :TieredLines, "super_diff/core/tiered_lines"
-    autoload :TieredLinesElider, "super_diff/core/tiered_lines_elider"
-    autoload :TieredLinesFormatter, "super_diff/core/tiered_lines_formatter"
-    autoload :UnaryOperation, "super_diff/core/unary_operation"
+    autoload :RecursionGuard, 'super_diff/core/recursion_guard'
+    autoload :TieredLines, 'super_diff/core/tiered_lines'
+    autoload :TieredLinesElider, 'super_diff/core/tiered_lines_elider'
+    autoload :TieredLinesFormatter, 'super_diff/core/tiered_lines_formatter'
+    autoload :UnaryOperation, 'super_diff/core/unary_operation'
   end
 end

data/lib/super_diff/csi/bold_sequence.rb

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

data/lib/super_diff/csi/color.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class Color
@@ -51,10 +53,8 @@ module SuperDiff
         if %i[foreground background].include?(layer)
           layer
         else
-          raise ArgumentError.new(
-                  "Invalid layer #{layer.inspect}. " +
-                    "Layer must be :foreground or :background."
-                )
+          raise ArgumentError, "Invalid layer #{layer.inspect}. " \
+                               'Layer must be :foreground or :background.'
         end
       end
     end

data/lib/super_diff/csi/color_sequence_block.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class ColorSequenceBlock
@@ -14,7 +16,7 @@ module SuperDiff
       def push(color)
         colors.push(color)
       end
-      alias_method :<<, :push
+      alias << push
 
       def to_s
         colors.map(&:to_s).join

data/lib/super_diff/csi/colorized_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class ColorizedDocument < Document
@@ -19,9 +21,9 @@ module SuperDiff
         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
+        return unless color_sequences_open_in_parent.any?
+
+        add_part(color_sequence_to_reopen)
       end
 
       def colorize_inline(contents, colors, opts)
@@ -54,13 +56,9 @@ module SuperDiff
         ColorSequenceBlock
           .new(colors)
           .tap do |sequence|
-            if opts[:fg]
-              sequence << Color.resolve(opts[:fg], layer: :foreground)
-            end
+            sequence << Color.resolve(opts[:fg], layer: :foreground) if opts[:fg]
 
-            if opts[:bg]
-              sequence << Color.resolve(opts[:bg], layer: :background)
-            end
+            sequence << Color.resolve(opts[:bg], layer: :background) if opts[:bg]
           end
       end
     end

data/lib/super_diff/csi/document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SuperDiff
   module Csi
     class Document
@@ -14,8 +16,8 @@ module SuperDiff
         parts.each(&block)
       end
 
-      def bold(*args, **opts, &block)
-        colorize(BoldSequence.new, *args, **opts, &block)
+      def bold(...)
+        colorize(BoldSequence.new, ...)
       end
 
       def colorize(*args, **opts, &block)
@@ -23,11 +25,10 @@ module SuperDiff
           args.partition { |arg| arg.is_a?(String) || arg.is_a?(self.class) }
 
         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
+          raise ArgumentError, "#colorize can't call itself!" if colors[0] == :colorize
+
+          public_send(colors[0], *contents, *colors[1..], **opts, &block)
+
         elsif !block && colors.empty? && opts.empty?
           text(*contents)
         elsif block
@@ -35,10 +36,10 @@ module SuperDiff
         elsif contents.any?
           colorize_inline(contents, colors, opts)
         else
-          raise ArgumentError, "Must have something to colorize!"
+          raise ArgumentError, 'Must have something to colorize!'
         end
       end
-      alias_method :colored, :colorize
+      alias colored colorize
 
       def text(*contents, **, &block)
         if block
@@ -46,10 +47,10 @@ module SuperDiff
         elsif contents.any?
           contents.each { |part| add_part(part) }
         else
-          raise ArgumentError.new("Must have something to add to the document!")
+          raise ArgumentError, 'Must have something to add to the document!'
         end
       end
-      alias_method :plain, :text
+      alias plain text
 
       def line(*contents, indent_by: 0, &block)
         indent(by: indent_by) do
@@ -60,9 +61,7 @@ module SuperDiff
           elsif contents.any?
             text(*contents)
           else
-            raise ArgumentError.new(
-                    "Must have something to add to the document!"
-                  )
+            raise ArgumentError, 'Must have something to add to the document!'
           end
         end
 
@@ -75,7 +74,7 @@ module SuperDiff
 
       def indent(by:, &block)
         # TODO: This won't work if using `text` manually to add lines
-        indentation_stack << (by.is_a?(String) ? by : " " * by)
+        indentation_stack << (by.is_a?(String) ? by : ' ' * by)
         evaluate_block(&block)
         indentation_stack.pop
       end
@@ -116,13 +115,11 @@ module SuperDiff
           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
+        if block.arity.positive?
           block.call(self)
         else
           instance_eval(&block)

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,16 +1,18 @@
+# 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"
+    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