super_diff 0.11.0 → 0.13.0

data/lib/super_diff/line.rb

@@ -1,83 +0,0 @@
-module SuperDiff
-  class Line
-    extend AttrExtras.mixin
-
-    ICONS = { delete: "-", insert: "+", noop: " " }.freeze
-    COLORS = { insert: :actual, delete: :expected, noop: :plain }.freeze
-
-    rattr_initialize(
-      [
-        :type!,
-        :indentation_level!,
-        :value!,
-        prefix: "",
-        add_comma: false,
-        children: [],
-        elided: false,
-        collection_bookend: nil,
-        complete_bookend: nil
-      ]
-    )
-    attr_query :add_comma?
-    attr_query :elided?
-
-    def clone_with(overrides = {})
-      self.class.new(
-        type: type,
-        indentation_level: indentation_level,
-        prefix: prefix,
-        value: value,
-        add_comma: add_comma?,
-        children: children,
-        elided: elided?,
-        collection_bookend: collection_bookend,
-        complete_bookend: complete_bookend,
-        **overrides
-      )
-    end
-
-    def icon
-      ICONS.fetch(type)
-    end
-
-    def color
-      COLORS.fetch(type)
-    end
-
-    def with_comma
-      clone_with(add_comma: true)
-    end
-
-    def as_elided
-      clone_with(elided: true)
-    end
-
-    def with_value_prepended(prelude)
-      clone_with(value: prelude + value)
-    end
-
-    def with_value_appended(suffix)
-      clone_with(value: value + suffix)
-    end
-
-    def prefixed_with(prefix)
-      clone_with(prefix: prefix + self.prefix)
-    end
-
-    def with_complete_bookend(complete_bookend)
-      clone_with(complete_bookend: complete_bookend)
-    end
-
-    def opens_collection?
-      collection_bookend == :open
-    end
-
-    def closes_collection?
-      collection_bookend == :close
-    end
-
-    def complete_bookend?
-      complete_bookend != nil
-    end
-  end
-end

data/lib/super_diff/object_inspection/inspection_tree_builders/base.rb

@@ -1,27 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    module InspectionTreeBuilders
-      class Base
-        extend AttrExtras.mixin
-        extend ImplementationChecks
-        include ImplementationChecks
-
-        def self.applies_to?(_value)
-          unimplemented_class_method!
-        end
-
-        method_object :object
-
-        def call
-          unimplemented_instance_method!
-        end
-
-        protected
-
-        def inspection_tree
-          unimplemented_instance_method!
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/object_inspection/inspection_tree_builders/defaults.rb

@@ -1,15 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    module InspectionTreeBuilders
-      DEFAULTS = [
-        CustomObject,
-        Array,
-        Hash,
-        Primitive,
-        TimeLike,
-        DateLike,
-        DefaultObject
-      ].freeze
-    end
-  end
-end

data/lib/super_diff/object_inspection/inspection_tree_builders/main.rb

@@ -1,30 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    module InspectionTreeBuilders
-      class Main
-        extend AttrExtras.mixin
-
-        method_object :object
-
-        def call
-          if resolved_class
-            resolved_class.call(object)
-          else
-            raise NoInspectorAvailableError.create(object)
-          end
-        end
-
-        private
-
-        def resolved_class
-          available_classes.find { |klass| klass.applies_to?(object) }
-        end
-
-        def available_classes
-          SuperDiff.configuration.extra_inspection_tree_builder_classes +
-            DEFAULTS
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/object_inspection/inspection_tree_builders.rb

@@ -1,48 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    module InspectionTreeBuilders
-      autoload(
-        :Base,
-        "super_diff/object_inspection/inspection_tree_builders/base"
-      )
-      autoload(
-        :Array,
-        "super_diff/object_inspection/inspection_tree_builders/array"
-      )
-      autoload(
-        :CustomObject,
-        "super_diff/object_inspection/inspection_tree_builders/custom_object"
-      )
-      autoload(
-        :DefaultObject,
-        "super_diff/object_inspection/inspection_tree_builders/default_object"
-      )
-      autoload(
-        :Hash,
-        "super_diff/object_inspection/inspection_tree_builders/hash"
-      )
-      autoload(
-        :Main,
-        "super_diff/object_inspection/inspection_tree_builders/main"
-      )
-      autoload(
-        :Primitive,
-        "super_diff/object_inspection/inspection_tree_builders/primitive"
-      )
-      autoload(
-        :String,
-        "super_diff/object_inspection/inspection_tree_builders/string"
-      )
-      autoload(
-        :TimeLike,
-        "super_diff/object_inspection/inspection_tree_builders/time_like"
-      )
-      autoload(
-        :DateLike,
-        "super_diff/object_inspection/inspection_tree_builders/date_like"
-      )
-    end
-  end
-end
-
-require "super_diff/object_inspection/inspection_tree_builders/defaults"

data/lib/super_diff/object_inspection/nodes.rb

