super_diff 0.1.0 → 0.2.0

data/lib/super_diff/active_record/differs.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module ActiveRecord
+    module Differs
+      autoload(
+        :ActiveRecordRelation,
+        "super_diff/active_record/differs/active_record_relation",
+      )
+    end
+  end
+end

data/lib/super_diff/active_record/differs/active_record_relation.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module ActiveRecord
+    module Differs
+      class ActiveRecordRelation < SuperDiff::Differs::Base
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::Array) &&
+            actual.is_a?(::ActiveRecord::Relation)
+        end
+
+        def call
+          DiffFormatters::ActiveRecordRelation.call(
+            operations,
+            indent_level: indent_level,
+          )
+        end
+
+        private
+
+        def operations
+          OperationalSequencers::ActiveRecordRelation.call(
+            expected: expected,
+            actual: actual,
+            extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+            extra_diff_formatter_classes: extra_diff_formatter_classes,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/object_inspection.rb

@@ -0,0 +1,14 @@
+module SuperDiff
+  module ActiveRecord
+    module ObjectInspection
+      autoload(
+        :Inspectors,
+        "super_diff/active_record/object_inspection/inspectors",
+      )
+      autoload(
+        :MapExtension,
+        "super_diff/active_record/object_inspection/map_extension",
+      )
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module SuperDiff
+  module ActiveRecord
+    module ObjectInspection
+      module Inspectors
+        autoload(
+          :ActiveRecordModel,
+          "super_diff/active_record/object_inspection/inspectors/active_record_model",
+        )
+        autoload(
+          :ActiveRecordRelation,
+          "super_diff/active_record/object_inspection/inspectors/active_record_relation",
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/object_inspection/inspectors/active_record_model.rb

@@ -0,0 +1,38 @@
+module SuperDiff
+  module ActiveRecord
+    module ObjectInspection
+      module Inspectors
+        ActiveRecordModel = SuperDiff::ObjectInspection::InspectionTree.new do
+          add_text do |object|
+            "#<#{object.class} "
+          end
+
+          when_multiline do
+            add_text "{"
+          end
+
+          nested do |object|
+            add_break
+
+            insert_separated_list(
+              ["id"] + (object.attributes.keys.sort - ["id"]),
+              separator: ",",
+            ) do |name|
+              add_text name
+              add_text ": "
+              add_inspection_of object.read_attribute(name)
+            end
+          end
+
+          add_break
+
+          when_multiline do
+            add_text "}"
+          end
+
+          add_text ">"
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/object_inspection/inspectors/active_record_relation.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module ActiveRecord
+    module ObjectInspection
+      module Inspectors
+        ActiveRecordRelation = SuperDiff::ObjectInspection::InspectionTree.new do
+          add_text "#<ActiveRecord::Relation ["
+
+          nested do |array|
+            insert_array_inspection_of(array)
+          end
+
+          add_break
+          add_text "]>"
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/object_inspection/map_extension.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module ActiveRecord
+    module ObjectInspection
+      module MapExtension
+        def call(object)
+          case object
+          when ::ActiveRecord::Base
+            Inspectors::ActiveRecordModel
+          when ::ActiveRecord::Relation
+            Inspectors::ActiveRecordRelation
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/operation_sequences.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module ActiveRecord
+    module OperationSequences
+      autoload(
+        :ActiveRecordRelation,
+        "super_diff/active_record/operation_sequences/active_record_relation",
+      )
+    end
+  end
+end

data/lib/super_diff/active_record/operation_sequences/active_record_relation.rb

@@ -0,0 +1,16 @@
+module SuperDiff
+  module ActiveRecord
+    module OperationSequences
+      class ActiveRecordRelation < SuperDiff::OperationSequences::Array
+        def to_diff(indent_level:, collection_prefix:, add_comma:)
+          DiffFormatters::ActiveRecordRelation.call(
+            self,
+            indent_level: indent_level,
+            collection_prefix: collection_prefix,
+            add_comma: add_comma,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/operational_sequencers.rb

@@ -0,0 +1,14 @@
+module SuperDiff
+  module ActiveRecord
+    module OperationalSequencers
+      autoload(
+        :ActiveRecordModel,
+        "super_diff/active_record/operational_sequencers/active_record_model",
+      )
+      autoload(
+        :ActiveRecordRelation,
+        "super_diff/active_record/operational_sequencers/active_record_relation",
+      )
+    end
+  end
+end

data/lib/super_diff/active_record/operational_sequencers/active_record_model.rb

@@ -0,0 +1,19 @@
+module SuperDiff
+  module ActiveRecord
+    module OperationalSequencers
+      class ActiveRecordModel < SuperDiff::OperationalSequencers::CustomObject
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::ActiveRecord::Base) &&
+            actual.is_a?(::ActiveRecord::Base) &&
+            expected.class == actual.class
+        end
+
+        protected
+
+        def attribute_names
+          ["id"] + (expected.attributes.keys.sort - ["id"])
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_record/operational_sequencers/active_record_relation.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module ActiveRecord
+    module OperationalSequencers
+      class ActiveRecordRelation < SuperDiff::OperationalSequencers::Array
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::Array) &&
+            actual.is_a?(::ActiveRecord::Relation)
+        end
+
+        def initialize(actual:, **rest)
+          super
+
+          @actual = actual.to_a
+        end
+
+        private
+
+        def operations
+          @_operations ||= OperationSequences::ActiveRecordRelation.new([])
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_support.rb

@@ -0,0 +1,33 @@
+module SuperDiff
+  module ActiveSupport
+    autoload :DiffFormatters, "super_diff/active_support/diff_formatters"
+    autoload :Differs, "super_diff/active_support/differs"
+    autoload :ObjectInspection, "super_diff/active_support/object_inspection"
+    autoload(
+      :OperationalSequencers,
+      "super_diff/active_support/operational_sequencers",
+    )
+    autoload(
+      :OperationalSequences,
+      "super_diff/active_support/operational_sequences",
+    )
+  end
+end
+
+if defined?(SuperDiff::RSpec)
+  SuperDiff::RSpec.configure do |config|
+    config.add_extra_differ_class(
+      SuperDiff::ActiveSupport::Differs::HashWithIndifferentAccess,
+    )
+    config.add_extra_operational_sequencer_class(
+      SuperDiff::ActiveSupport::OperationalSequencers::HashWithIndifferentAccess,
+    )
+    config.add_extra_diff_formatter_class(
+      SuperDiff::ActiveSupport::DiffFormatters::HashWithIndifferentAccess,
+    )
+  end
+end
+
+SuperDiff::ObjectInspection.map.prepend(
+  SuperDiff::ActiveSupport::ObjectInspection::MapExtension,
+)

data/lib/super_diff/active_support/diff_formatters.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module ActiveSupport
+    module DiffFormatters
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/active_support/diff_formatters/hash_with_indifferent_access",
+      )
+    end
+  end
+end

