super_diff 0.1.0 → 0.2.0

data/lib/super_diff/object_inspection/inspectors/hash.rb

@@ -0,0 +1,22 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      Hash = InspectionTree.new do
+        when_empty do
+          add_text "{}"
+        end
+
+        when_non_empty do
+          add_text "{"
+
+          nested do |hash|
+            insert_hash_inspection_of(hash)
+          end
+
+          add_break " "
+          add_text "}"
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/inspectors/primitive.rb

@@ -0,0 +1,13 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      Primitive = InspectionTree.new do
+        # rubocop:disable Style/SymbolProc
+        add_text do |object|
+          object.inspect
+        end
+        # rubocop:enable Style/SymbolProc
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/inspectors/string.rb

@@ -0,0 +1,13 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      String = InspectionTree.new do
+        # rubocop:disable Style/SymbolProc
+        add_text do |string|
+          string.inspect
+        end
+        # rubocop:enable Style/SymbolProc
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/map.rb

@@ -0,0 +1,28 @@
+module SuperDiff
+  module ObjectInspection
+    class Map
+      def prepend(mod)
+        singleton_class.prepend(mod)
+      end
+
+      def call(object)
+        if object.respond_to?(:attributes_for_super_diff)
+          Inspectors::CustomObject
+        else
+          case object
+          when Array
+            Inspectors::Array
+          when Hash
+            Inspectors::Hash
+          when String
+            Inspectors::String
+          when true, false, nil, Symbol, Numeric, Regexp, Class
+            Inspectors::Primitive
+          else
+            Inspectors::DefaultObject
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes.rb

