Rename some concepts

* Rename "operation sequence" to "operation tree"
* Rename "operational sequencer" to "operation tree builder"

This commit is in preparation for adding elisions to diffs, which will
require adding the concept of an "operation list" (basically a flattened
version of an operation tree).

Author: mcmire

ARCHITECTURE.md

@@ -5,17 +5,28 @@ but here are some quick hits:
 
 ## Basic concepts
 
-* A **differ** figures out which operational sequencer to use.
-* An **operational sequencer** makes a comparison between two like data structures.
-  and generates a set of operations between them
-  (additions, deletions, or changes).
-* An **operation sequence** is a list of those operations
-  associated with some kind of diff formatter.
-* A **diff formatter** takes a list of operations
-  and spits out a textual representation of that list in the form of a conventional diff.
 * An **object inspector** generates a multi-line textual representation of an object,
   similar to PrettyPrinter in Ruby or AwesomePrint,
   but more appropriate for showing within a diff.
+* An **operation** represents a difference in one value from another
+  in the context of a data structure.
+  That difference can either be an *delete*, *insert*, or *change*.
+* An **operation tree** is the set of all operations between two data structures,
+  where each operation represents the difference between an inner element within the structure
+  (value for an array or a key/value pair for a hash).
+  Since change operations represent elements that have child elements,
+  they also have child operations to represent those child elements.
+  Those child operations can themselves have children, etc.
+  This descendancy is what forms the tree.
+* An **operation tree builder** makes a comparison between two like data structures
+  and generates an operation tree to represent the differences.
+* A **diff formatter** takes an operation tree
+  and spits out a textual representation of that tree in the form of a conventional diff.
+  Each operation may in fact generate more than one line in the final diff
+  because the object that is specific to the operation is run through an object inspector.
+* Finally, a **differ** ties everything together
+  and figures out which operation tree builder and diff formatter to use for a particular pair of values
+  (where one value is the "expected" and the other is the "actual").
 
 ## Code flow diagram
 

README.md

@@ -167,13 +167,16 @@ you would add something like this to your test helper file
 ``` ruby
 SuperDiff.configure do |config|
   config.add_extra_differ_class(YourDiffer)
-  config.add_extra_operational_sequencer_class(YourOperationalSequencer)
-  config.add_extra_operation_sequence_class(YourOperationSequence)
+  config.add_extra_operation_tree_builder_class(YourOperationTreeBuilder)
+  config.add_extra_operation_tree_class(YourOperationTree)
   config.add_extra_diff_formatter_class(YourDiffFormatter)
 end
 ```
 
-*(More info here in the future on adding a custom differ, operational sequencer, operation sequence, and diff formatter.
+*(More info here in the future on adding a custom differ,
+operation tree builder,
+operation tree,
+and diff formatter.
 Also explanations on what these are.)*
 
 ## Support

lib/super_diff.rb

@@ -16,8 +16,8 @@ module SuperDiff
   autoload :Helpers, "super_diff/helpers"
   autoload :ImplementationChecks, "super_diff/implementation_checks"
   autoload :ObjectInspection, "super_diff/object_inspection"
-  autoload :OperationSequences, "super_diff/operation_sequences"
-  autoload :OperationalSequencers, "super_diff/operational_sequencers"
+  autoload :OperationTrees, "super_diff/operation_trees"
+  autoload :OperationTreeBuilders, "super_diff/operation_tree_builders"
   autoload :Operations, "super_diff/operations"
   autoload :RecursionGuard, "super_diff/recursion_guard"
 

lib/super_diff/active_record.rb

@@ -9,21 +9,21 @@ module ActiveRecord
       "super_diff/active_record/object_inspection",
     )
     autoload(
-      :OperationSequences,
-      "super_diff/active_record/operation_sequences",
+      :OperationTrees,
+      "super_diff/active_record/operation_trees",
     )
     autoload(
-      :OperationalSequencers,
-      "super_diff/active_record/operational_sequencers",
+      :OperationTreeBuilders,
+      "super_diff/active_record/operation_tree_builders",
     )
 
     SuperDiff.configure do |config|
       config.add_extra_differ_classes(
         Differs::ActiveRecordRelation,
       )
-      config.add_extra_operational_sequencer_classes(
-        OperationalSequencers::ActiveRecordModel,
-        OperationalSequencers::ActiveRecordRelation,
+      config.add_extra_operation_tree_builder_classes(
+        OperationTreeBuilders::ActiveRecordModel,
+        OperationTreeBuilders::ActiveRecordRelation,
       )
       config.add_extra_diff_formatter_classes(
         DiffFormatters::ActiveRecordRelation,

lib/super_diff/active_record/diff_formatters/active_record_relation.rb

@@ -2,8 +2,8 @@ module SuperDiff
   module ActiveRecord
     module DiffFormatters
       class ActiveRecordRelation < SuperDiff::DiffFormatters::Base
-        def self.applies_to?(operations)
-          operations.is_a?(OperationSequences::ActiveRecordRelation)
+        def self.applies_to?(operation_tree)
+          operation_tree.is_a?(OperationTrees::ActiveRecordRelation)
         end
 
         def call
@@ -12,7 +12,7 @@ def call
             close_token: "]>",
             collection_prefix: collection_prefix,
             build_item_prefix: proc { "" },
-            operations: operations,
+            operation_tree: operation_tree,
             indent_level: indent_level,
             add_comma: add_comma?,
           )

lib/super_diff/active_record/differs/active_record_relation.rb

@@ -9,15 +9,15 @@ def self.applies_to?(expected, actual)
 
         def call
           DiffFormatters::ActiveRecordRelation.call(
-            operations,
+            operation_tree,
             indent_level: indent_level,
           )
         end
 
         private
 
-        def operations
-          OperationalSequencers::ActiveRecordRelation.call(
+        def operation_tree
+          OperationTreeBuilders::ActiveRecordRelation.call(
             expected: expected,
             actual: actual,
           )

lib/super_diff/active_record/operation_tree_builders.rb

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

lib/super_diff/active_record/operational_sequencers/active_record_model.rb renamed to lib/super_diff/active_record/operation_tree_builders/active_record_model.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module ActiveRecord
-    module OperationalSequencers
-      class ActiveRecordModel < SuperDiff::OperationalSequencers::CustomObject
+    module OperationTreeBuilders
+      class ActiveRecordModel < SuperDiff::OperationTreeBuilders::CustomObject
         def self.applies_to?(expected, actual)
           expected.is_a?(::ActiveRecord::Base) &&
             actual.is_a?(::ActiveRecord::Base) &&

lib/super_diff/active_record/operational_sequencers/active_record_relation.rb renamed to lib/super_diff/active_record/operation_tree_builders/active_record_relation.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module ActiveRecord
-    module OperationalSequencers
-      class ActiveRecordRelation < SuperDiff::OperationalSequencers::Array
+    module OperationTreeBuilders
+      class ActiveRecordRelation < SuperDiff::OperationTreeBuilders::Array
         def self.applies_to?(expected, actual)
           expected.is_a?(::Array) &&
             actual.is_a?(::ActiveRecord::Relation)
@@ -15,8 +15,8 @@ def initialize(actual:, **rest)
 
         private
 
-        def operations
-          @_operations ||= OperationSequences::ActiveRecordRelation.new([])
+        def operation_tree
+          @_operation_tree ||= OperationTrees::ActiveRecordRelation.new([])
         end
       end
     end

lib/super_diff/active_record/operation_sequences.rb renamed to lib/super_diff/active_record/operation_trees.rb

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