data/lib/super_diff/active_support/diff_formatters/hash_with_indifferent_access.rb

@@ -0,0 +1,36 @@
+module SuperDiff
+  module ActiveSupport
+    module DiffFormatters
+      class HashWithIndifferentAccess < SuperDiff::DiffFormatters::Base
+        def self.applies_to?(operations)
+          operations.is_a?(OperationSequences::HashWithIndifferentAccess)
+        end
+
+        def call
+          SuperDiff::DiffFormatters::Collection.call(
+            open_token: "#<HashWithIndifferentAccess {",
+            close_token: "}>",
+            collection_prefix: collection_prefix,
+            build_item_prefix: -> (operation) {
+              key =
+                if operation.respond_to?(:left_key)
+                  operation.left_key
+                else
+                  operation.key
+                end
+
+              if key.is_a?(Symbol)
+                "#{key}: "
+              else
+                "#{key.inspect} => "
+              end
+            },
+            operations: operations,
+            indent_level: indent_level,
+            add_comma: add_comma?,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_support/differs.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module ActiveSupport
+    module Differs
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/active_support/differs/hash_with_indifferent_access",
+      )
+    end
+  end
+end

data/lib/super_diff/active_support/differs/hash_with_indifferent_access.rb

@@ -0,0 +1,36 @@
+module SuperDiff
+  module ActiveSupport
+    module Differs
+      class HashWithIndifferentAccess < SuperDiff::Differs::Hash
+        def self.applies_to?(expected, actual)
+          (
+            expected.is_a?(::HashWithIndifferentAccess) &&
+              actual.is_a?(::Hash)
+          ) ||
+          (
+            expected.is_a?(::Hash) &&
+              actual.is_a?(::HashWithIndifferentAccess)
+          )
+        end
+
+        def call
+          DiffFormatters::HashWithIndifferentAccess.call(
+            operations,
+            indent_level: indent_level,
+          )
+        end
+
+        private
+
+        def operations
+          OperationalSequencers::HashWithIndifferentAccess.call(
+            expected: expected,
+            actual: actual,
+            extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+            extra_diff_formatter_classes: extra_diff_formatter_classes,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_support/object_inspection.rb

@@ -0,0 +1,14 @@
+module SuperDiff
+  module ActiveSupport
+    module ObjectInspection
+      autoload(
+        :Inspectors,
+        "super_diff/active_support/object_inspection/inspectors",
+      )
+      autoload(
+        :MapExtension,
+        "super_diff/active_support/object_inspection/map_extension",
+      )
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module SuperDiff
+  module ActiveSupport
+    module ObjectInspection
+      module Inspectors
+        autoload(
+          :HashWithIndifferentAccess,
+          "super_diff/active_support/object_inspection/inspectors/hash_with_indifferent_access",
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/active_support/object_inspection/inspectors/hash_with_indifferent_access.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module ActiveSupport
+    module ObjectInspection
+      module Inspectors
+        HashWithIndifferentAccess = SuperDiff::ObjectInspection::InspectionTree.new do
+          add_text "#<HashWithIndifferentAccess {"
+
+          nested do |hash|
+            insert_hash_inspection_of(hash)
+          end
+
+          add_break " "
+          add_text "}>"
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/active_support/object_inspection/map_extension.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module ActiveSupport
+    module ObjectInspection
+      module MapExtension
+        def call(object)
+          if object.is_a?(::HashWithIndifferentAccess)
+            Inspectors::HashWithIndifferentAccess
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end