super_diff 0.1.0 → 0.2.0

data/lib/super_diff/equality_matchers/{single_line_string.rb → singleline_string.rb}

@@ -1,6 +1,6 @@
 module SuperDiff
   module EqualityMatchers
-    class SingleLineString < Base
+    class SinglelineString < Base
       def self.applies_to?(value)
         value.class == ::String
       end
@@ -11,14 +11,16 @@ module SuperDiff
 
           #{
             Helpers.style(
-              :deleted,
-              "Expected: #{Helpers.inspect_object(expected)}",
+              :alpha,
+              "Expected: " +
+              ObjectInspection.inspect(expected, as_single_line: true),
             )
           }
           #{
             Helpers.style(
-              :inserted,
-              "  Actual: #{Helpers.inspect_object(actual)}",
+              :beta,
+              "  Actual: " +
+              ObjectInspection.inspect(actual, as_single_line: true),
             )
           }
         OUTPUT

data/lib/super_diff/helpers.rb

@@ -1,9 +1,23 @@
 module SuperDiff
   module Helpers
-    COLORS = { normal: :plain, inserted: :green, deleted: :red }.freeze
+    # TODO: Simplify this
+    def self.style(*args, color_enabled: true, **opts, &block)
+      klass =
+        if color_enabled && Csi.color_enabled?
+          Csi::ColorizedDocument
+        else
+          Csi::UncolorizedDocument
+        end
+
+      document = klass.new.extend(ColorizedDocumentExtensions)
+
+      if block
+        document.__send__(:evaluate_block, &block)
+      else
+        document.colorize(*args, **opts)
+      end
 
-    def self.style(style_name, text)
-      Csi::ColorHelper.public_send(COLORS.fetch(style_name), text)
+      document
     end
 
     def self.plural_type_for(value)
@@ -14,83 +28,5 @@ module SuperDiff
       else "objects"
       end
     end
-
-    def self.inspect_object(value_to_inspect, single_line: true)
-      case value_to_inspect
-      when ::Hash
-        inspect_hash(value_to_inspect, single_line: single_line)
-      when String
-        inspect_string(value_to_inspect)
-      when ::Array
-        inspect_array(value_to_inspect)
-      else
-        inspect_unclassified_object(value_to_inspect, single_line: single_line)
-      end
-    end
-
-    def self.inspect_hash(hash, single_line: true)
-      contents = hash.map do |key, value|
-        if key.is_a?(Symbol)
-          "#{key}: #{inspect_object(value)}"
-        else
-          "#{inspect_object(key)} => #{inspect_object(value)}"
-        end
-      end
-
-      if single_line
-        ["{", contents.join(", "), "}"].join(" ")
-      else
-        ValueInspection.new(
-          beginning: "{",
-          middle: contents.map.with_index do |line, index|
-            if index < contents.size - 1
-              line + ","
-            else
-              line
-            end
-          end,
-          end: "}",
-        )
-      end
-    end
-    private_class_method :inspect_hash
-
-    def self.inspect_string(string)
-      newline = "⏎"
-      string.gsub(/\r\n/, newline).gsub(/\n/, newline).inspect
-    end
-    private_class_method :inspect_string
-
-    def self.inspect_array(array)
-      "[" + array.map { |element| inspect_object(element) }.join(", ") + "]"
-    end
-    private_class_method :inspect_array
-
-    def self.inspect_unclassified_object(object, single_line: true)
-      if object.respond_to?(:attributes_for_super_diff)
-        attributes = object.attributes_for_super_diff
-        inspected_attributes =
-          attributes.map.with_index do |(key, value), index|
-            "#{key}: #{value.inspect}".tap do |line|
-              if index < attributes.size - 1
-                line << ","
-              end
-            end
-          end
-
-        if single_line
-          "#<#{object.class} #{inspected_attributes.join(" ")}>"
-        else
-          ValueInspection.new(
-            beginning: "#<#{object.class} {",
-            middle: inspected_attributes,
-            end: "}>",
-          )
-        end
-      else
-        object.inspect
-      end
-    end
-    private_class_method :inspect_unclassified_object
   end
 end

data/lib/super_diff/no_differ_available_error.rb

@@ -0,0 +1,22 @@
+module SuperDiff
+  class NoDifferAvailableError < StandardError
+    def self.create(expected, actual)
+      allocate.tap do |error|
+        error.expected = expected
+        error.actual = actual
+        error.__send__(:initialize)
+      end
+    end
+
+    attr_accessor :expected, :actual
+
+    def initialize
+      super(<<-MESSAGE)
+There is no differ available to handle an "expected" value of type
+#{expected.class}
+and an "actual" value of type
+#{actual.class}.
+      MESSAGE
+    end
+  end
+end

data/lib/super_diff/object_inspection.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module ObjectInspection
+    autoload :InspectionTree, "super_diff/object_inspection/inspection_tree"
+    autoload :Inspector, "super_diff/object_inspection/inspector"
+    autoload :Inspectors, "super_diff/object_inspection/inspectors"
+    autoload :Map, "super_diff/object_inspection/map"
+    autoload :Nodes, "super_diff/object_inspection/nodes"
+
+    class << self
+      attr_accessor :map
+    end
+
+    def self.inspect(object, as_single_line:, indent_level: 0)
+      Inspector.call(
+        map,
+        object,
+        as_single_line: as_single_line,
+        indent_level: indent_level,
+      )
+    end
+
+    self.map = Map.new
+  end
+end

data/lib/super_diff/object_inspection/inspection_tree.rb

