logidze 0.9.0 → 1.0.0

data/lib/generators/logidze/install/templates/migration_fx.rb.erb

@@ -0,0 +1,41 @@
+class <%= @migration_class_name %> < ActiveRecord::Migration[5.0]
+  def change
+  <%- if update? -%>
+    reversible do |dir|
+      dir.up do
+        # Drop legacy functions (<1.0)
+        execute <<~SQL
+          DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb);
+          DROP FUNCTION IF EXISTS logidze_snapshot(jsonb);
+          DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb, text[]);
+          DROP FUNCTION IF EXISTS logidze_snapshot(jsonb, text[]);
+          DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb, timestamp with time zone, text[]);
+          DROP FUNCTION IF EXISTS logidze_snapshot(jsonb, text, text[]);
+          DROP FUNCTION IF EXISTS logidze_exclude_keys(jsonb, VARIADIC text[]);
+          DROP FUNCTION IF EXISTS logidze_compact_history(jsonb);
+        SQL
+      end
+    end
+
+  <%- end -%>
+  <%- function_definitions.each do |f| -%>
+    <%- previous_version = previous_version_for(f.name) -%>
+    <%- if previous_version -%>
+      <%- if previous_version != f.version -%>
+    update_function :<%= f.name %>, version: <%= f.version %>, revert_to_version: <%= previous_version %>
+      <%- end -%>
+    <%- else -%>
+    reversible do |dir|
+      dir.up do
+        create_function :<%= f.name %>, version: <%= f.version %>
+      end
+
+      dir.down do
+        execute "DROP FUNCTION IF EXISTS <%= f.name %>(<%= f.signature %>) CASCADE"
+      end
+    end
+
+    <%- end -%>
+  <%- end -%>
+  end
+end

data/lib/generators/logidze/model/model_generator.rb

@@ -1,12 +1,20 @@
-# rubocop:disable Metrics/BlockLength
 # frozen_string_literal: true
+
 require "rails/generators"
 require "rails/generators/active_record/migration/migration_generator"
+require_relative "../inject_sql"
+require_relative "../fx_helper"
+
+using RubyNext
 
 module Logidze
   module Generators
     class ModelGenerator < ::ActiveRecord::Generators::Base # :nodoc:
-      source_root File.expand_path('templates', __dir__)
+      include InjectSql
+      include FxHelper
+
+      source_root File.expand_path("templates", __dir__)
+      source_paths << File.expand_path("triggers", __dir__)
 
       class_option :limit, type: :numeric, optional: true, desc: "Specify history size limit"
 
@@ -21,23 +29,31 @@ module Logidze
 
       class_option :path, type: :string, optional: true, desc: "Specify path to the model file"
 
-      class_option :blacklist, type: :array, optional: true
-      class_option :whitelist, type: :array, optional: true
+      class_option :except, type: :array, optional: true
+      class_option :only, type: :array, optional: true
 
       class_option :timestamp_column, type: :string, optional: true,
                                       desc: "Specify timestamp column"
 
+      class_option :name, type: :string, optional: true, desc: "Migration name"
+
       class_option :update, type: :boolean, optional: true,
                             desc: "Define whether this is an update migration"
 
       def generate_migration
-        if options[:blacklist] && options[:whitelist]
-          warn "Use only one: --whitelist or --blacklist"
+        if options[:except] && options[:only]
+          warn "Use only one: --only or --except"
           exit(1)
         end
         migration_template "migration.rb.erb", "db/migrate/#{migration_file_name}"
       end
 
+      def generate_fx_trigger
+        return unless fx?
+
+        template "logidze.sql", "db/triggers/logidze_on_#{table_name}_v#{next_version.to_s.rjust(2, "0")}.sql"
+      end
+
       def inject_logidze_to_model
         return if update?
 
@@ -48,6 +64,8 @@ module Logidze
 
       no_tasks do
         def migration_name
+          return options[:name] if options[:name].present?
+
           if update?
             "update_logidze_for_#{plural_table_name}"
           else
@@ -75,19 +93,18 @@ module Logidze
           options[:update]
         end
 
-        def columns_blacklist
-          array = if !options[:whitelist]
-                    options[:blacklist]
-                  else
-                    class_name.constantize.column_names - options[:whitelist]
-                  end
+        def filtered_columns
+          format_pgsql_array(options[:only] || options[:except])
+        end
 
-          format_pgsql_array(array)
+        def include_columns
+          return unless options[:only] || options[:except]
+          options[:only].present?
         end
 
         def timestamp_column