@@ -1,50 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    module Nodes
-      autoload(
-        :AsLinesWhenRenderingToLines,
-        "super_diff/object_inspection/nodes/as_lines_when_rendering_to_lines"
-      )
-      autoload(
-        :AsPrefixWhenRenderingToLines,
-        "super_diff/object_inspection/nodes/as_prefix_when_rendering_to_lines"
-      )
-      autoload(
-        :AsPreludeWhenRenderingToLines,
-        "super_diff/object_inspection/nodes/as_prelude_when_rendering_to_lines"
-      )
-      autoload(
-        :AsSingleLine,
-        "super_diff/object_inspection/nodes/as_single_line"
-      )
-      autoload :Base, "super_diff/object_inspection/nodes/base"
-      autoload :Inspection, "super_diff/object_inspection/nodes/inspection"
-      autoload :Nesting, "super_diff/object_inspection/nodes/nesting"
-      autoload :OnlyWhen, "super_diff/object_inspection/nodes/only_when"
-      autoload :Text, "super_diff/object_inspection/nodes/text"
-      autoload(
-        :WhenRenderingToLines,
-        "super_diff/object_inspection/nodes/when_rendering_to_lines"
-      )
-      autoload(
-        :WhenRenderingToString,
-        "super_diff/object_inspection/nodes/when_rendering_to_string"
-      )
-
-      def self.registry
-        @_registry ||= [
-          AsLinesWhenRenderingToLines,
-          AsPrefixWhenRenderingToLines,
-          AsPreludeWhenRenderingToLines,
-          AsSingleLine,
-          Inspection,
-          Nesting,
-          OnlyWhen,
-          Text,
-          WhenRenderingToLines,
-          WhenRenderingToString
-        ]
-      end
-    end
-  end
-end

data/lib/super_diff/object_inspection/prefix_for_next_node.rb

@@ -1,6 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    class PrefixForNextNode < String
-    end
-  end
-end

data/lib/super_diff/object_inspection/prelude_for_next_node.rb

@@ -1,6 +0,0 @@
-module SuperDiff
-  module ObjectInspection
-    class PreludeForNextNode < String
-    end
-  end
-end

data/lib/super_diff/operation_tree_builders/array.rb

@@ -1,107 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class Array < Base
-      def self.applies_to?(expected, actual)
-        expected.is_a?(::Array) && actual.is_a?(::Array)
-      end
-
-      def call
-        Diff::LCS.traverse_balanced(expected, actual, lcs_callbacks)
-        operation_tree
-      end
-
-      private
-
-      def lcs_callbacks
-        @_lcs_callbacks ||=
-          LcsCallbacks.new(
-            operation_tree: operation_tree,
-            expected: expected,
-            actual: actual,
-            compare: method(:compare)
-          )
-      end
-
-      def operation_tree
-        @_operation_tree ||= OperationTrees::Array.new([])
-      end
-
-      class LcsCallbacks
-        extend AttrExtras.mixin
-
-        pattr_initialize %i[operation_tree! expected! actual! compare!]
-        public :operation_tree
-
-        def match(event)
-          add_noop_operation(event)
-        end
-
-        def discard_a(event)
-          add_delete_operation(event)
-        end
-
-        def discard_b(event)
-          add_insert_operation(event)
-        end
-
-        def change(event)
-          children = compare.(event.old_element, event.new_element)
-
-          if children
-            add_change_operation(event, children)
-          else
-            add_delete_operation(event)
-            add_insert_operation(event)
-          end
-        end
-
-        private
-
-        def add_delete_operation(event)
-          operation_tree << Operations::UnaryOperation.new(
-            name: :delete,
-            collection: expected,
-            key: event.old_position,
-            value: event.old_element,
-            index: event.old_position
-          )
-        end
-
-        def add_insert_operation(event)
-          operation_tree << Operations::UnaryOperation.new(
-            name: :insert,
-            collection: actual,
-            key: event.new_position,
-            value: event.new_element,
-            index: event.new_position
-          )
-        end
-
-        def add_noop_operation(event)
-          operation_tree << Operations::UnaryOperation.new(
-            name: :noop,
-            collection: actual,
-            key: event.new_position,
-            value: event.new_element,
-            index: event.new_position
-          )
-        end
-
-        def add_change_operation(event, children)
-          operation_tree << Operations::BinaryOperation.new(
-            name: :change,
-            left_collection: expected,
-            right_collection: actual,
-            left_key: event.old_position,
-            right_key: event.new_position,
-            left_value: event.old_element,
-            right_value: event.new_element,
-            left_index: event.old_position,
-            right_index: event.new_position,
-            children: children
-          )
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/operation_tree_builders/custom_object.rb

