super_diff 0.1.0 → 0.2.0

data/lib/super_diff/diff_formatters.rb

@@ -1,5 +1,14 @@
 module SuperDiff
   module DiffFormatters
-    DEFAULTS = [Array, Hash, MultiLineString].freeze
+    autoload :Array, "super_diff/diff_formatters/array"
+    autoload :Base, "super_diff/diff_formatters/base"
+    autoload :Collection, "super_diff/diff_formatters/collection"
+    autoload :CustomObject, "super_diff/diff_formatters/custom_object"
+    autoload :DefaultObject, "super_diff/diff_formatters/default_object"
+    autoload :Hash, "super_diff/diff_formatters/hash"
+    autoload :MultilineString, "super_diff/diff_formatters/multiline_string"
+
+    # TODO: Why doesn't this include CustomObject and DefaultObject?
+    DEFAULTS = [Array, Hash, MultilineString].freeze
   end
 end

data/lib/super_diff/diff_formatters/base.rb

@@ -5,33 +5,28 @@ module SuperDiff
         raise NotImplementedError
       end
 
-      def self.call(*args)
-        new(*args).call
-      end
+      extend AttrExtras.mixin
 
-      def initialize(
-        operations,
-        indent_level:,
-        collection_prefix: "",
-        add_comma: false
+      method_object(
+        :operations,
+        [
+          :indent_level!,
+          collection_prefix: "",
+          add_comma: false,
+        ],
       )
-        @operations = operations
-        @indent_level = indent_level
-        @collection_prefix = collection_prefix
-        @add_comma = add_comma
-      end
 
       def call
         raise NotImplementedError
       end
 
+      # rubocop:disable Lint/UselessAccessModifier
+
       private
 
-      attr_reader :operations, :indent_level, :collection_prefix
+      # rubocop:enable Lint/UselessAccessModifier
 
-      def add_comma?
-        @add_comma
-      end
+      attr_query :add_comma?
     end
   end
 end

data/lib/super_diff/diff_formatters/collection.rb

@@ -1,30 +1,22 @@
 module SuperDiff
   module DiffFormatters
     class Collection
-      ICONS = { delete: "-", insert: "+" }.freeze
-      STYLES = { insert: :inserted, delete: :deleted, noop: :normal }.freeze
+      extend AttrExtras.mixin
 
-      def self.call(*args, &block)
-        new(*args, &block).call
-      end
+      ICONS = { delete: "-", insert: "+" }.freeze
+      STYLES = { insert: :beta, delete: :alpha, noop: :plain }.freeze
 
-      def initialize(
-        open_token:,
-        close_token:,
-        operations:,
-        indent_level:,
-        add_comma:,
-        collection_prefix:,
-        build_item_prefix:
+      method_object(
+        [
+          :open_token!,
+          :close_token!,
+          :operations!,
+          :indent_level!,
+          :add_comma!,
+          :collection_prefix!,
+          :build_item_prefix!,
+        ],
       )
-        @open_token = open_token
-        @close_token = close_token
-        @operations = operations
-        @indent_level = indent_level
-        @add_comma = add_comma
-        @collection_prefix = collection_prefix
-        @build_item_prefix = build_item_prefix
-      end
 
       def call
         lines.join("\n")
@@ -32,8 +24,7 @@ module SuperDiff
 
       private
 
-      attr_reader :open_token, :close_token, :operations, :indent_level,
-        :add_comma, :collection_prefix, :build_item_prefix
+      attr_query :add_comma?
 
       def lines
         [
@@ -46,42 +37,82 @@ module SuperDiff
       def contents
         operations.map do |operation|
           if operation.name == :change
+            handle_change_operation(operation)
+          else
+            handle_non_change_operation(operation)
+          end
+        end
+      end
+
+      def handle_change_operation(operation)
+        SuperDiff::RecursionGuard.guarding_recursion_of(
+          operation.left_collection,
+          operation.right_collection,
+        ) do |already_seen|
+          if already_seen
+            raise "Infinite recursion!"
+          else
             operation.child_operations.to_diff(
               indent_level: indent_level + 1,
               collection_prefix: build_item_prefix.call(operation),
               add_comma: operation.should_add_comma_after_displaying?,
             )
-          else
-            icon = ICONS.fetch(operation.name, " ")
-            style_name = STYLES.fetch(operation.name, :normal)
-            chunk = build_chunk(
-              Helpers.inspect_object(operation.value, single_line: false),
-              prefix: build_item_prefix.call(operation),
-              icon: icon,
-            )
+          end
+        end
+      end
 
-            if operation.should_add_comma_after_displaying?
-              chunk << ","
-            end
+      def handle_non_change_operation(operation)
+        icon = ICONS.fetch(operation.name, " ")
+        style_name = STYLES.fetch(operation.name, :normal)
+        chunk = build_chunk_for(
+          operation,
+          prefix: build_item_prefix.call(operation),
+          icon: icon,
+        )
 
-            style_chunk(style_name, chunk)
-          end
+        if operation.should_add_comma_after_displaying?
+          chunk << ","
         end
+
+        style_chunk(style_name, chunk)
       end
 
-      def build_chunk(content, prefix:, icon:)
-        lines =
-          if content.is_a?(ValueInspection)
-            [
-              indentation(offset: 1) + prefix + content.beginning,
-              *content.middle.map { |line| indentation(offset: 2) + line },
-              indentation(offset: 1) + content.end,
-            ]
-          else
-            [indentation(offset: 1) + prefix + content]
-          end
+      def build_chunk_for(operation, prefix:, icon:)
+        if operation.value.equal?(operation.collection)
+          build_chunk_from_string(
+            SuperDiff::RecursionGuard::PLACEHOLDER,
+            prefix: build_item_prefix.call(operation),
+            icon: icon,
+          )
+        else
+          build_chunk_by_inspecting(
+            operation.value,
+            prefix: build_item_prefix.call(operation),
+            icon: icon,
+          )
+        end
+      end
 
-        lines.map { |line| icon + " " + line }.join("\n")
+      def build_chunk_by_inspecting(value, prefix:, icon:)
+        inspection = ObjectInspection.inspect(
+          value,
+          as_single_line: false,
+        )
+        build_chunk_from_string(inspection, prefix: prefix, icon: icon)
+      end
+
+      def build_chunk_from_string(value, prefix:, icon:)
+        value.split("\n").
+          map.with_index { |line, index|
+            [
+              icon,
+              " ",
+              indentation(offset: 1),
+              (index == 0 ? prefix : ""),
+              line,
+            ].join
+          }.
+          join("\n")
       end
 
       def style_chunk(style_name, chunk)
@@ -92,11 +123,11 @@ module SuperDiff
       end
 
       def indentation(offset: 0)
-        " " * ((indent_level + offset) * 2)
+        "  " * (indent_level + offset)
       end
 
       def comma
-        if add_comma
+        if add_comma?
           ","
         else
           ""

data/lib/super_diff/diff_formatters/{object.rb → custom_object.rb}

@@ -1,8 +1,8 @@
 module SuperDiff
   module DiffFormatters
-    class Object < Base
+    class CustomObject < DefaultObject
       def self.applies_to?(operations)
-        operations.is_a?(OperationSequences::Object)
+        operations.is_a?(OperationSequences::CustomObject)
       end
 
       def call
@@ -10,18 +10,21 @@ module SuperDiff
           open_token: "#<#{value_class} {",
           close_token: "}>",
           collection_prefix: collection_prefix,
-          build_item_prefix: -> (operation) { "#{operation.key}: " },
+          build_item_prefix: -> (operation) {
+            key =
+              if operation.respond_to?(:left_key)
+                operation.left_key
+              else
+                operation.key
+              end
+
+            "#{key}: "
+          },
           operations: operations,
           indent_level: indent_level,
           add_comma: add_comma?,
         )
       end
-
-      protected
-
-      def value_class
-        raise NotImplementedError
-      end
     end
   end
 end

data/lib/super_diff/diff_formatters/default_object.rb

@@ -0,0 +1,48 @@
+module SuperDiff
+  module DiffFormatters
+    class DefaultObject < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::DefaultObject)
+      end
+
+      def initialize(operations, value_class: nil, **rest)
+        super(operations, **rest)
+
+        @value_class = value_class
+      end
+
+      def call
+        Collection.call(
+          open_token: "#<#{value_class} {",
+          close_token: "}>",
+          collection_prefix: collection_prefix,
+          build_item_prefix: -> (operation) {
+            key =
+              if operation.respond_to?(:left_key)
+                operation.left_key
+              else
+                operation.key
+              end
+
+            "@#{key}="
+          },
+          operations: operations,
+          indent_level: indent_level,
+          add_comma: add_comma?,
+        )
+      end
+
+      protected
+
+      def value_class
+        if @value_class
+          @value_class
+        else
+          raise NotImplementedError.new(
+            "You must override #value_class in your subclass.",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/diff_formatters/multiline_string.rb

@@ -0,0 +1,31 @@
+module SuperDiff
+  module DiffFormatters
+    class MultilineString < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::MultilineString)
+      end
+
+      def call
+        lines.join("\n")
+      end
+
+      private
+
+      def lines
+        operations.reduce([]) do |array, operation|
+          case operation.name
+          when :change
+            array << Helpers.style(:alpha, "- #{operation.left_value}")
+            array << Helpers.style(:beta, "+ #{operation.right_value}")
+          when :delete
+            array << Helpers.style(:alpha, "- #{operation.value}")
+          when :insert
+            array << Helpers.style(:beta, "+ #{operation.value}")
+          else
+            array << Helpers.style(:plain, "  #{operation.value}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/differ.rb

@@ -1,47 +1,50 @@
 module SuperDiff
   class Differ
-    def self.call(*args)
-      new(*args).call
-    end
+    extend AttrExtras.mixin
 
-    def initialize(
-      expected,
-      actual,
-      indent_level: 0,
-      index_in_collection: nil,
-      extra_classes: [],
-      extra_operational_sequencer_classes: [],
-      extra_diff_formatter_classes: []
+    method_object(
+      :expected,
+      :actual,
+      [
+        indent_level: 0,
+        index_in_collection: nil,
+        omit_empty: false,
+        extra_classes: [],
+        extra_operational_sequencer_classes: [],
+        extra_diff_formatter_classes: [],
+      ],
     )
-      @expected = expected
-      @actual = actual
-      @indent_level = indent_level
-      @index_in_collection = index_in_collection
-      @extra_classes = extra_classes
-      @extra_operational_sequencer_classes = extra_operational_sequencer_classes
-      @extra_diff_formatter_classes = extra_diff_formatter_classes
-    end
 
     def call
-      resolved_class.call(
-        expected,
-        actual,
-        indent_level: indent_level,
-        index_in_collection: index_in_collection,
-        extra_operational_sequencer_classes: extra_operational_sequencer_classes,
-        extra_diff_formatter_classes: extra_diff_formatter_classes,
-      )
+      if resolved_class
+        resolved_class.call(
+          expected,
+          actual,
+          indent_level: indent_level,
+          index_in_collection: index_in_collection,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      else
+        raise NoDifferAvailableError.create(expected, actual)
+      end
     end
 
     private
 
-    attr_reader :expected, :actual, :indent_level, :index_in_collection,
-      :extra_classes, :extra_operational_sequencer_classes,
-      :extra_diff_formatter_classes
+    attr_query :omit_empty?
 
     def resolved_class
-      (Differs::DEFAULTS + extra_classes).find do |klass|
-        klass.applies_to?(expected) && klass.applies_to?(actual)
+      available_classes.find { |klass| klass.applies_to?(expected, actual) }
+    end
+
+    def available_classes
+      classes = extra_classes + Differs::DEFAULTS
+
+      if omit_empty?
+        classes - [Differs::Empty]
+      else
+        classes
       end
     end
   end

data/lib/super_diff/differs.rb

@@ -1,5 +1,20 @@
 module SuperDiff
   module Differs
-    DEFAULTS = [Array, Hash, MultiLineString, Object, Empty].freeze
+    autoload :Array, "super_diff/differs/array"
+    autoload :Base, "super_diff/differs/base"
+    autoload :CustomObject, "super_diff/differs/custom_object"
+    autoload :DefaultObject, "super_diff/differs/default_object"
+    autoload :Empty, "super_diff/differs/empty"
+    autoload :Hash, "super_diff/differs/hash"
+    autoload :MultilineString, "super_diff/differs/multiline_string"
+
+    DEFAULTS = [
+      Array,
+      Hash,
+      MultilineString,
+      CustomObject,
+      DefaultObject,
+      Empty,
+    ].freeze
   end
 end