Resolve historical join table via name/table_alias (#389)

All supported Rails versions consistently respond to `#name` and
`#table_alias`, so branching on `#table_name` is unnecessary.

This change standardizes on the stable API by resolving models via
`join.left.name` and, in JoinNode, computing the virtual table name as
`join_node.table_alias || join_node.name`.

It also retains the early return in chrono_join_history when the join
has already been wrapped and removes the emulation of `Arel::Table`-like
readers from the SqlLiteral JoinNode.

`respond_to?` guards in JoinNode have been removed because
`Relation#chrono_join_history` only instantiates it for nodes that
respond to `:name` (and `Arel::Table` provides `:table_alias` across
all supported Rails versions), so this invariant is enforced at the call
site.

The generated SQL semantics are unchanged; the refactor simply aligns
our code with the methods that are available across Rails supported
rails versions and reduces maintenance

Close #388

Author: tagliala

lib/chrono_model/patches/join_node.rb

@@ -2,40 +2,17 @@
 
 module ChronoModel
   module Patches
-    # This class supports the AR < 7.1 code that expects to receive an
-    # Arel::Table as the left join node. We need to replace the node
-    # with a virtual table that fetches from the history at a given
-    # point in time, we replace the join node with a SqlLiteral node
-    # that does not respond to the methods that AR expects.
-    #
-    # This class provides AR with an object implementing the methods
-    # it expects, yet producing SQL that fetches from history tables
-    # as-of-time.
-    #
-    # TODO: Remove when dropping Rails < 7.1 compatibility
+    # Replaces the left side of an Arel join (table or table alias) with a SQL
+    # literal pointing to the history virtual table at the given as_of_time,
+    # preserving any existing table alias.
     class JoinNode < Arel::Nodes::SqlLiteral
-      attr_reader :name, :table_name, :table_alias, :as_of_time
+      attr_reader :as_of_time
 
       def initialize(join_node, history_model, as_of_time)
-        # Handle both Arel::Table (which has .name method) and other join node types
-        # (which have .table_name method) to extract the table name consistently
-        table_name =
-          if join_node.respond_to?(:table_name)
-            join_node.table_name
-          elsif join_node.respond_to?(:name)
-            join_node.name
-          else
-            raise ArgumentError, "Cannot determine table name from #{join_node.class}: expected :table_name or :name method"
-          end
-
-        @name        = table_name
-        @table_name  = table_name
-        @table_alias = join_node.table_alias if join_node.respond_to?(:table_alias)
-
         @as_of_time  = as_of_time
 
-        virtual_table = history_model
-                        .virtual_table_at(@as_of_time, table_name: @table_alias || @table_name)
+        table_name = join_node.table_alias || join_node.name
+        virtual_table = history_model.virtual_table_at(@as_of_time, table_name: table_name)
 
         super(virtual_table)
       end

lib/chrono_model/patches/relation.rb

@@ -68,26 +68,18 @@ def build_arel(*)
 
       # Replaces a join with the current data with another that
       # loads records As-Of time against the history data.
-      #
       def chrono_join_history(join)
+        join_left = join.left
+
         # This case happens with nested includes, where the below
         # code has already replaced the join.left with a JoinNode.
-        #
-        return if join.left.respond_to?(:as_of_time)
-
-        # Handle both Arel::Table (which has .name method) and other join node types
-        # (which have .table_name method) to extract the table name consistently
-        model =
-          if join.left.respond_to?(:table_name)
-            ChronoModel.history_models[join.left.table_name]
-          elsif join.left.respond_to?(:name)
-            ChronoModel.history_models[join.left.name]
-          end
+        return if join_left.is_a?(ChronoModel::Patches::JoinNode)
 
+        model = ChronoModel.history_models[join_left.name] if join_left.respond_to?(:name)
         return unless model
 
         join.left = ChronoModel::Patches::JoinNode.new(
-          join.left, model.history, @_as_of_time
+          join_left, model.history, @_as_of_time
         )
       end