chrono_model 1.2.2 → 3.0.1

data/lib/chrono_model/adapter.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 require 'active_record/connection_adapters/postgresql_adapter'
 
 require 'chrono_model/adapter/migrations'
+require 'chrono_model/adapter/migrations_modules/stable'
+
 require 'chrono_model/adapter/ddl'
 require 'chrono_model/adapter/indexes'
 require 'chrono_model/adapter/tsrange'
 require 'chrono_model/adapter/upgrade'
 
 module ChronoModel
-
   # This class implements all ActiveRecord::ConnectionAdapters::SchemaStatements
   # methods adding support for temporal extensions. It inherits from the Postgres
   # adapter for a clean override of its methods using super.
@@ -25,12 +28,28 @@ module ChronoModel
     # The schema holding historical data
     HISTORY_SCHEMA  = 'history'
 
+    if ActiveRecord::VERSION::STRING >= '7.1'
+      def initialize(*)
+        super
+
+        connect!
+
+        unless chrono_supported?
+          raise ChronoModel::Error, 'Your database server is not supported by ChronoModel. ' \
+                                    'Currently, only PostgreSQL >= 9.3 is supported.'
+        end
+
+        chrono_setup!
+      end
+    end
+
     # Returns true whether the connection adapter supports our
     # implementation of temporal tables. Currently, Chronomodel
-    # is supported starting with PostgreSQL 9.3.
+    # is supported starting with PostgreSQL 9.3 (90300 in PostgreSQL's
+    # `PG_VERSION_NUM` numeric format).
     #
     def chrono_supported?
-      postgresql_version >= 90300
+      postgresql_version >= 90300 # rubocop:disable Style/NumericLiterals
     end
 
     def chrono_setup!
@@ -53,13 +72,13 @@ module ChronoModel
     #
     # NOTE: These methods are dynamically defined, see the source.
     #
-    def primary_key(table_name)
-    end
+    def primary_key(table_name); end
 
-    [:primary_key, :indexes, :default_sequence_name].each do |method|
+    %i[primary_key indexes default_sequence_name].each do |method|
       define_method(method) do |*args|
         table_name = args.first
         return super(*args) unless is_chrono?(table_name)
+
         on_schema(TEMPORAL_SCHEMA, recurse: :ignore) { super(*args) }
       end
     end
@@ -73,12 +92,12 @@ module ChronoModel
     #
     # NOTE: This method is dynamically defined, see the source.
     #
-    def column_definitions
-    end
+    def column_definitions; end
 
     define_method(:column_definitions) do |table_name|
       return super(table_name) unless is_chrono?(table_name)
-      on_schema(TEMPORAL_SCHEMA + ',' + self.schema_search_path, recurse: :ignore) { super(table_name) }
+
+      on_schema("#{TEMPORAL_SCHEMA},#{schema_search_path}", recurse: :ignore) { super(table_name) }
     end
 
     # Evaluates the given block in the temporal schema.
@@ -101,16 +120,15 @@ module ChronoModel
     # See specs for examples and behaviour.
     #
     def on_schema(schema, recurse: :follow)
-      old_path = self.schema_search_path
+      old_path = schema_search_path
 
       count_recursions do
-        if recurse == :follow or Thread.current['recursions'] == 1
+        if (recurse == :follow) || (Thread.current['recursions'] == 1)
           self.schema_search_path = schema
         end
 
         yield
       end
-
     ensure
       # If the transaction is aborted, any execute() call will raise
       # "transaction is aborted errors" - thus calling the Adapter's
@@ -121,7 +139,7 @@ module ChronoModel
       # transaction ends.
       #
       transaction_aborted =
-        @connection.transaction_status == PG::Connection::PQTRANS_INERROR
+        chrono_connection.transaction_status == PG::Connection::PQTRANS_INERROR
 
       if transaction_aborted && Thread.current['recursions'] == 1
         @schema_search_path = nil
