logidze 0.11.0 → 1.2.0

data/lib/generators/logidze/model/triggers/logidze.sql

@@ -0,0 +1,6 @@
+CREATE TRIGGER logidze_on_<%= table_name %>
+BEFORE UPDATE OR INSERT ON <%= table_name %> FOR EACH ROW
+WHEN (coalesce(current_setting('logidze.disabled', true), '') <> 'on')
+-- Parameters: history_size_limit (integer), timestamp_column (text), filtered_columns (text[]),
+-- include_columns (boolean), debounce_time_ms (integer)
+EXECUTE PROCEDURE logidze_logger(<%= logidze_logger_parameters %>);

data/lib/logidze.rb

@@ -5,6 +5,7 @@ require "logidze/version"
 # Logidze provides tools for adding in-table JSON-based audit to DB tables
 # and ActiveRecord extensions to work with changes history.
 module Logidze
+  require "ruby-next"
   require "logidze/history"
   require "logidze/model"
   require "logidze/versioned_association"
@@ -19,31 +20,53 @@ module Logidze
   class << self
     # Determines if Logidze should append a version to the log after updating an old version.
     attr_accessor :append_on_undo
-
-    attr_writer :associations_versioning
-
-    def associations_versioning
-      @associations_versioning || false
-    end
-
+    # Determines whether associations versioning is enabled or not
+    attr_accessor :associations_versioning
     # Determines if Logidze should exclude log data from SELECT statements
-    attr_writer :ignore_log_data_by_default
-
-    def ignore_log_data_by_default
-      @ignore_log_data_by_default || false
-    end
+    attr_accessor :ignore_log_data_by_default
+    # Whether #at should return self or nil when log_data is nil
+    attr_accessor :return_self_if_log_data_is_empty
+    # Determines what Logidze should do when upgrade is needed (:raise | :warn | :ignore)
+    attr_reader :on_pending_upgrade
 
     # Temporary disable DB triggers.
     #
     # @example
     #   Logidze.without_logging { Post.update_all(active: true) }
     def without_logging
+      with_logidze_setting("logidze.disabled", "on") { yield }
+    end
+
+    # Instruct Logidze to create a full snapshot for the new versions, not a diff
+    #
+    # @example
+    #   Logidze.with_full_snapshot { post.touch }
+    def with_full_snapshot
+      with_logidze_setting("logidze.full_snapshot", "on") { yield }
+    end
+
+    def on_pending_upgrade=(mode)
+      if %i[raise warn ignore].exclude? mode
+        raise ArgumentError, "Unknown on_pending_upgrade option `#{mode.inspect}`. Expecting :raise, :warn or :ignore"
+      end
+      @on_pending_upgrade = mode
+    end
+
+    private
+
+    def with_logidze_setting(name, value)
       ActiveRecord::Base.transaction do
-        ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO on;"
+        ActiveRecord::Base.connection.execute "SET LOCAL #{name} TO #{value};"
         res = yield
-        ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO DEFAULT;"
+        ActiveRecord::Base.connection.execute "SET LOCAL #{name} TO DEFAULT;"
         res
       end
     end
   end
+
+  self.append_on_undo = false
+  self.associations_versioning = false
+  self.ignore_log_data_by_default = false
+  self.return_self_if_log_data_is_empty = true
+  self.on_pending_upgrade = :ignore
 end

data/lib/logidze/engine.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "logidze"
+require "logidze/utils/check_pending"
 
 module Logidze
   class Engine < Rails::Engine # :nodoc:
@@ -11,5 +12,13 @@ module Logidze
         ActiveRecord::Base.send :include, Logidze::HasLogidze
       end
     end
+
+    initializer "check Logidze function versions" do |app|
+      if config.logidze.on_pending_upgrade != :ignore
+        ActiveSupport.on_load(:active_record) do
+          app.config.app_middleware.use Logidze::Utils::CheckPending
+        end
+      end
+    end
   end
 end

