chrono_model 1.2.2 → 2.0.0

data/lib/chrono_model/railtie.rb

@@ -1,45 +1,50 @@
+# frozen_string_literal: true
+
 require 'active_record/tasks/chronomodel_database_tasks'
 
 module ChronoModel
   class Railtie < ::Rails::Railtie
+    TASKS_CLASS = ActiveRecord::Tasks::ChronomodelDatabaseTasks
+
+    # Register our database tasks under our adapter name
+    if Rails.version < '5.2'
+      ActiveRecord::Tasks::DatabaseTasks.register_task(/chronomodel/, TASKS_CLASS)
+    else
+      ActiveRecord::Tasks::DatabaseTasks.register_task(/chronomodel/, TASKS_CLASS.to_s)
+    end
 
     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!'
+      def task_config
+        if Rails.version < '6.1'
+          ActiveRecord::Tasks::DatabaseTasks.current_config.with_indifferent_access
+        else
+          ActiveRecord::Base.connection_db_config
+        end
       end
 
-      tasks_class = ActiveRecord::Tasks::ChronomodelDatabaseTasks
+      if Rails.version < '6.1'
+        # 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
 
-      # Register our database tasks under our adapter name
-      #
-      ActiveRecord::Tasks::DatabaseTasks.register_task(/chronomodel/, tasks_class)
-
-      # 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
+        Rake::Task['db:schema:load'].clear.enhance(['environment']) do
+          Rake::Task['db:structure:load'].invoke
+        end
       end
 
-      Rake::Task['db:schema:load'].clear.enhance(['environment']) do
-        Rake::Task['db:structure:load'].invoke
-      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

data/lib/chrono_model/time_machine/history_model.rb

@@ -1,15 +1,25 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module TimeMachine
-
     module HistoryModel
       extend ActiveSupport::Concern
 
       included do
-        self.table_name = [Adapter::HISTORY_SCHEMA, superclass.table_name].join('.')
+        self.table_name = "#{Adapter::HISTORY_SCHEMA}.#{superclass.table_name}"
 
         scope :chronological, -> { order(Arel.sql('lower(validity) ASC')) }
       end
 
+      # ACTIVE RECORD 7 does not call `class.find` but a new internal method called `_find_record`
+      def _find_record(options)
+        if options && options[:lock]
+          self.class.preload(strict_loaded_associations).lock(options[:lock]).find_by!(hid: hid)
+        else
+          self.class.preload(strict_loaded_associations).find_by!(hid: hid)
+        end
+      end
+
       # Methods that make up the history interface of the companion History
       # model, automatically built for each Model that includes TimeMachine
       #
@@ -21,11 +31,11 @@ module ChronoModel
         # setting it now and ensuring to reset it to the original one after
         # execution completes. FIXME
         #
-        def with_hid_pkey(&block)
-          old = self.primary_key
+        def with_hid_pkey
+          old = primary_key
           self.primary_key = :hid
 
-          block.call
+          yield
         ensure
           self.primary_key = old
         end
@@ -61,9 +71,12 @@ module ChronoModel
         end
 
         def virtual_table_at(time, table_name: nil)
-          virtual_name = table_name ?
-            connection.quote_table_name(table_name) :
-            superclass.quoted_table_name
+          virtual_name =
+            if table_name
+              connection.quote_table_name(table_name)
+            else
+              superclass.quoted_table_name
+            end
 
           "(#{at(time).to_sql}) #{virtual_name}"
         end
@@ -77,7 +90,7 @@ module ChronoModel
         # Returns the history sorted by recorded_at
         #
         def sorted