@@ -0,0 +1,49 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      autoload :Base, "super_diff/object_inspection/nodes/base"
+      autoload :Break, "super_diff/object_inspection/nodes/break"
+      autoload :Inspection, "super_diff/object_inspection/nodes/inspection"
+      autoload :Nesting, "super_diff/object_inspection/nodes/nesting"
+      autoload :Text, "super_diff/object_inspection/nodes/text"
+      autoload(
+        :WhenEmpty,
+        "super_diff/object_inspection/nodes/when_empty",
+      )
+      autoload(
+        :WhenMultiline,
+        "super_diff/object_inspection/nodes/when_multiline",
+      )
+      autoload(
+        :WhenNonEmpty,
+        "super_diff/object_inspection/nodes/when_non_empty",
+      )
+      autoload(
+        :WhenSingleline,
+        "super_diff/object_inspection/nodes/when_singleline",
+      )
+
+      def self.fetch(type)
+        registry.fetch(type) do
+          raise(
+            KeyError,
+            "#{type.inspect} is not included in ObjectInspection::Nodes.registry!",
+          )
+        end
+      end
+
+      def self.registry
+        @_registry ||= {
+          break: Break,
+          inspection: Inspection,
+          nesting: Nesting,
+          text: Text,
+          when_empty: WhenEmpty,
+          when_multiline: WhenMultiline,
+          when_non_empty: WhenNonEmpty,
+          when_singleline: WhenSingleline,
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class Base
+        def initialize(tree, *args, &block)
+          if !args.empty? && block
+            raise ArgumentError.new(
+              "You cannot provide both an immediate value and a lazy value. " +
+              "Either pass a block or a positional argument.",
+            )
+          end
+
+          @tree = tree
+          @immediate_value = args.first
+          @block = block
+        end
+
+        def clone_with(
+          tree: @tree,
+          immediate_value: @immediate_value,
+          block: @block
+        )
+          if block
+            self.class.new(tree, &block)
+          else
+            self.class.new(tree, immediate_value)
+          end
+        end
+
+        def type
+          self.class.name.
+            sub(/^(.+)::(.+?)$/, '\2').
+            gsub(/([a-z])([A-Z])/, '\1_\2').
+            downcase.
+            to_sym
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def evaluate(object, indent_level:, as_single_line:)
+        # rubocop:enable Lint/UnusedMethodArgument
+          raise NotImplementedError.new(
+            "Your node must provide an #evaluate method. " +
+            "(Keep in mind #evaluate may be called more than once for a node!)",
+          )
+        end
+
+        def pretty_print(pp)
+          pp.object_address_group(self) do
+            pp.seplist(pretty_print_variables, proc { pp.text "," }) do |name|
+              value = instance_variable_get(name)
+              pp.breakable " "
+              pp.group(1) do
+                pp.text name[1..-1].to_s
+                pp.text ":"
+                pp.breakable
+                pp.pp value
+              end
+            end
+          end
+        end
+
+        private
+
+        attr_reader :tree, :immediate_value, :block
+
+        def pretty_print_variables
+          if block
+            [:"@block"]
+          else
+            [:"@immediate_value"]
+          end
+        end
+
+        def evaluate_in_subtree(object, indent_level:, as_single_line:)
+          subtree = InspectionTree.new
+          subtree.evaluate_block(object, &block)
+          subtree.evaluate(
+            object,
+            indent_level: indent_level,
+            as_single_line: as_single_line,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/break.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class Break < Base
+        def evaluate(_object, indent_level:, as_single_line:)
+          if as_single_line
+            immediate_value.to_s
+          else
+            "\n#{"  " * indent_level}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/inspection.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class Inspection < Base
+        def evaluate(_object, indent_level:, as_single_line:)
+          SuperDiff::ObjectInspection.inspect(
+            immediate_value,
+            indent_level: indent_level,
+            as_single_line: as_single_line,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/nesting.rb

@@ -0,0 +1,16 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class Nesting < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          evaluate_in_subtree(
+            object,
+            indent_level: indent_level + 1,
+            as_single_line: as_single_line,
+            &block
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/text.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class Text < Base
+        def evaluate(object, **)
+          if block
+            tree.evaluate_block(object, &block).to_s
+          else
+            immediate_value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/when_empty.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenEmpty < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          if empty?(object)
+            evaluate_in_subtree(
+              object,
+              indent_level: indent_level,
+              as_single_line: as_single_line,
+              &block
+            )
+          else
+            ""
+          end
+        end
+
+        private
+
+        def empty?(object)
+          if object.respond_to?(:empty?)
+            object.empty?
+          else
+            object.instance_variables.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/when_multiline.rb

@@ -0,0 +1,22 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenMultiline < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          if as_single_line
+            ""
+          elsif block
+            evaluate_in_subtree(
+              object,
+              indent_level: indent_level,
+              as_single_line: as_single_line,
+              &block
+            )
+          else
+            immediate_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/when_non_empty.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenNonEmpty < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          if empty?(object)
+            ""
+          else
+            evaluate_in_subtree(
+              object,
+              indent_level: indent_level,
+              as_single_line: as_single_line,
+              &block
+            )
+          end
+        end
+
+        private
+
+        def empty?(object)
+          if object.respond_to?(:empty?)
+            object.empty?
+          else
+            object.instance_variables.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/when_singleline.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenSingleline < Base
+        def evaluate(object, indent_level:, as_single_line:)
+          if as_single_line
+            if immediate_value
+              immediate_value
+            else
+              evaluate_in_subtree(
+                object,
+                indent_level: indent_level,
+                as_single_line: as_single_line,
+                &block
+              )
+            end
+          else
+            ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/operation_sequences.rb

@@ -0,0 +1,9 @@
+module SuperDiff
+  module OperationSequences
+    autoload :Array, "super_diff/operation_sequences/array"
+    autoload :Base, "super_diff/operation_sequences/base"
+    autoload :CustomObject, "super_diff/operation_sequences/custom_object"
+    autoload :DefaultObject, "super_diff/operation_sequences/default_object"
+    autoload :Hash, "super_diff/operation_sequences/hash"
+  end
+end

data/lib/super_diff/operation_sequences/base.rb

@@ -2,7 +2,7 @@ module SuperDiff
   module OperationSequences
     class Base < SimpleDelegator
       # rubocop:disable Lint/UnusedMethodArgument
-      def to_diff(indent_level:, add_comma:, collection_prefix: nil)
+      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
         raise NotImplementedError
       end
       # rubocop:enable Lint/UnusedMethodArgument

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

@@ -1,12 +1,13 @@
 module SuperDiff
   module OperationSequences
-    class Object < Base
-      def to_diff(indent_level:, collection_prefix:, add_comma:)
-        DiffFormatters::Object.call(
+    class CustomObject < DefaultObject
+      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
+        DiffFormatters::CustomObject.call(
           self,
           indent_level: indent_level,
           collection_prefix: collection_prefix,
           add_comma: add_comma,
+          value_class: value_class,
         )
       end
     end

data/lib/super_diff/operation_sequences/default_object.rb

@@ -0,0 +1,25 @@
+module SuperDiff
+  module OperationSequences
+    class DefaultObject < Base
+      def initialize(collection, value_class:)
+        super(collection)
+
+        @value_class = value_class
+      end
+
+      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
+        DiffFormatters::DefaultObject.call(
+          self,
+          indent_level: indent_level,
+          collection_prefix: collection_prefix,
+          add_comma: add_comma,
+          value_class: value_class,
+        )
+      end
+
+      private
+
+      attr_reader :value_class
+    end
+  end
+end