data/lib/logidze/has_logidze.rb

@@ -11,8 +11,8 @@ module Logidze
       # Include methods to work with history.
       #
       def has_logidze(ignore_log_data: Logidze.ignore_log_data_by_default)
-        include Logidze::Model
         include Logidze::IgnoreLogData
+        include Logidze::Model
 
         @ignore_log_data = ignore_log_data
 

data/lib/logidze/history.rb

@@ -17,15 +17,6 @@ module Logidze
     delegate :size, to: :versions
     delegate :responsible_id, :meta, to: :current_version
 
-    ### Rails 4 ###
-    def self.dump(object)
-      ActiveSupport::JSON.encode(object)
-    end
-
-    def self.load(json)
-      new(json) if json.present?
-    end
-
     def initialize(data)
       @data = data
     end
@@ -57,7 +48,7 @@ module Logidze
     end
 
     # Return diff from the initial state to specified time or version.
-    # Optional `data` paramater can be used as initial diff state.
+    # Optional `data` parameter can be used as initial diff state.
     def changes_to(time: nil, version: nil, data: {}, from: 0)
       raise ArgumentError, "Time or version must be specified" if time.nil? && version.nil?
 
@@ -108,7 +99,7 @@ module Logidze
 
     # Return nearest (from the bottom) version to the specified time
     def find_by_time(time)
-      versions.reverse.find { |v| v.time <= time }
+      versions.reverse_each.find { |v| v.time <= time }
     end
 
     def dup

data/lib/logidze/ignore_log_data.rb

@@ -5,9 +5,7 @@ module Logidze
     extend ActiveSupport::Concern
 
     included do
-      if Rails::VERSION::MAJOR == 4
-        require "logidze/ignore_log_data/ignored_columns"
-      elsif Rails::VERSION::MAJOR == 5
+      if Rails::VERSION::MAJOR == 5
         require "logidze/ignore_log_data/cast_attribute_patch"
         include CastAttributePatch
       end

data/lib/logidze/meta.rb

@@ -3,18 +3,19 @@
 module Logidze # :nodoc:
   # Provide methods to attach meta information
   module Meta
-    def with_meta(meta, &block)
-      MetaTransaction.wrap_with(meta, &block)
+    def with_meta(meta, transactional: true, &block)
+      wrapper = transactional ? MetaWithTransaction : MetaWithoutTransaction
+      wrapper.wrap_with(meta, &block)
     end
 
-    def with_responsible(responsible_id, &block)
+    def with_responsible(responsible_id, transactional: true, &block)
       return yield if responsible_id.nil?
 
       meta = {Logidze::History::Version::META_RESPONSIBLE => responsible_id}
-      with_meta(meta, &block)
+      with_meta(meta, transactional: transactional, &block)
     end
 
-    class MetaTransaction # :nodoc:
+    class MetaWrapper # :nodoc:
       def self.wrap_with(meta, &block)
         new(meta, &block).perform
       end
@@ -29,14 +30,12 @@ module Logidze # :nodoc:
       end
 
       def perform
-        return if block.nil?
+        raise ArgumentError, "Block must be given" unless block
         return block.call if meta.nil?
 
-        ActiveRecord::Base.transaction { call_block_in_meta_context }
+        call_block_in_meta_context
       end
 
-      private
-
       def call_block_in_meta_context
         prev_meta = current_meta
 
@@ -44,10 +43,9 @@ module Logidze # :nodoc:
 
         pg_set_meta_param(current_meta)
         result = block.call
-        pg_reset_meta_param(prev_meta)
-
         result
       ensure
+        pg_reset_meta_param(prev_meta)
         meta_stack.pop
       end
 
@@ -60,20 +58,49 @@ module Logidze # :nodoc:
         Thread.current[:meta]
       end
 