-          all.order(Arel.sql(%[ #{quoted_table_name}."recorded_at" ASC, #{quoted_table_name}."hid" ASC ]))
+          all.order(Arel.sql(%( #{quoted_table_name}."recorded_at" ASC, #{quoted_table_name}."hid" ASC )))
         end
 
         # Fetches the given +object+ history, sorted by history record time
@@ -96,9 +109,7 @@ module ChronoModel
         #
         # As such it is overriden here to return the same contents that
         # the parent would have returned.
-        def sti_name
-          superclass.sti_name
-        end
+        delegate :sti_name, to: :superclass
 
         # For STI to work, the history model needs to have the exact same
         # semantics as the model it inherits from. However given it is
@@ -107,18 +118,17 @@ module ChronoModel
         # same exact hierarchy location as its parent, thus this is defined in
         # this override.
         #
-        def descends_from_active_record?
-          superclass.descends_from_active_record?
-        end
+        delegate :descends_from_active_record?, to: :superclass
 
         private
-          # STI fails when a Foo::History record has Foo as type in the
-          # inheritance column; AR expects the type to be an instance of the
-          # current class or a descendant (or self).
-          #
-          def find_sti_class(type_name)
-            super(type_name + "::History")
-          end
+
+        # STI fails when a Foo::History record has Foo as type in the
+        # inheritance column; AR expects the type to be an instance of the
+        # current class or a descendant (or self).
+        #
+        def find_sti_class(type_name)
+          super("#{type_name}::History")
+        end
       end
 
       # The history id is `hid`, but this cannot set as primary key
@@ -134,15 +144,15 @@ module ChronoModel
       end
 
       def save(*)
-        self.class.with_hid_pkey { super }
+        with_hid_pkey { super }
       end
 
       def save!(*)
-        self.class.with_hid_pkey { super }
+        with_hid_pkey { super }
       end
 
       def update_columns(*)
-        self.class.with_hid_pkey { super }
+        with_hid_pkey { super }
       end
 
       def historical?
@@ -153,7 +163,7 @@ module ChronoModel
       # is the first one.
       #
       def pred
-        return if self.valid_from.nil?
+        return if valid_from.nil?
 
         if self.class.timeline_associations.empty?
           self.class.where('id = ? AND upper(validity) = ?', rid, valid_from).first
@@ -166,7 +176,7 @@ module ChronoModel
       # last one.
       #
       def succ
-        return if self.valid_to.nil?
+        return if valid_to.nil?
 
         if self.class.timeline_associations.empty?
           self.class.where('id = ? AND lower(validity) = ?', rid, valid_to).first
@@ -174,7 +184,7 @@ module ChronoModel
           super(id: rid, after: valid_to, table: self.class.superclass.quoted_table_name)
         end
       end
-      alias :next :succ
+      alias next succ
 
       # Returns the first history entry
       #
@@ -194,9 +204,9 @@ module ChronoModel
         self.class.superclass.find(rid)
       end
 
-      def record #:nodoc:
+      def record # :nodoc:
         ActiveSupport::Deprecation.warn '.record is deprecated in favour of .current_version'
-        self.current_version
+        current_version
       end
 
       def valid_from
@@ -211,7 +221,31 @@ module ChronoModel
       def recorded_at
         ChronoModel::Conversions.string_to_utc_time attributes_before_type_cast['recorded_at']
       end
-    end
 
+      # Starting from Rails 6.0, `.read_attribute` will use the memoized
+      # `primary_key` if it detects that the attribute name is `id`.
+      #
+      # Since the `primary key` may have been changed to `hid` because of
+      # `.find` overload, the new behavior may break relations where `id` is
+      # still the correct attribute to read
+      #
+      # Ref: ifad/chronomodel#181
+      def read_attribute(attr_name, &block)
+        return super unless attr_name.to_s == 'id' && @primary_key.to_s == 'hid'
+
+        _read_attribute('id', &block)
+      end
+
+      private
+
+      def with_hid_pkey(&block)
+        old_primary_key = @primary_key
+        @primary_key = :hid
+
+        self.class.with_hid_pkey(&block)
+      ensure
+        @primary_key = old_primary_key
+      end
+    end
   end
 end

data/lib/chrono_model/time_machine/time_query.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module TimeMachine
-
     #
     # TODO Documentation
     #
@@ -12,75 +13,90 @@ module ChronoModel
       end
 
       private
-        def time_query_sql(match, time, range, options)
-          case match
-          when :at
-            build_time_query_at(time, range)
 
-          when :not
-            "NOT (#{build_time_query_at(time, range)})"
+      def time_query_sql(match, time, range, options)
+        case match
+        when :at
+          build_time_query_at(time, range)
 
-          when :before
-            op = options.fetch(:inclusive, true) ? '&&' : '@>'
-            build_time_query(['NULL', time_for_time_query(time, range)], range, op)
+        when :not
+          "NOT (#{build_time_query_at(time, range)})"
 
-          when :after
-            op = options.fetch(:inclusive, true) ? '&&' : '@>'
-            build_time_query([time_for_time_query(time, range), 'NULL'], range, op)
+        when :before
+          op =
+            if options.fetch(:inclusive, true)
+              '&&'
+            else
+              '@>'
+            end
+          build_time_query(['NULL', time_for_time_query(time, range)], range, op)
 
-          else
-            raise ChronoModel::Error, "Invalid time_query: #{match}"
-          end
+        when :after
+          op =
+            if options.fetch(:inclusive, true)
+              '&&'
+            else
+              '@>'
+            end
+          build_time_query([time_for_time_query(time, range), 'NULL'], range, op)
+
+        else
+          raise ChronoModel::Error, "Invalid time_query: #{match}"
         end
+      end
 
-        def time_for_time_query(t, column)
-          if t == :now || t == :today
-            now_for_column(column)
-          else
-            quoted_t = connection.quote(connection.quoted_date(t))
-            [quoted_t, primitive_type_for_column(column)].join('::')
-          end
+      def time_for_time_query(t, column)
+        if t == :now || t == :today
+          now_for_column(column)
+        else
+          quoted_t = connection.quote(connection.quoted_date(t))
+          "#{quoted_t}::#{primitive_type_for_column(column)}"
         end
+      end
 
-        def now_for_column(column)
-          case column.type
-          when :tsrange, :tstzrange then "timezone('UTC', current_timestamp)"
-          when :daterange           then "current_date"
-          else raise "Cannot generate 'now()' for #{column.type} column #{column.name}"
-          end
+      def now_for_column(column)
+        case column.type
+        when :tsrange, :tstzrange then "timezone('UTC', current_timestamp)"
+        when :daterange           then 'current_date'
+        else raise "Cannot generate 'now()' for #{column.type} column #{column.name}"
         end
+      end
 
-        def primitive_type_for_column(column)
-          case column.type
-          when :tsrange   then :timestamp
-          when :tstzrange then :timestamptz
-          when :daterange then :date
-          else raise "Don't know how to map #{column.type} column #{column.name} to a primitive type"
-          end
+      def primitive_type_for_column(column)
+        case column.type
+        when :tsrange   then :timestamp
+        when :tstzrange then :timestamptz
+        when :daterange then :date
+        else raise "Don't know how to map #{column.type} column #{column.name} to a primitive type"
         end
+      end
 
-        def build_time_query_at(time, range)
-          time = if time.kind_of?(Array)
-            time.map! {|t| time_for_time_query(t, range)}
+      def build_time_query_at(time, range)
+        time =
+          if time.is_a?(Array)
+            time.map! { |t| time_for_time_query(t, range) }
 
             # If both edges of the range are the same the query fails using the '&&' operator.
             # The correct solution is to use the <@ operator.
-            time.first == time.last ? time.first : time
+            if time.first == time.last
+              time.first
+            else
+              time
+            end
           else
             time_for_time_query(time, range)
           end
 
-          build_time_query(time, range)
-        end
+        build_time_query(time, range)
+      end
 
-        def build_time_query(time, range, op = '&&')
-          if time.kind_of?(Array)
-            Arel.sql %[ #{range.type}(#{time.first}, #{time.last}) #{op} #{table_name}.#{range.name} ]
-          else
-            Arel.sql %[ #{time} <@ #{table_name}.#{range.name} ]
-          end
+      def build_time_query(time, range, op = '&&')
+        if time.is_a?(Array)
+          Arel.sql %[ #{range.type}(#{time.first}, #{time.last}) #{op} #{table_name}.#{range.name} ]
+        else
+          Arel.sql %( #{time} <@ #{table_name}.#{range.name} )
         end
+      end
     end
-
   end
 end

data/lib/chrono_model/time_machine/timeline.rb

@@ -1,59 +1,87 @@
+# frozen_string_literal: true
+
 module ChronoModel
   module TimeMachine
-
     module Timeline
       # Returns an Array of unique UTC timestamps for which at least an
       # history record exists. Takes temporal associations into account.
       #
       def timeline(record = nil, options = {})
-        rid = record.respond_to?(:rid) ? record.rid : record.id if record
+        rid =
+          if record
+            if record.respond_to?(:rid)
+              record.rid
+            else
+              record.id
+            end
+          end
 
-        assocs = options.key?(:with) ?
-          timeline_associations_from(options[:with]) : timeline_associations
+        assocs =
+          if options.key?(:with)
+            timeline_associations_from(options[:with])
+          else
+            timeline_associations
+          end
 
         models = []
-        models.push self if self.chrono?
-        models.concat(assocs.map {|a| a.klass.history})
+        models.push self if chrono?
+        models.concat(assocs.map { |a| a.klass.history })
 
         return [] if models.empty?
 
-        fields = models.inject([]) {|a,m| a.concat m.quoted_history_fields}
+        fields = models.inject([]) { |a, m| a.concat m.quoted_history_fields }
 
-        relation = self.except(:order).
-          select("DISTINCT UNNEST(ARRAY[#{fields.join(',')}]) AS ts")
+        relation = except(:order)
+                   .select("DISTINCT UNNEST(ARRAY[#{fields.join(',')}]) AS ts")
 
         if assocs.present?
-          relation = relation.joins(*assocs.map(&:name))
+          assocs.each do |ass|
+            association_quoted_table_name = connection.quote_table_name(ass.table_name)
+            # `join` first, then use `where`s
+            relation =
+              if ass.belongs_to?
+                relation.joins("LEFT JOIN #{association_quoted_table_name} ON #{association_quoted_table_name}.#{ass.association_primary_key} = #{quoted_table_name}.#{ass.association_foreign_key}")
+              else
+                relation.joins("LEFT JOIN #{association_quoted_table_name} ON #{association_quoted_table_name}.#{ass.foreign_key} = #{quoted_table_name}.#{primary_key}")
+              end
+          end
         end
 
-        relation = relation.
-          order('ts ' << (options[:reverse] ? 'DESC' : 'ASC'))
+        relation_order =
+          if options[:reverse]
+            'DESC'
+          else
+            'ASC'
+          end
+
+        relation = relation.order("ts #{relation_order}")
 
-        relation = relation.from(%["public".#{quoted_table_name}]) unless self.chrono?
+        relation = relation.from("public.#{quoted_table_name}") unless chrono?
         relation = relation.where(id: rid) if rid
 
-        sql = "SELECT ts FROM ( #{relation.to_sql} ) foo WHERE ts IS NOT NULL"
+        sql = "SELECT ts FROM ( #{relation.to_sql} ) AS foo WHERE ts IS NOT NULL".dup
 
         if options.key?(:before)
           sql << " AND ts < '#{Conversions.time_to_utc_string(options[:before])}'"
         end
 
         if options.key?(:after)
-          sql << " AND ts > '#{Conversions.time_to_utc_string(options[:after ])}'"
+          sql << " AND ts > '#{Conversions.time_to_utc_string(options[:after])}'"
         end
 
         if rid && !options[:with]
-          sql << (self.chrono? ? %{
-            AND ts <@ ( SELECT tsrange(min(lower(validity)), max(upper(validity)), '[]') FROM #{quoted_table_name} WHERE id = #{rid} )
-          } : %[ AND ts < NOW() ])
+          sql <<
+            if chrono?
+              %{ AND ts <@ ( SELECT tsrange(min(lower(validity)), max(upper(validity)), '[]') FROM #{quoted_table_name} WHERE id = #{rid} ) }
+            else
+              %[ AND ts < NOW() ]
+            end
         end
 
         sql << " LIMIT #{options[:limit].to_i}" if options.key?(:limit)
 
-        sql.gsub! 'INNER JOIN', 'LEFT OUTER JOIN'
-
         connection.on_schema(Adapter::HISTORY_SCHEMA) do
-          connection.select_values(sql, "#{self.name} periods").map! do |ts|
+          connection.select_values(sql, "#{name} periods").map! do |ts|
             Conversions.string_to_utc_time ts
           end
         end
@@ -74,21 +102,17 @@ module ChronoModel
       def timeline_associations_from(names)
         Array.wrap(names).map do |name|
           reflect_on_association(name) or raise ArgumentError,
-            "No association found for name `#{name}'"
+                                                "No association found for name `#{name}'"
         end
       end
 
       def quoted_history_fields
         @quoted_history_fields ||= begin
-          validity =
-            [connection.quote_table_name(table_name),
-             connection.quote_column_name('validity')
-            ].join('.')
+          validity = "#{quoted_table_name}.#{connection.quote_column_name('validity')}"
 
-          [:lower, :upper].map! {|func| "#{func}(#{validity})"}
+          %w[lower upper].map! { |func| "#{func}(#{validity})" }
         end
       end
     end
-
   end
 end