Add a way to elide diffs

When looking at a large diff for which many of the lines are unchanged
it can be difficult to locate the lines which are changed. Text-oriented
diffs such as those you get from a conventional version control system
solve this problem by collapsing parts of the diff to show you only the
most important lines (and also including some unimportant lines, aka
context, so that you know where they fit within the bigger picture):

```
diff --git a/README.md b/README.md
index 56b046c..b38f4ca 100644
--- a/README.md
+++ b/README.md
@@ -169,7 +169,6 @@ SuperDiff.configure do |config|
   config.add_extra_differ_class(YourDiffer)
   config.add_extra_operation_tree_builder_class(YourOperationTreeBuilder)
   config.add_extra_operation_tree_class(YourOperationTree)
-  config.add_extra_diff_formatter_class(YourDiffFormatter)
 end
```

This commit implements a similar feature for data-oriented diffs. It
adds three new configuration options to allow you to control the elision
logic:

* `diff_elision_enabled` — The elision logic is disabled by default so
  as not to surprise people, so setting this to `true` will turn it on.
* `diff_elision_threshold` — This controls the maximum number of
  unchanged lines in between changed lines that you want to keep.
  The gem will collapse the data structures in this space as much as
  possible until the limit is reached.
* `diff_elision_padding` — This is the option that's similar to the
  "context" in text-based diffs and controls how many unchanged lines
  you want to keep around before and after changed lines. The gem will
  guarantee that no lines in this padding will ever be collapsed.

Here is a simple example. If you add this to your test helper:

``` ruby
SuperDiff.configure do |config|
  config.diff_elision_enabled = true
  config.diff_elision_threshold = 5
end
```

And you have this test:

``` ruby
expected = [
  "Afghanistan",
  "Aland Islands",
  "Albania",
  "American Samoa",
  "Andorra",
  "Angola",
  "Anguilla",
  "Antarctica",
  "Antigua And Barbuda",
  "Argentina",
  "Aruba",
  "Australia"
]
actual = [
  "Afghanistan",
  "Aland Islands",
  "Algeria",
  "American Samoa",
  "Andorra",
  "Angola",
  "Anguilla",
  "Antarctica",
  "Antigua And Barbuda",
  "Armenia",
  "Aruba",
  "Australia"
]
expect(actual).to eq(expected)
```

Then you will get a diff that looks like:

```
  [
    "Afghanistan",
    "Aland Islands",
-   "Albania",
+   "Algeria",
    "American Samoa",
    "Andorra",
    # ...
    "Antarctica",
    "Antigua And Barbuda",
-   "Argentina",
+   "Armenia",
    "Aruba",
    "Australia"
  ]
```

Now let's consider this example:

``` ruby
expected = {
  foo: {
    bar: [
      "one",
      "two",
      "three"
    ],
    baz: "qux",
    fizz: "buzz",
    zing: "bing"
  }
}
actual = [
  foo: {
    bar: [
      "one",
      "two",
      "tree"
    ],
    baz: "qux",
    fizz: "buzz",
    zing: "bing"
  }
]
expect(actual).to eq(expected)
```

With the following configuration:

``` ruby
SuperDiff.configure do |config|
  config.diff_elision_enabled = true
  config.diff_elision_threshold = 0
end
```

you would get:

```
  {
    foo: {
      bar: [
        # ...
-       "three"
+       "tree"
      ],
      # ...
    }
  }
```

whereas with a configuration of:

``` ruby
SuperDiff.configure do |config|
  config.diff_elision_enabled = true
  config.diff_elision_threshold = 0
  config.diff_elision_padding = 2
end
```

you would get:

```
  {
    foo: {
      bar: [
        "one",
        "two",
-       "three"
+       "tree"
      ],
      baz: "qux",
      # ...
    }
  }
```

Author: mcmire

CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## Unreleased
+
+### Breaking changes
+
+* Continuing with the previous release, diff formatters are now gone in favor of
+  operation tree flatteners. If you have a custom diff formatter, you will want
+  to inherit from SuperDiff::DiffFormatters::Base (or an appropriate subclass).
+  Additionally, the `add_extra_diff_formatter_class` configuration option has
+  disappeared; instead, operation tree classes are expected to have an
+  `operation_tree_flattener_class` method.
+
+### Features
+
+* Add the ability to compress long diffs by eliding unimportant sections. This
+  functionality is not enabled by default; rather, you will need to activate it
+  and then configure it. At a minimum, you will want to add something like this
+  to your spec helper:
+
+  ``` ruby
+  SuperDiff.configure do |config|
+    config.diff_elision_enabled = true
+    config.diff_elision_threshold = 10
+  end
+  ```
+
+  Here, `diff_elision_threshold` controls the minimum number of lines that are
+  changed that you want to see in between lines that are unchanged (everything
+  else will be elided as much as possible in a way that makes sense). Here is
+  another possible configuration:
+
+  ``` ruby
+  SuperDiff.configure do |config|
+    config.diff_elision_enabled = true
+    config.diff_elision_threshold = 10
+    config.diff_elision_padding = 5
+  end
+  ```
+
+  Here, `diff_elision_padding` controls the amount of context that you want to
+  preserve around changed lines in the diff. This makes this functionality act
+  closer to diffs you might see in a version control system.
+
+### Features
+
+* Update inspection of Doubles to include stubbed methods and their values.
+
+### Improvements
+
+* Change how objects are inspected on a single line so that instance variables
+  are always sorted.
+* Make a tweak to how hashes are presented in diffs and inspections: a hash that
+  has a mixture of symbols and strings will be presented as though all keys are
+  strings (i.e. hashrocket syntax).
+
 ## 0.5.1 - 2020-06-19
 
 ### Bug fixes

