chrono_model 1.2.2 → 3.0.1

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"
 
         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

data/lib/chrono_model/time_machine.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'chrono_model/time_machine/time_query'
 require 'chrono_model/time_machine/timeline'
 require 'chrono_model/time_machine/history_model'
 
 module ChronoModel
-
   module TimeMachine
     include ChronoModel::Patches::AsOfTimeHolder
 
@@ -11,20 +12,41 @@ module ChronoModel
 
     included do
       if table_exists? && !chrono?
-        puts  "ChronoModel: #{table_name} is not a temporal table. " \
-          "Please use `change_table :#{table_name}, temporal: true` in a migration."
+        logger.warn <<-MSG.squish
+          ChronoModel: #{table_name} is not a temporal table.
+          Please use `change_table :#{table_name}, temporal: true` in a migration.
+        MSG
       end
 
       history = ChronoModel::TimeMachine.define_history_model_for(self)
       ChronoModel.history_models[table_name] = history
 
       class << self
-        alias_method :direct_descendants_with_history, :direct_descendants
-        def direct_descendants
-          direct_descendants_with_history.reject(&:history?)
+        def subclasses(with_history: false)
+          subclasses = super()
+          subclasses.reject!(&:history?) unless with_history
+          subclasses
+        end
+
+        def subclasses_with_history
+          subclasses(with_history: true)
+        end
+
+        # `direct_descendants` is deprecated method in 7.0 and has been
+        # removed in 7.1
+        if method_defined?(:direct_descendants)
+          alias_method :direct_descendants_with_history, :subclasses_with_history
+          alias_method :direct_descendants, :subclasses
+        end
+
+        # Ruby 3.1 has a native subclasses method and descendants is
+        # implemented with recursion of subclasses
+        if Class.method_defined?(:subclasses)
+          def descendants_with_history
+            subclasses_with_history.concat(subclasses.flat_map(&:descendants_with_history))
+          end
         end
 
-        alias_method :descendants_with_history, :descendants
         def descendants
           descendants_with_history.reject(&:history?)
         end
@@ -43,9 +65,9 @@ module ChronoModel
           # Sadly, we can't avoid it by calling +.history?+, because in the
           # subclass the HistoryModel hasn't been included yet.
           #
-          unless subclass.name.nil?
-            ChronoModel::TimeMachine.define_history_model_for(subclass)
-          end
+          return if subclass.name.nil?
+
+          ChronoModel::TimeMachine.define_history_model_for(subclass)
         end
       end
     end
@@ -71,21 +93,23 @@ module ChronoModel
 
       # Returns an ActiveRecord::Relation on the history of this model as
       # it was +time+ ago.
-      def as_of(time)
-        history.as_of(time)
-      end
+      delegate :as_of, to: :history
 
       def attribute_names_for_history_changes
         @attribute_names_for_history_changes ||= attribute_names -
-          %w( id hid validity recorded_at )
+                                                 %w[id hid validity recorded_at]
       end
 
       def has_timeline(options)
         changes = options.delete(:changes)
         assocs  = history.has_timeline(options)
 
-        attributes = changes.present? ?
-          Array.wrap(changes) : assocs.map(&:name)
+        attributes =
+          if changes.present?
+            Array.wrap(changes)
+          else
+            assocs.map(&:name)
+          end
 
         attribute_names_for_history_changes.concat(attributes.map(&:to_s))
       end
@@ -112,7 +136,7 @@ module ChronoModel
     # reasons, to avoid a `rescue` (@lleirborras).
     #
     def _as_of(time)
-      self.class.as_of(time).where(id: self.id)
+      self.class.as_of(time).where(id: id)
     end
     protected :_as_of
 
@@ -132,13 +156,14 @@ module ChronoModel
     # Returns a boolean indicating whether this record is an history entry.
     #
     def historical?
-      self.as_of_time.present?
+      as_of_time.present?
     end
 
     # Inhibit destroy of historical records
     #
     def destroy
       raise ActiveRecord::ReadOnlyRecord, 'Cannot delete historical records' if historical?
+
       super
     end
 
@@ -147,7 +172,7 @@ module ChronoModel
     #
     def pred(options = {})
       if self.class.timeline_associations.empty?
-        history.order(Arel.sql('upper(validity) DESC')).offset(1).first
+        history.reverse_order.second
       else
         return nil unless (ts = pred_timestamp(options))
 
@@ -178,7 +203,11 @@ module ChronoModel
     # Returns the current history version
     #
     def current_version
-      self.historical? ? self.class.find(self.id) : self
+      if historical?
+        self.class.find(id)
+      else
+        self
+      end
     end
 
     # Returns the differences between this entry and the previous history one.
@@ -196,17 +225,20 @@ module ChronoModel
     #
     def changes_against(ref)
       self.class.attribute_names_for_history_changes.inject({}) do |changes, attr|
-        old, new = ref.public_send(attr), self.public_send(attr)
+        old = ref.public_send(attr)
+        new = public_send(attr)
 
         changes.tap do |c|
-          changed = old.respond_to?(:history_eql?) ?
-            !old.history_eql?(new) : old != new
+          changed =
+            if old.respond_to?(:history_eql?)
+              !old.history_eql?(new)
+            else
+              old != new
+            end
 
           c[attr] = [old, new] if changed
         end
       end
     end
-
   end
-
 end

data/lib/chrono_model/utilities.rb

@@ -1,5 +1,6 @@
-module ChronoModel
+# frozen_string_literal: true
 
+module ChronoModel
   module Utilities
     # Amends the given history item setting a different period.
     # Useful when migrating from legacy systems.
@@ -11,7 +12,7 @@ module ChronoModel
     #   end
     #
     def amend_period!(hid, from, to)
-      unless [from, to].any? {|ts| ts.respond_to?(:zone) && ts.zone == 'UTC'}
+      unless [from, to].any? { |ts| ts.respond_to?(:zone) && ts.zone == 'UTC' }
         raise 'Can amend history only with UTC timestamps'
       end
 
@@ -23,5 +24,4 @@ module ChronoModel
       ]
     end
   end
-
 end

data/lib/chrono_model/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ChronoModel
-  VERSION = "1.2.2"
+  VERSION = '3.0.1'
 end