@@ -143,7 +161,8 @@ module ChronoModel
     def chrono_metadata_for(view_name)
       comment = select_value(
         "SELECT obj_description(#{quote(view_name)}::regclass)",
-        "ChronoModel metadata for #{view_name}") if data_source_exists?(view_name)
+        "ChronoModel metadata for #{view_name}"
+      ) if data_source_exists?(view_name)
 
       MultiJson.load(comment || '{}').with_indifferent_access
     end
@@ -153,29 +172,38 @@ module ChronoModel
     def chrono_metadata_set(view_name, metadata)
       comment = MultiJson.dump(metadata)
 
-      execute %[ COMMENT ON VIEW #{view_name} IS #{quote(comment)} ]
+      execute %( COMMENT ON VIEW #{view_name} IS #{quote(comment)} )
+    end
+
+    def valid_table_definition_options
+      super + %i[temporal journal no_journal full_journal]
     end
 
     private
-      # Counts the number of recursions in a thread local variable
-      #
-      def count_recursions # yield
-        Thread.current['recursions'] ||= 0
-        Thread.current['recursions'] += 1
 
-        yield
+    # Rails 7.1 uses `@raw_connection`, older versions use `@connection`
+    #
+    def chrono_connection
+      @chrono_connection ||= @raw_connection || @connection
+    end
 
-      ensure
-        Thread.current['recursions'] -= 1
-      end
+    # Counts the number of recursions in a thread local variable
+    #
+    def count_recursions # yield
+      Thread.current['recursions'] ||= 0
+      Thread.current['recursions'] += 1
 
-      # Create the temporal and history schemas, unless they already exist
-      #
-      def chrono_ensure_schemas
-        [TEMPORAL_SCHEMA, HISTORY_SCHEMA].each do |schema|
-          execute "CREATE SCHEMA #{schema}" unless schema_exists?(schema)
-        end
+      yield
+    ensure
+      Thread.current['recursions'] -= 1
+    end
+
+    # Create the temporal and history schemas, unless they already exist
+    #
+    def chrono_ensure_schemas
+      [TEMPORAL_SCHEMA, HISTORY_SCHEMA].each do |schema|
+        execute "CREATE SCHEMA #{schema}" unless schema_exists?(schema)
       end
+    end
   end
-
 end

data/lib/chrono_model/chrono.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChronoModel
+  # A module to add to ActiveRecord::Base to check if they are backed by
+  # temporal tables.
+  module Chrono
+    # Checks whether this Active Record model is backed by a temporal table
+    #
+    # @return [Boolean] false if the connection does not respond to is_chrono?
+    #   the result of connection.is_chrono?(table_name) otherwise
+    def chrono?
+      return false unless connection.respond_to? :is_chrono?
+
+      connection.is_chrono?(table_name)
+    end
+  end
+end

data/lib/chrono_model/conversions.rb

@@ -1,20 +1,26 @@
-module ChronoModel
+# frozen_string_literal: true
 
+module ChronoModel
   module Conversions
-    extend self
+    module_function
 
     ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(?:\.(\d+))?\z/
 
+    # rubocop:disable Style/PerlBackrefs
     def string_to_utc_time(string)
-      if string =~ ISO_DATETIME
-        usec = $7.nil? ? '000000' : $7.ljust(6, '0') # .1 is .100000, not .000001
-        Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec.to_i
-      end
+      return string if string.is_a?(Time)
+
+      return unless string =~ ISO_DATETIME
+
+      # .1 is .100000, not .000001
+      usec = $7.ljust(6, '0') unless $7.nil?
+
+      Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec.to_i
     end
+    # rubocop:enable Style/PerlBackrefs
 
     def time_to_utc_string(time)
-      [time.to_s(:db), sprintf('%06d', time.usec)].join '.'
+      time.to_fs(:db) << '.' << format('%06d', time.usec)
     end
   end
-
 end

data/lib/chrono_model/db_console.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'chrono_model/patches/db_console'
+
+Rails::DBConsole.prepend ChronoModel::Patches::DBConsole::DbConfig

data/lib/chrono_model/patches/as_of_time_holder.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     # Added to classes that need to carry the As-Of date around
     #
     module AsOfTimeHolder
@@ -18,6 +19,5 @@ module ChronoModel
         @_as_of_time
       end
     end
-
   end
 end

data/lib/chrono_model/patches/as_of_time_relation.rb

@@ -1,19 +1,9 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     # This class is a dummy relation whose scope is only to pass around the
     # as_of_time parameters across ActiveRecord call chains.
-    #
-    # With AR 5.2 a simple relation can be used, as the only required argument
-    # is the model. 5.0 and 5.1 require more arguments, that are passed here.
-    #
-    class AsOfTimeRelation < ActiveRecord::Relation
-      if ActiveRecord::VERSION::STRING.to_f < 5.2
-        def initialize(klass, table: klass.arel_table, predicate_builder: klass.predicate_builder, values: {})
-          super(klass, table, predicate_builder, values)
-        end
-      end
-    end
-
+    class AsOfTimeRelation < ActiveRecord::Relation; end
   end
 end

data/lib/chrono_model/patches/association.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     # Patches ActiveRecord::Associations::Association to add support for
     # temporal associations.
     #
@@ -30,23 +31,25 @@ module ChronoModel
 
         scope.as_of_time!(owner.as_of_time)
 
-        return scope
+        scope
       end
 
       private
-        def _chrono_record?
-          owner.respond_to?(:as_of_time) && owner.as_of_time.present?
-        end
 
-        def _chrono_target?
-          @_target_klass ||= reflection.options[:polymorphic] ?
-            owner.public_send(reflection.foreign_type).constantize :
-            reflection.klass
+      def _chrono_record?
+        owner.class.include?(ChronoModel::Patches::AsOfTimeHolder) && owner.as_of_time.present?
+      end
 
-          @_target_klass.chrono?
-        end
+      def _chrono_target?
+        @_target_klass ||=
+          if reflection.options[:polymorphic]
+            owner.public_send(reflection.foreign_type).constantize
+          else
+            reflection.klass
+          end
 
+        @_target_klass.chrono?
+      end
     end
-
   end
 end

data/lib/chrono_model/patches/batches.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ChronoModel
+  module Patches
+    module Batches
+      def in_batches(**)
+        return super unless try(:history?)
+
+        with_hid_pkey { super }
+      end
+    end
+  end
+end

data/lib/chrono_model/patches/db_console.rb

@@ -1,11 +1,27 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     module DBConsole
-      def config
-        super.dup.tap {|config| config['adapter'] = 'postgresql/chronomodel' }
+      module Config
+        def config
+          super.dup.tap { |config| config['adapter'] = 'postgresql/chronomodel' }
+        end
       end
-    end
 
+      module DbConfig
+        def db_config
+          return @patched_db_config if @patched_db_config
+
+          original_db_config = super
+          patched_db_configuration_hash = original_db_config.configuration_hash.dup.tap do |config|
+            config[:adapter] = 'postgresql/chronomodel'
+          end
+          original_db_config.instance_variable_set :@configuration_hash, patched_db_configuration_hash
+
+          @patched_db_config = original_db_config
+        end
+      end
+    end
   end
 end

data/lib/chrono_model/patches/join_node.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     # This class supports the AR 5.0 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
@@ -21,12 +22,11 @@ module ChronoModel
 
         @as_of_time  = as_of_time
 
-        virtual_table = history_model.
-          virtual_table_at(@as_of_time, table_name: @table_alias || @table_name)
+        virtual_table = history_model
+                        .virtual_table_at(@as_of_time, table_name: @table_alias || @table_name)
 
         super(virtual_table)
       end
     end
-
   end
 end

data/lib/chrono_model/patches/preloader.rb

@@ -1,18 +1,26 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     # Patches ActiveRecord::Associations::Preloader to add support for
     # temporal associations. This is tying itself to Rails internals
     # and it is ugly :-(.
     #
     module Preloader
-      attr_reader :options
+      attr_reader :chronomodel_options
 
       # We overwrite the initializer in order to pass the +as_of_time+
       # parameter above in the build_preloader
       #
-      def initialize(options = {})
-        @options = options.freeze
+      def initialize(**options)
+        @chronomodel_options = options.extract!(:as_of_time, :model)
+        options[:scope] = chronomodel_scope(options[:scope]) if options.key?(:scope)
+
+        if options.empty?
+          super()
+        else
+          super(**options)
+        end
       end
 
       # Patches the AR Preloader (lib/active_record/associations/preloader.rb)
@@ -37,14 +45,20 @@ module ChronoModel
       # so we use it directly.
       #
       def preload(records, associations, given_preload_scope = nil)
-        if options[:as_of_time]
-          preload_scope = given_preload_scope ||
-            ChronoModel::Patches::AsOfTimeRelation.new(options[:model])
+        super(records, associations, chronomodel_scope(given_preload_scope))
+      end
+
+      private
 
-          preload_scope.as_of_time!(options[:as_of_time])
+      def chronomodel_scope(given_preload_scope)
+        preload_scope = given_preload_scope
+
+        if chronomodel_options[:as_of_time]
+          preload_scope ||= ChronoModel::Patches::AsOfTimeRelation.new(chronomodel_options[:model])
+          preload_scope.as_of_time!(chronomodel_options[:as_of_time])
         end
 
-        super records, associations, preload_scope
+        preload_scope
       end
 
       module Association
@@ -59,10 +73,26 @@ module ChronoModel
             scope = scope.as_of(preload_scope.as_of_time)
           end
 
-          return scope
+          scope
         end
       end
-    end
 
+      module ThroughAssociation
+        # Builds the preloader scope taking into account a potential
+        # +as_of_time+ passed down the call chain starting at the
+        # end user invocation.
+        #
+        def through_scope
+          scope = super
+          return unless scope # Rails 5.2 may not return a scope
+
+          if preload_scope.try(:as_of_time)
+            scope = scope.as_of(preload_scope.as_of_time)
+          end
+
+          scope
+        end
+      end
+    end
   end
 end

data/lib/chrono_model/patches/relation.rb

@@ -1,13 +1,32 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module Patches
-
     module Relation
       include ChronoModel::Patches::AsOfTimeHolder
 
+      def preload_associations(records) # :nodoc:
+        preload = preload_values
+        preload += includes_values unless eager_loading?
+        scope = StrictLoadingScope if strict_loading_value
+
+        preload.each do |associations|
+          ActiveRecord::Associations::Preloader.new(
+            records: records, associations: associations, scope: scope, model: model, as_of_time: as_of_time
+          ).call
+        end
+      end
+
+      def empty_scope?
+        return super unless @_as_of_time
+
+        @values == klass.unscoped.as_of(as_of_time).values
+      end
+
       def load
         return super unless @_as_of_time && !loaded?
 
-        super.each {|record| record.as_of_time!(@_as_of_time) }
+        super.each { |record| record.as_of_time!(@_as_of_time) }
       end
 
       def merge(*)
@@ -20,11 +39,9 @@ module ChronoModel
         return super unless @_as_of_time
 
         super.tap do |arel|
-
           arel.join_sources.each do |join|
             chrono_join_history(join)
           end
-
         end
       end
 
@@ -37,11 +54,18 @@ module ChronoModel
         #
         return if join.left.respond_to?(:as_of_time)
 
-        model = ChronoModel.history_models[join.left.table_name]
+        model =
+          if join.left.respond_to?(:table_name)
+            ChronoModel.history_models[join.left.table_name]
+          else
+            ChronoModel.history_models[join.left]
+          end
+
         return unless model
 
         join.left = ChronoModel::Patches::JoinNode.new(
-          join.left, model.history, @_as_of_time)
+          join.left, model.history, @_as_of_time
+        )
       end
 
       # Build a preloader at the +as_of_time+ of this relation.
@@ -49,10 +73,29 @@ module ChronoModel
       #
       def build_preloader
         ActiveRecord::Associations::Preloader.new(
-          model: self.model, as_of_time: as_of_time
+          model: model, as_of_time: as_of_time
         )
       end
-    end
 
+      def find_nth(*)
+        return super unless try(:history?)
+
+        with_hid_pkey { super }
+      end
+
+      def last(*)
+        return super unless try(:history?)
+
+        with_hid_pkey { super }
+      end
+
+      private
+
+      def ordered_relation
+        return super unless try(:history?)
+
+        with_hid_pkey { super }
+      end
+    end
   end
 end

data/lib/chrono_model/patches.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'chrono_model/patches/as_of_time_holder'
 require 'chrono_model/patches/as_of_time_relation'
 
@@ -5,4 +7,4 @@ require 'chrono_model/patches/join_node'
 require 'chrono_model/patches/relation'
 require 'chrono_model/patches/preloader'
 require 'chrono_model/patches/association'
-require 'chrono_model/patches/db_console'
+require 'chrono_model/patches/batches'

data/lib/chrono_model/railtie.rb

@@ -1,45 +1,31 @@
+# frozen_string_literal: true
+
 require 'active_record/tasks/chronomodel_database_tasks'
 
 module ChronoModel
   class Railtie < ::Rails::Railtie
+    TASKS_CLASS = ActiveRecord::Tasks::ChronomodelDatabaseTasks
 
-    rake_tasks do
-      if Rails.application.config.active_record.schema_format != :sql
-        raise 'In order to use ChronoModel, config.active_record.schema_format must be :sql!'
-      end
-
-      tasks_class = ActiveRecord::Tasks::ChronomodelDatabaseTasks
-
-      # Register our database tasks under our adapter name
-      #
-      ActiveRecord::Tasks::DatabaseTasks.register_task(/chronomodel/, tasks_class)
+    # Register our database tasks under our adapter name
+    ActiveRecord::Tasks::DatabaseTasks.register_task(/chronomodel/, TASKS_CLASS.to_s)
 
-      # Make schema:dump and schema:load invoke structure:dump and structure:load
-      Rake::Task['db:schema:dump'].clear.enhance(['environment']) do
-        Rake::Task['db:structure:dump'].invoke
-      end
-
-      Rake::Task['db:schema:load'].clear.enhance(['environment']) do
-        Rake::Task['db:structure:load'].invoke
+    rake_tasks do
+      def task_config
+        ActiveRecord::Base.connection_db_config
       end
 
-      desc "Dumps database into db/data.NOW.sql or file specified via DUMP="
+      desc 'Dumps database into db/data.NOW.sql or file specified via DUMP='
       task 'db:data:dump' => :environment do
-        config = ActiveRecord::Tasks::DatabaseTasks.current_config
         target = ENV['DUMP'] || Rails.root.join('db', "data.#{Time.now.to_f}.sql")
-
-        tasks_class.new(config).data_dump(target)
+        TASKS_CLASS.new(task_config).data_dump(target)
       end
 
-      desc "Loads database dump from file specified via DUMP="
+      desc 'Loads database dump from file specified via DUMP='
       task 'db:data:load' => :environment do
-        config = ActiveRecord::Tasks::DatabaseTasks.current_config
         source = ENV['DUMP'].presence or
-          raise ArgumentError, "Invoke as rake db:data:load DUMP=/path/to/data.sql"
-
-        tasks_class.new(config).data_load(source)
+          raise ArgumentError, 'Invoke as rake db:data:load DUMP=/path/to/data.sql'
+        TASKS_CLASS.new(task_config).data_load(source)
       end
     end
-
   end
 end

data/lib/chrono_model/time_gate.rb

@@ -1,5 +1,6 @@
-module ChronoModel
+# frozen_string_literal: true
 
+module ChronoModel
   # Provides the TimeMachine API to non-temporal models that associate
   # temporal ones.
   #
@@ -17,12 +18,11 @@ module ChronoModel
     end
 
     def as_of(time)
-      self.class.as_of(time).where(id: self.id).first!
+      self.class.as_of(time).where(id: id).first!
     end
 
     def timeline
       self.class.timeline(self)
     end
   end
-
 end