README.md

@@ -169,7 +169,6 @@ SuperDiff.configure do |config|
   config.add_extra_differ_class(YourDiffer)
   config.add_extra_operation_tree_builder_class(YourOperationTreeBuilder)
   config.add_extra_operation_tree_class(YourOperationTree)
-  config.add_extra_diff_formatter_class(YourDiffFormatter)
 end
 ```
 

config/zeus_plan.rb

@@ -18,10 +18,15 @@ class CustomZeusPlan < Zeus::Plan
     :confirm_started,
   )
 
-  def initialize(using_outside_of_zeus: false, color_enabled: false)
+  def initialize(
+    using_outside_of_zeus: false,
+    color_enabled: false,
+    configuration: {}
+  )
     @test_plan = TestPlan.new(
       using_outside_of_zeus: using_outside_of_zeus,
       color_enabled: color_enabled,
+      configuration: configuration,
     )
   end
 end

lib/super_diff.rb

@@ -7,6 +7,7 @@ module SuperDiff
     :ColorizedDocumentExtensions,
     "super_diff/colorized_document_extensions",
   )
+  autoload :OperationTreeFlatteners, "super_diff/operation_tree_flatteners"
   autoload :Configuration, "super_diff/configuration"
   autoload :Csi, "super_diff/csi"
   autoload :DiffFormatters, "super_diff/diff_formatters"
@@ -15,6 +16,10 @@ module SuperDiff
   autoload :Errors, "super_diff/errors"
   autoload :Helpers, "super_diff/helpers"
   autoload :ImplementationChecks, "super_diff/implementation_checks"
+  autoload :Line, "super_diff/line"
+  autoload :TieredLines, "super_diff/tiered_lines"
+  autoload :TieredLinesElider, "super_diff/tiered_lines_elider"
+  autoload :TieredLinesFormatter, "super_diff/tiered_lines_formatter"
   autoload :ObjectInspection, "super_diff/object_inspection"
   autoload :OperationTrees, "super_diff/operation_trees"
   autoload :OperationTreeBuilders, "super_diff/operation_tree_builders"
@@ -24,12 +29,14 @@ module SuperDiff
   COLORS = {
     alpha: :magenta,
     beta: :yellow,
+    gamma: :cyan,
     border: :blue,
     header: :white,
   }.freeze
 
   def self.configure
     yield configuration
+    configuration.updated
   end
 
   def self.configuration
@@ -42,4 +49,13 @@ def self.time_like?(value)
     (value.respond_to?(:acts_like_time?) && value.acts_like_time?) ||
       value.is_a?(Time)
   end
+
+  def self.primitive?(value)
+    case value
+    when true, false, nil, Symbol, Numeric, Regexp, Class
+      true
+    else
+      false
+    end
+  end
 end

lib/super_diff/active_record.rb

@@ -2,7 +2,6 @@
 
 module SuperDiff
   module ActiveRecord
-    autoload :DiffFormatters, "super_diff/active_record/diff_formatters"
     autoload :Differs, "super_diff/active_record/differs"
     autoload(
       :ObjectInspection,
@@ -16,6 +15,10 @@ module ActiveRecord
       :OperationTreeBuilders,
       "super_diff/active_record/operation_tree_builders",
     )
+    autoload(
+      :OperationTreeFlatteners,
+      "super_diff/active_record/operation_tree_flatteners",
+    )
 
     SuperDiff.configure do |config|
       config.add_extra_differ_classes(
@@ -25,12 +28,9 @@ module ActiveRecord
         OperationTreeBuilders::ActiveRecordModel,
         OperationTreeBuilders::ActiveRecordRelation,
       )
-      config.add_extra_diff_formatter_classes(
-        DiffFormatters::ActiveRecordRelation,
-      )
-      config.add_extra_inspector_classes(
-        ObjectInspection::Inspectors::ActiveRecordModel,
-        ObjectInspection::Inspectors::ActiveRecordRelation,
+      config.add_extra_inspection_tree_builder_classes(
+        ObjectInspection::InspectionTreeBuilders::ActiveRecordModel,
+        ObjectInspection::InspectionTreeBuilders::ActiveRecordRelation,
       )
     end
   end

lib/super_diff/active_record/diff_formatters.rb

@@ -7,20 +7,10 @@ def self.applies_to?(expected, actual)
             actual.is_a?(::ActiveRecord::Relation)
         end
 
-        def call
-          DiffFormatters::ActiveRecordRelation.call(
-            operation_tree,
-            indent_level: indent_level,
-          )
-        end
-
-        private
+        protected
 
-        def operation_tree
-          OperationTreeBuilders::ActiveRecordRelation.call(
-            expected: expected,
-            actual: actual,
-          )
+        def operation_tree_builder_class
+          OperationTreeBuilders::ActiveRecordRelation
         end
       end
     end

lib/super_diff/active_record/diff_formatters/active_record_relation.rb

@@ -2,12 +2,8 @@ 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",
+        :InspectionTreeBuilders,
+        "super_diff/active_record/object_inspection/inspection_tree_builders",
       )
     end
   end

lib/super_diff/active_record/differs/active_record_relation.rb

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