@@ -0,0 +1,144 @@
+module SuperDiff
+  module ObjectInspection
+    class InspectionTree
+      include Enumerable
+
+      def initialize(&block)
+        @nodes = []
+
+        if block
+          instance_eval(&block)
+        end
+      end
+
+      def each(&block)
+        nodes.each(&block)
+      end
+
+      def before_each_callbacks
+        @_before_each_callbacks ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def evaluate(object, as_single_line:, indent_level:)
+        nodes.reduce("") do |str, node|
+          str << node.evaluate(
+            object,
+            as_single_line: as_single_line,
+            indent_level: indent_level,
+          )
+        end
+      end
+
+      def evaluate_block(object, &block)
+        instance_exec(object, &block)
+      end
+
+      def add_text(*args, &block)
+        add_node :text, *args, &block
+      end
+
+      def when_multiline(&block)
+        add_node :when_multiline, &block
+      end
+
+      def when_singleline(&block)
+        add_node :when_singleline, &block
+      end
+
+      def add_break(*args, &block)
+        add_node :break, *args, &block
+      end
+
+      def nested(&block)
+        add_node :nesting, &block
+      end
+
+      def when_empty(&block)
+        add_node :when_empty, &block
+      end
+
+      def when_non_empty(&block)
+        add_node :when_non_empty, &block
+      end
+
+      def insert_array_inspection_of(array)
+        # FIXME: why must this be inside the `nested`?
+        add_break
+
+        insert_separated_list(array) do |value|
+          add_inspection_of value
+        end
+      end
+
+      def insert_hash_inspection_of(hash, initial_break: " ")
+        # FIXME: why must this be inside the `nested`?
+        add_break initial_break
+
+        format_keys_as_kwargs = hash.keys.all? do |key|
+          key.is_a?(Symbol)
+        end
+
+        insert_separated_list(hash) do |(key, value)|
+          if format_keys_as_kwargs
+            add_text key
+            add_text ": "
+          else
+            add_inspection_of key
+            add_text " => "
+          end
+
+          add_inspection_of value
+        end
+      end
+
+      def insert_separated_list(enumerable, separator: ",")
+        enumerable.each_with_index do |value, index|
+          if index > 0
+            if separator.is_a?(Nodes::Base)
+              append_node separator
+            else
+              add_text separator
+            end
+
+            add_break " "
+          end
+
+          yield value
+        end
+      end
+
+      def add_inspection_of(value)
+        add_node :inspection, value
+      end
+
+      def apply_tree(tree)
+        tree.each do |node|
+          append_node(node.clone_with(tree: self))
+        end
+      end
+
+      private
+
+      attr_reader :nodes
+
+      def add_node(type, *args, &block)
+        append_node(build_node(type, *args, &block))
+      end
+
+      def append_node(node)
+        nodes.push(node)
+      end
+
+      def build_node(type, *args, &block)
+        Nodes.fetch(type).new(self, *args, &block)
+      end
+
+      class BlockArgument
+        extend AttrExtras.mixin
+
+        rattr_initialize [:object!, :as_single_line!]
+        attr_query :as_single_line?
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/inspector.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    class Inspector
+      extend AttrExtras.mixin
+
+      method_object :map, :object, [:indent_level!, :as_single_line!]
+
+      def call
+        SuperDiff::RecursionGuard.substituting_recursion_of(object) do
+          inspector.evaluate(
+            object,
+            as_single_line: as_single_line,
+            indent_level: indent_level,
+          )
+        end
+      end
+
+      private
+
+      attr_query :as_single_line?
+
+      def inspector
+        @_inspector ||= map.call(object)
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/inspectors.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      autoload :Array, "super_diff/object_inspection/inspectors/array"
+      autoload(
+        :CustomObject,
+        "super_diff/object_inspection/inspectors/custom_object",
+      )
+      autoload(
+        :DefaultObject,
+        "super_diff/object_inspection/inspectors/default_object",
+      )
+      autoload :Hash, "super_diff/object_inspection/inspectors/hash"
+      autoload :Primitive, "super_diff/object_inspection/inspectors/primitive"
+      autoload :String, "super_diff/object_inspection/inspectors/string"
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      Array = InspectionTree.new do
+        when_empty do
+          add_text "[]"
+        end
+
+        when_non_empty do
+          add_text "["
+
+          nested do |array|
+            insert_array_inspection_of(array)
+          end
+
+          add_break
+          add_text "]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      CustomObject = InspectionTree.new do
+        add_text do |object|
+          "#<#{object.class}"
+        end
+
+        when_multiline do
+          add_text " {"
+        end
+
+        nested do |object|
+          insert_hash_inspection_of(object.attributes_for_super_diff)
+        end
+
+        add_break
+
+        when_multiline do
+          add_text "}"
+        end
+
+        add_text ">"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module SuperDiff
+  module ObjectInspection
+    module Inspectors
+      DefaultObject = InspectionTree.new do
+        when_empty do
+          add_text do |object|
+            object.inspect
+          end
+        end
+
+        when_non_empty do
+          when_singleline do
+            add_text do |object|
+              object.inspect
+            end
+          end
+
+          when_multiline do
+            add_text do |object|
+              "#<%<class>s:0x%<id>x {" % {
+                class: object.class,
+                id: object.object_id * 2,
+              }
+            end
+
+            nested do |object|
+              add_break " "
+
+              insert_separated_list(
+                object.instance_variables.sort,
+                separator: ","
+              ) do |name|
+                add_text name.to_s
+                add_text "="
+                add_inspection_of object.instance_variable_get(name)
+              end
+            end
+
+            add_break
+
+            add_text "}>"
+          end
+        end
+      end
+    end
+  end
+end