-      def pg_set_meta_param(value)
-        encoded_meta = connection.quote(ActiveSupport::JSON.encode(value))
-        connection.execute("SET LOCAL logidze.meta = #{encoded_meta};")
+      def encode_meta(value)
+        connection.quote(ActiveSupport::JSON.encode(value))
       end
 
       def pg_reset_meta_param(prev_meta)
         if prev_meta.empty?
-          connection.execute("SET LOCAL logidze.meta TO DEFAULT;")
+          pg_clear_meta_param
         else
           pg_set_meta_param(prev_meta)
         end
       end
     end
 
-    private_constant :MetaTransaction
+    class MetaWithTransaction < MetaWrapper # :nodoc:
+      private
+
+      def call_block_in_meta_context
+        connection.transaction { super }
+      end
+
+      def pg_set_meta_param(value)
+        connection.execute("SET LOCAL logidze.meta = #{encode_meta(value)};")
+      end
+
+      def pg_clear_meta_param
+        connection.execute("SET LOCAL logidze.meta TO DEFAULT;")
+      end
+    end
+
+    class MetaWithoutTransaction < MetaWrapper # :nodoc:
+      private
+
+      def pg_set_meta_param(value)
+        connection.execute("SET logidze.meta = #{encode_meta(value)};")
+      end
+
+      def pg_clear_meta_param
+        connection.execute("SET logidze.meta TO DEFAULT;")
+      end
+    end
+
+    private_constant :MetaWrapper
+    private_constant :MetaWithTransaction
+    private_constant :MetaWithoutTransaction
   end
 end

data/lib/logidze/model.rb

@@ -3,43 +3,28 @@
 require "active_support"
 
 module Logidze
-  module Deprecations # :nodoc:
-    def self.show_ts_deprecation_for(meth)
-      warn(
-        "[Deprecation] Usage of #{meth}(time) will be removed in the future releases, "\
-        "use #{meth}(time: ts) instead"
-      )
-    end
-  end
+  using RubyNext
 
   # Extends model with methods to browse history
   module Model
-    require "logidze/history/type" if Rails::VERSION::MAJOR >= 5
+    require "logidze/history/type"
 
     extend ActiveSupport::Concern
 
     included do
-      if Rails::VERSION::MAJOR < 5
-        serialize :log_data, Logidze::History
-      else
-        attribute :log_data, Logidze::History::Type.new
-      end
+      attribute :log_data, Logidze::History::Type.new
 
       delegate :version, to: :log_data, prefix: "log"
     end
 
     module ClassMethods # :nodoc:
       # Return records reverted to specified time
-      def at(ts = nil, time: nil, version: nil)
-        Deprecations.show_ts_deprecation_for(".at") if ts
-        time ||= ts
-        all.map { |record| record.at(time: time, version: version) }.compact
+      def at(time: nil, version: nil)
+        all.to_a.filter_map { |record| record.at(time: time, version: version) }
       end
 
       # Return changes made to records since specified time
-      def diff_from(ts = nil, time: nil, version: nil)
-        Deprecations.show_ts_deprecation_for(".diff_from") if ts
-        time ||= ts
+      def diff_from(time: nil, version: nil)
         all.map { |record| record.diff_from(time: time, version: version) }
       end
 
@@ -58,6 +43,28 @@ module Logidze
       def reset_log_data
         without_logging { update_all(log_data: nil) }
       end