-          value = options[:timestamp_column] || 'updated_at'
-          return if %w(nil null false).include?(value)
+          value = options[:timestamp_column] || "updated_at"
+          return if %w[nil null false].include?(value)
 
           escape_pgsql_string(value)
         end
@@ -96,18 +113,41 @@ module Logidze
           options[:debounce_time]
         end
 
+        def previous_version
+          @previous_version ||= all_triggers.filter_map { |path| Regexp.last_match[1].to_i if path =~ %r{logidze_on_#{table_name}_v(\d+).sql} }.max
+        end
+
+        def next_version
+          previous_version&.next || 1
+        end
+
+        def all_triggers
+          @all_triggers ||=
+            begin
+              res = nil
+              in_root do
+                res = if File.directory?("db/triggers")
+                  Dir.entries("db/triggers")
+                else
+                  []
+                end
+              end
+              res
+            end
+        end
+
         def logidze_logger_parameters
-          format_pgsql_args(limit, timestamp_column, columns_blacklist, debounce_time)
+          format_pgsql_args(limit, timestamp_column, filtered_columns, include_columns, debounce_time)
         end
 
         def logidze_snapshot_parameters
-          format_pgsql_args('to_jsonb(t)', timestamp_column, columns_blacklist)
+          format_pgsql_args("to_jsonb(t)", timestamp_column, filtered_columns, include_columns)
         end
 
         def format_pgsql_array(ruby_array)
           return if ruby_array.blank?
 
-          "'{" + ruby_array.join(', ') + "}'"
+          "'{" + ruby_array.join(", ") + "}'"
         end
 
         def escape_pgsql_string(string)
@@ -124,10 +164,10 @@ module Logidze
         def format_pgsql_args(*values)
           args = []
           values.reverse_each do |value|
-            formatted_value = value.presence || (args.any? && 'null')
+            formatted_value = value.presence || (args.any? && "null")
             args << formatted_value if formatted_value
           end
-          args.compact.reverse.join(', ')
+          args.compact.reverse.join(", ")
         end
       end
 

data/lib/generators/logidze/model/templates/migration.rb.erb

@@ -1,43 +1,64 @@
-class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
-  require 'logidze/migration'
-  include Logidze::Migration
-
-  def up
-    <% if update? %>
-    execute "DROP TRIGGER logidze_on_<%= table_name %> on <%= table_name %>;"
-    <% elsif !only_trigger? %>
+class <%= @migration_class_name %> < ActiveRecord::Migration[5.0]
+  def change
+<%- unless update? || only_trigger? -%>
     add_column :<%= table_name %>, :log_data, :jsonb
-    <% end %>
+<%- end -%>
 
-    execute <<-SQL
-      CREATE TRIGGER logidze_on_<%= table_name %>
-      BEFORE UPDATE OR INSERT ON <%= table_name %> FOR EACH ROW
-      WHEN (coalesce(#{current_setting('logidze.disabled')}, '') <> 'on')
-      EXECUTE PROCEDURE logidze_logger(<%= logidze_logger_parameters %>);
-    SQL
+<%- if fx? -%>
+  <%- if previous_version -%>
+    update_trigger :logidze_on_<%= table_name %>, on: :<%= table_name %>, version: <%= next_version %>, revert_to_version: <%= previous_version %>
+  <%- else -%>
+    reversible do |dir|
+      dir.up do
+    <%- if update? -%>
+        # Drop legacy trigger if any (<1.0)
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
 
-    <% if backfill? %>
-    execute <<-SQL
-      UPDATE <%= table_name %> as t
-      SET log_data = logidze_snapshot(<%= logidze_snapshot_parameters %>);
-    SQL
-    <% end %>
-  end
+    <%- end -%>
+        create_trigger :logidze_on_<%= table_name %>, on: :<%= table_name %>
+      end
+
+      dir.down do
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+      end
+    end
+  <%- end -%>
+<%- else -%>
+    reversible do |dir|
+      dir.up do
+  <%- if update? -%>
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+
+  <%- end -%>
+        execute <<~SQL
+<%= inject_sql("logidze.sql", indent: 10) %>
+        SQL
+      end
 
-  def down
-    <% if update? %>
-    # NOTE: We have no idea on how to revert the migration
-    # ('cause we don't know the previous trigger params),
-    # but you can do that on your own.
-    # 
-    # Uncomment this line if you want to raise an error.
-    # raise ActiveRecord::IrreversibleMigration
-    <% else %>
-    execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+      dir.down do
+  <%- if update? -%>
+        # NOTE: We have no idea on how to revert the migration
+        # ('cause we don't know the previous trigger params),
+        # but you can do that on your own.
+        #
+        # Uncomment this line if you want to raise an error.
+        # raise ActiveRecord::IrreversibleMigration
+  <%- else -%>
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+  <%- end -%>
+      end
+    end
+<%- end -%>
+<%- if backfill? -%>
 
-    <% if !only_trigger? %>
-    remove_column :<%= table_name %>, :log_data
-    <% end %>
-    <% end %>
+    reversible do |dir|
+      dir.up do
+        execute <<~SQL
+          UPDATE <%= table_name %> as t
+          SET log_data = logidze_snapshot(<%= logidze_snapshot_parameters %>);
+        SQL
+      end
+    end
+<%- end -%>
   end
 end

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

@@ -1,40 +1,62 @@
 # frozen_string_literal: true
+
 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 'logidze/history'
-  require 'logidze/model'
-  require 'logidze/versioned_association'
-  require 'logidze/ignore_log_data'
-  require 'logidze/has_logidze'
-  require 'logidze/meta'
+  require "ruby-next"
+  require "logidze/history"
+  require "logidze/model"
+  require "logidze/versioned_association"
+  require "logidze/ignore_log_data"
+  require "logidze/has_logidze"
+  require "logidze/meta"
 
   extend Logidze::Meta
 
-  require 'logidze/engine' if defined?(Rails)
+  require "logidze/engine" if defined?(Rails)
 
   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
+    # Determines whether associations versioning is enabled or not
+    attr_accessor :associations_versioning
+    # Determines if Logidze should exclude log data from SELECT statements
+    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
 
-    def associations_versioning
-      @associations_versioning || false
+    # Temporary disable DB triggers.
+    #
+    # @example
+    #   Logidze.without_logging { Post.update_all(active: true) }
+    def without_logging
+      with_logidze_setting("logidze.disabled", "on") { yield }
     end
-  end
 
-  # Temporary disable DB triggers.
-  #
-  # @example
-  #   Logidze.without_logging { Post.update_all(active: true) }
-  def self.without_logging
-    ActiveRecord::Base.transaction do
-      ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO on;"
-      res = yield
-      ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO DEFAULT;"
-      res
+    # Instructure 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
+
+    private
+
+    def with_logidze_setting(name, value)
+      ActiveRecord::Base.transaction do
+        ActiveRecord::Base.connection.execute "SET LOCAL #{name} TO #{value};"
+        res = yield
+        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
 end

data/lib/logidze/engine.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
-require 'logidze'
+
+require "logidze"
 
 module Logidze
   class Engine < Rails::Engine # :nodoc:
+    config.logidze = Logidze
+
     initializer "extend ActiveRecord with Logidze" do |_app|
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Base.send :include, Logidze::HasLogidze

data/lib/logidze/has_logidze.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'active_support'
+
+require "active_support"
 
 module Logidze
   # Add `has_logidze` method to AR::Base
@@ -9,10 +10,17 @@ module Logidze
     module ClassMethods # :nodoc:
       # Include methods to work with history.
       #
-      # rubocop:disable Naming/PredicateName
-      def has_logidze(ignore_log_data: false)
+      def has_logidze(ignore_log_data: Logidze.ignore_log_data_by_default)
+        include Logidze::IgnoreLogData
         include Logidze::Model
-        include Logidze::IgnoreLogData if ignore_log_data
+
+        @ignore_log_data = ignore_log_data
+
+        self.ignored_columns += ["log_data"] if @ignore_log_data
+      end
+
+      def ignores_log_data?
+        @ignore_log_data
       end
     end
   end

data/lib/logidze/history.rb

@@ -1,30 +1,22 @@
 # frozen_string_literal: true
-require 'active_support/core_ext/module/delegation'
+
+require "active_support/core_ext/module/delegation"
 
 module Logidze
   # Log data wrapper
   class History
-    require 'logidze/history/version'
+    require "logidze/history/version"
 
     # History key
-    HISTORY = 'h'
+    HISTORY = "h"
     # Version key
-    VERSION = 'v'
+    VERSION = "v"
 
     attr_reader :data
 
     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
@@ -107,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
@@ -128,7 +120,7 @@ module Logidze
 
     def build_changes(a, b)
       b.each_with_object({}) do |(k, v), acc|
-        acc[k] = { "old" => a[k], "new" => v } unless v == a[k]
+        acc[k] = {"old" => a[k], "new" => v} unless v == a[k]
       end
     end