@@ -1,40 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class CustomObject < DefaultObject
-      def self.applies_to?(expected, actual)
-        expected.class == actual.class &&
-          expected.respond_to?(:attributes_for_super_diff) &&
-          actual.respond_to?(:attributes_for_super_diff)
-      end
-
-      protected
-
-      def build_operation_tree
-        # NOTE: It doesn't matter whether we use expected or actual here,
-        # because all we care about is the name of the class
-        OperationTrees::CustomObject.new([], underlying_object: actual)
-      end
-
-      def attribute_names
-        expected.attributes_for_super_diff.keys &
-          actual.attributes_for_super_diff.keys
-      end
-
-      private
-
-      attr_reader :expected_attributes, :actual_attributes
-
-      def establish_expected_and_actual_attributes
-        @expected_attributes =
-          attribute_names.reduce({}) do |hash, name|
-            hash.merge(name => expected.public_send(name))
-          end
-
-        @actual_attributes =
-          attribute_names.reduce({}) do |hash, name|
-            hash.merge(name => actual.public_send(name))
-          end
-      end
-    end
-  end
-end

data/lib/super_diff/operation_tree_builders/date_like.rb

@@ -1,15 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class DateLike < CustomObject
-      def self.applies_to?(expected, actual)
-        SuperDiff.date_like?(expected) && SuperDiff.date_like?(actual)
-      end
-
-      protected
-
-      def attribute_names
-        %w[year month day]
-      end
-    end
-  end
-end

data/lib/super_diff/operation_tree_builders/default_object.rb

@@ -1,119 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class DefaultObject < Base
-      def self.applies_to?(_expected, _actual)
-        true
-      end
-
-      def initialize(*args)
-        super(*args)
-
-        establish_expected_and_actual_attributes
-      end
-
-      protected
-
-      def unary_operations
-        attribute_names.reduce([]) do |operations, name|
-          possibly_add_noop_operation_to(operations, name)
-          possibly_add_delete_operation_to(operations, name)
-          possibly_add_insert_operation_to(operations, name)
-          operations
-        end
-      end
-
-      def build_operation_tree
-        # XXX This assumes that `expected` and `actual` are the same
-        # TODO: Does this need to be find_operation_tree_for?
-        OperationTrees::DefaultObject.new([], underlying_object: actual)
-      end
-
-      def find_operation_tree_for(value)
-        OperationTrees::Main.call(value)
-      end
-
-      def attribute_names
-        (
-          expected.instance_variables.sort & actual.instance_variables.sort
-        ).map { |variable_name| variable_name[1..-1] }
-      end
-
-      private
-
-      attr_reader :expected_attributes, :actual_attributes
-
-      def establish_expected_and_actual_attributes
-        @expected_attributes =
-          attribute_names.reduce({}) do |hash, name|
-            hash.merge(name => expected.instance_variable_get("@#{name}"))
-          end
-
-        @actual_attributes =
-          attribute_names.reduce({}) do |hash, name|
-            hash.merge(name => actual.instance_variable_get("@#{name}"))
-          end
-      end
-
-      def possibly_add_noop_operation_to(operations, attribute_name)
-        if should_add_noop_operation?(attribute_name)
-          operations << Operations::UnaryOperation.new(
-            name: :noop,
-            collection: actual_attributes,
-            key: attribute_name,
-            index: attribute_names.index(attribute_name),
-            value: actual_attributes[attribute_name]
-          )
-        end
-      end
-
-      def should_add_noop_operation?(attribute_name)
-        expected_attributes.include?(attribute_name) &&
-          actual_attributes.include?(attribute_name) &&
-          expected_attributes[attribute_name] ==
-            actual_attributes[attribute_name]
-      end
-
-      def possibly_add_delete_operation_to(operations, attribute_name)
-        if should_add_delete_operation?(attribute_name)
-          operations << Operations::UnaryOperation.new(
-            name: :delete,
-            collection: expected_attributes,
-            key: attribute_name,
-            index: attribute_names.index(attribute_name),
-            value: expected_attributes[attribute_name]
-          )
-        end
-      end
-
-      def should_add_delete_operation?(attribute_name)
-        expected_attributes.include?(attribute_name) &&
-          (
-            !actual_attributes.include?(attribute_name) ||
-              expected_attributes[attribute_name] !=
-                actual_attributes[attribute_name]
-          )
-      end
-
-      def possibly_add_insert_operation_to(operations, attribute_name)
-        if should_add_insert_operation?(attribute_name)
-          operations << Operations::UnaryOperation.new(
-            name: :insert,
-            collection: actual_attributes,
-            key: attribute_name,
-            index: attribute_names.index(attribute_name),
-            value: actual_attributes[attribute_name]
-          )
-        end
-      end
-
-      def should_add_insert_operation?(attribute_name)
-        !expected_attributes.include?(attribute_name) ||
-          (
-            actual_attributes.include?(attribute_name) &&
-              expected_attributes[attribute_name] !=
-                actual_attributes[attribute_name]
-          )
-      end
-    end
-  end
-end

data/lib/super_diff/operation_tree_builders/defaults.rb

@@ -1,5 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    DEFAULTS = [Array, Hash, TimeLike, DateLike, CustomObject].freeze
-  end
-end