+
+      # Initialize log_data with the current state if it's null
+      def create_logidze_snapshot(timestamp: nil, only: nil, except: nil)
+        args = ["'null'"]
+
+        args[0] = "'#{timestamp}'" if timestamp
+
+        columns = only || except
+
+        if columns
+          args[1] = "'{#{columns.join(",")}}'"
+          args[2] = only ? "true" : "false"
+        end
+
+        without_logging do
+          where(log_data: nil).update_all(
+            <<~SQL
+              log_data = logidze_snapshot(to_jsonb(#{quoted_table_name}), #{args.join(", ")})
+            SQL
+          )
+        end
+      end
     end
 
     # Use this to convert Ruby time to milliseconds
@@ -69,14 +76,15 @@ module Logidze
     # If time/version is less then the first version, then return nil.
     # If time/version is greater then the last version, then return self.
     # rubocop: disable Metrics/MethodLength
-    def at(ts = nil, time: nil, version: nil)
-      Deprecations.show_ts_deprecation_for("#at") if ts
-
+    def at(time: nil, version: nil)
       return at_version(version) if version
 
-      time ||= ts
       time = parse_time(time)
 
+      unless log_data
+        return Logidze.return_self_if_log_data_is_empty ? self : nil
+      end
+
       return nil unless log_data.exists_ts?(time)
 
       if log_data.current_ts?(time)
@@ -91,12 +99,11 @@ module Logidze
     # rubocop: enable Metrics/MethodLength
 
     # Revert record to the version at specified time (without saving to DB)
-    def at!(ts = nil, time: nil, version: nil)
-      Deprecations.show_ts_deprecation_for("#at!") if ts
-
+    def at!(time: nil, version: nil)
       return at_version!(version) if version
 
-      time ||= ts
+      raise ArgumentError, "#log_data is empty" unless log_data
+
       time = parse_time(time)
 
       return self if log_data.current_ts?(time)
@@ -119,6 +126,8 @@ module Logidze
 
     # Revert record to the specified version (without saving to DB)
     def at_version!(version)
+      raise ArgumentError, "#log_data is empty" unless log_data
+
       return self if log_data.version == version
       return false unless log_data.find_by_version(version)
 
@@ -131,13 +140,11 @@ module Logidze
     #
     #   post.diff_from(time: 2.days.ago) # or post.diff_from(version: 2)
     #   #=> { "id" => 1, "changes" => { "title" => { "old" => "Hello!", "new" => "World" } } }
-    def diff_from(ts = nil, version: nil, time: nil)
-      Deprecations.show_ts_deprecation_for("#diff_from") if ts
-      time ||= ts
+    def diff_from(version: nil, time: nil)
       time = parse_time(time) if time
-      changes = log_data.diff_from(time: time, version: version).tap do |v|
+      changes = log_data&.diff_from(time: time, version: version)&.tap do |v|
         deserialize_changes!(v)
-      end
+      end || {}
 
       changes.delete_if { |k, _v| deleted_column?(k) }
 
@@ -206,7 +213,7 @@ module Logidze
 
     # Loads log_data field from the database, stores to the attributes hash and returns it
     def reload_log_data
-      self.log_data = self.class.where(self.class.primary_key => id).pluck(:log_data).first
+      self.log_data = self.class.where(self.class.primary_key => id).pluck("#{self.class.table_name}.log_data").first
     end
 
     # Nullify log_data column for a single record
@@ -214,6 +221,12 @@ module Logidze
       self.class.without_logging { update_column(:log_data, nil) }
     end
 
+    def create_logidze_snapshot!(**opts)
+      self.class.where(self.class.primary_key => id).create_logidze_snapshot(**opts)
+
+      reload_log_data
+    end
+
     protected
 
     def apply_diff(version, diff)
@@ -226,7 +239,7 @@ module Logidze
     end
 
     def apply_column_diff(column, value)
-      return if deleted_column?(column)
+      return if deleted_column?(column) || column == "log_data"
 
       write_attribute column, deserialize_value(column, value)
     end
@@ -240,14 +253,8 @@ module Logidze
       object_at
     end
 
-    if Rails::VERSION::MAJOR < 5
-      def deserialize_value(column, value)
-        @attributes[column].type.type_cast_from_database(value)
-      end
-    else
-      def deserialize_value(column, value)
-        @attributes[column].type.deserialize(value)
-      end
+    def deserialize_value(column, value)
+      @attributes[column].type.deserialize(value)
     end
 
     def deleted_column?(column)