hoardable 0.14.2 → 0.16.0

data/lib/generators/hoardable/install_generator.rb

@@ -1,47 +1,46 @@
 # frozen_string_literal: true
 
-require 'rails/generators'
+require "rails/generators"
 
 module Hoardable
   # Generates an initializer file for {Hoardable} configuration and a migration with a PostgreSQL
   # function.
   class InstallGenerator < Rails::Generators::Base
-    source_root File.expand_path('templates', __dir__)
+    source_root File.expand_path("templates", __dir__)
     include Rails::Generators::Migration
-    delegate :supports_schema_enums?, to: :class
 
     def create_initializer_file
-      create_file(
-        'config/initializers/hoardable.rb',
-        <<~TEXT
-          # Hoardable configuration defaults are below. Learn more at https://github.com/waymondo/hoardable#configuration
-          #
-          # Hoardable.enabled = true
-          # Hoardable.version_updates = true
-          # Hoardable.save_trash = true
-        TEXT
-      )
-    end
-
-    def change_schema_format_to_sql
-      return if supports_schema_enums?
-
-      application 'config.active_record.schema_format = :sql'
+      create_file("config/initializers/hoardable.rb", <<~TEXT)
+        # Hoardable configuration defaults are below. Learn more at https://github.com/waymondo/hoardable#configuration
+        #
+        # Hoardable.enabled = true
+        # Hoardable.version_updates = true
+        # Hoardable.save_trash = true
+      TEXT
     end
 
     def create_migration_file
-      migration_template 'install.rb.erb', 'db/migrate/install_hoardable.rb'
+      migration_template "install.rb.erb", "db/migrate/install_hoardable.rb"
     end
 
     def create_functions
-      Dir.glob(File.join(__dir__, 'functions', '*.sql')).each do |file_path|
-        file_name = file_path.match(%r{([^/]+)\.sql})[1]
-        template file_path, "db/functions/#{file_name}_v01.sql"
-      end
+      Dir
+        .glob(File.join(__dir__, "functions", "*.sql"))
+        .each do |file_path|
+          file_name = file_path.match(%r{([^/]+)\.sql})[1]
+          template file_path, "db/functions/#{file_name}_v01.sql"
+        end
     end
 
-    def self.supports_schema_enums?
-      ActiveRecord.version >= ::Gem::Version.new('7.0.0')
+    no_tasks do
+      def postgres_version
+        ActiveRecord::Base
+          .connection
+          .select_value("SELECT VERSION()")
+          .match(/[0-9]{1,2}([,.][0-9]{1,2})?/)[
+          0
+        ].to_f
+      end
     end
 
     def self.next_migration_number(dir)

data/lib/generators/hoardable/migration_generator.rb

@@ -1,23 +1,26 @@
 # frozen_string_literal: true
 
-require 'rails/generators'
-require 'rails/generators/active_record/migration/migration_generator'
+require "rails/generators"
+require "rails/generators/active_record/migration/migration_generator"
 
 module Hoardable
   # Generates a migration to create an inherited uni-temporal table of a model including
   # {Hoardable::Model}, for the storage of +versions+.
   class MigrationGenerator < ActiveRecord::Generators::Base
-    source_root File.expand_path('templates', __dir__)
+    source_root File.expand_path("templates", __dir__)
     include Rails::Generators::Migration
     class_option(
       :foreign_key_type,
       type: :string,
       optional: true,
-      desc: 'explictly set / override the foreign key type of the versions table'
+      desc: "explictly set / override the foreign key type of the versions table"
     )
 
     def create_versions_table
-      migration_template 'migration.rb.erb', "db/migrate/create_#{singularized_table_name}_versions.rb"
+      migration_template(
+        "migration.rb.erb",
+        "db/migrate/create_#{singularized_table_name}_versions.rb"
+      )
     end
 
     def create_triggers
@@ -34,17 +37,23 @@ module Hoardable
     end
 
     no_tasks do
+      def table_name
+        class_name.singularize.constantize.table_name
+      rescue StandardError
+        super
+      end
+
       def foreign_key_type
         options[:foreign_key_type] ||
-          class_name.singularize.constantize.columns.find { |col| col.name == 'id' }.sql_type
+          class_name.singularize.constantize.columns.find { |col| col.name == primary_key }.sql_type
       rescue StandardError
-        'bigint'
+        "bigint"
       end
 
       def primary_key
         options[:primary_key] || class_name.singularize.constantize.primary_key
       rescue StandardError
-        'id'
+        "id"
       end
 
       def singularized_table_name

data/lib/generators/hoardable/templates/install.rb.erb

@@ -2,33 +2,10 @@
 
 class InstallHoardable < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-    create_function :hoardable_prevent_update_id
+    <% if postgres_version < 13 %>enable_extension :pgcrypto
+    <% end %>create_function :hoardable_prevent_update_id
     create_function :hoardable_source_set_id
     create_function :hoardable_version_prevent_update
-    <% if supports_schema_enums? %>
     create_enum :hoardable_operation, %w[update delete insert]
-    <% else %>
-    reversible do |dir|
-      dir.up do
-        execute(
-          <<~SQL.squish
-            DO $$
-            BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_type t WHERE t.typname = 'hoardable_operation'
-              ) THEN
-                CREATE TYPE hoardable_operation AS ENUM ('update', 'delete', 'insert');
-              END IF;
-            END
-            $$;
-          SQL
-        )
-      end
-
-      dir.down do
-        execute('DROP TYPE IF EXISTS hoardable_operation;')
-      end
-    end
-    <% end %>
   end
 end

data/lib/generators/hoardable/templates/migration.rb.erb

@@ -4,7 +4,11 @@ class Create<%= class_name.singularize.delete(':') %>Versions < ActiveRecord::Mi
   def change
     add_column :<%= table_name %>, :hoardable_id, :<%= foreign_key_type %>
     add_index :<%= table_name %>, :hoardable_id
-    create_table :<%= singularized_table_name %>_versions, id: false, options: 'INHERITS (<%= table_name %>)' do |t|
+    create_table(
+      :<%= singularized_table_name %>_versions,
+      id: false, 
+      options: 'INHERITS (<%= table_name %>)',
+    ) do |t|
       t.jsonb :_data
       t.tsrange :_during, null: false
       t.uuid :_event_uuid, null: false, index: true
@@ -12,6 +16,8 @@ class Create<%= class_name.singularize.delete(':') %>Versions < ActiveRecord::Mi
     end
     reversible do |dir|
       dir.up do
+        execute('ALTER TABLE <%= singularized_table_name %>_versions ADD PRIMARY KEY (<%= primary_key %>);')
+        # remove the following line if you plan on seeding +hoardable_id+ outside the migration
         execute('UPDATE <%= table_name %> SET hoardable_id = <%= primary_key %>;')
       end
     end

data/lib/hoardable/arel_visitors.rb

@@ -0,0 +1,57 @@
+module Hoardable
+  # This is a monkey patch of JOIN related {Arel::Visitors} for PostgreSQL so that they can append
+  # the ONLY clause when known to be operating on a {Hoardable::Model}. Ideally, {Arel} itself would
+  # provide a mechanism to support this keyword.
+  module ArelVisitors
+    def visit_Arel_Nodes_FullOuterJoin(o, collector)
+      collector << "FULL OUTER JOIN "
+      hoardable_maybe_add_only(o, collector)
+      collector = visit o.left, collector
+      collector << " "
+      visit o.right, collector
+    end
+
+    def visit_Arel_Nodes_OuterJoin(o, collector)
+      collector << "LEFT OUTER JOIN "
+      hoardable_maybe_add_only(o, collector)
+      collector = visit o.left, collector
+      collector << " "
+      visit o.right, collector
+    end
+
+    def visit_Arel_Nodes_RightOuterJoin(o, collector)
+      collector << "RIGHT OUTER JOIN "
+      hoardable_maybe_add_only(o, collector)
+      collector = visit o.left, collector
+      collector << " "
+      visit o.right, collector
+    end
+
+    def visit_Arel_Nodes_InnerJoin(o, collector)
+      collector << "INNER JOIN "
+      hoardable_maybe_add_only(o, collector)
+      collector = visit o.left, collector
+      if o.right
+        collector << " "
+        visit(o.right, collector)
+      else
+        collector
+      end
+    end
+
+    private def hoardable_maybe_add_only(o, collector)
+      left = o.left
+
+      if left.is_a?(Arel::Nodes::TableAlias)
+        hoardable_maybe_add_only(left, collector)
+      else
+        return unless left.instance_variable_get("@klass").in?(Hoardable::REGISTRY)
+        return if Hoardable.instance_variable_get("@at")
+
+        collector << "ONLY "
+      end
+    end
+  end
+end
+
+Arel::Visitors::PostgreSQL.prepend Hoardable::ArelVisitors

data/lib/hoardable/database_client.rb

@@ -13,9 +13,13 @@ module Hoardable
     delegate :version_class, to: :source_record
 
     def insert_hoardable_version(operation, &block)
-      version = version_class.insert(initialize_version_attributes(operation), returning: source_primary_key.to_sym)
+      version =
+        version_class.insert(
+          initialize_version_attributes(operation),
+          returning: source_primary_key.to_sym
+        )
       version_id = version[0][source_primary_key]
-      source_record.instance_variable_set('@hoardable_version', version_class.find(version_id))
+      source_record.instance_variable_set("@hoardable_version", version_class.find(version_id))
       source_record.run_callbacks(:versioned, &block)
     end
 
@@ -24,40 +28,50 @@ module Hoardable
     end
 
     def find_or_initialize_hoardable_event_uuid
-      Thread.current[:hoardable_event_uuid] ||= ActiveRecord::Base.connection.query('SELECT gen_random_uuid();')[0][0]
+      Thread.current[:hoardable_event_uuid] ||= (
+        ActiveRecord::Base.connection.query("SELECT gen_random_uuid();")[0][0]
+      )
     end
 
     def initialize_version_attributes(operation)
       source_attributes_without_primary_key.merge(
         source_record.changes.transform_values { |h| h[0] },
         {
-          'hoardable_id' => source_record.id,
-          '_event_uuid' => find_or_initialize_hoardable_event_uuid,
-          '_operation' => operation,
-          '_data' => initialize_hoardable_data.merge(changes: source_record.changes),
-          '_during' => initialize_temporal_range
+          "hoardable_id" => source_record.id,
+          "_event_uuid" => find_or_initialize_hoardable_event_uuid,
+          "_operation" => operation,
+          "_data" => initialize_hoardable_data.merge(changes: source_record.changes),
+          "_during" => initialize_temporal_range
         }
       )
     end
 
     def has_one_find_conditions(reflection)
       {
-        reflection.type => source_record.class.name.sub(/Version$/, ''),
+        reflection.type => source_record.class.name.sub(/Version$/, ""),
         reflection.foreign_key => source_record.hoardable_id,
-        'name' => (reflection.name.to_s.sub(/^rich_text_/, '') if reflection.class_name.match?(/RichText$/))
+        "name" =>
+          (reflection.name.to_s.sub(/^rich_text_/, "") if reflection.class_name.match?(/RichText$/))
       }.reject { |k, v| k.nil? || v.nil? }
     end
 
     def has_one_at_timestamp
-      Hoardable.instance_variable_get('@at') || source_record.updated_at
+      Hoardable.instance_variable_get("@at") || source_record.updated_at
     rescue NameError
       raise(UpdatedAtColumnMissingError, source_record.class.table_name)
     end
 
     def source_attributes_without_primary_key
-      source_record.attributes.without(source_primary_key, *generated_column_names).merge(
-        source_record.class.select(refreshable_column_names).find(source_record.id).slice(refreshable_column_names)
-      )
+      source_record
+        .attributes
+        .without(source_primary_key, *generated_column_names)
+        .merge(
+          source_record
+            .class
+            .select(refreshable_column_names)
+            .find(source_record.id)
+            .slice(refreshable_column_names)
+        )
     end
 
     def generated_column_names
@@ -67,9 +81,15 @@ module Hoardable
     end
 
     def refreshable_column_names
-      @refreshable_column_names ||= source_record.class.columns.select(&:default_function).reject do |column|
-        column.name == source_primary_key || column.name.in?(generated_column_names)
-      end.map(&:name)
+      @refreshable_column_names ||=
+        source_record
+          .class
+          .columns
+          .select(&:default_function)
+          .reject do |column|
+            column.name == source_primary_key || column.name.in?(generated_column_names)
+          end
+          .map(&:name)
     end
 
     def initialize_temporal_range
@@ -77,9 +97,7 @@ module Hoardable
     end
 
     def initialize_hoardable_data
-      DATA_KEYS.to_h do |key|
-        [key, assign_hoardable_context(key)]
-      end
+      DATA_KEYS.to_h { |key| [key, assign_hoardable_context(key)] }
     end
 
     def assign_hoardable_context(key)
@@ -89,18 +107,18 @@ module Hoardable
     end
 
     def unset_hoardable_version_and_event_uuid
-      source_record.instance_variable_set('@hoardable_version', nil)
+      source_record.instance_variable_set("@hoardable_version", nil)
       return if source_record.class.connection.transaction_open?
 
       Thread.current[:hoardable_event_uuid] = nil
     end
 
     def previous_temporal_tsrange_end
-      source_record.versions.only_most_recent.pluck('_during').first&.end
+      source_record.versions.only_most_recent.pluck("_during").first&.end
     end
 
     def hoardable_source_epoch
-      return source_record.created_at if source_record.class.column_names.include?('created_at')
+      return source_record.created_at if source_record.class.column_names.include?("created_at")
 
       raise CreatedAtColumnMissingError, source_record.class.table_name
     end

data/lib/hoardable/engine.rb

@@ -2,6 +2,8 @@
 
 # An +ActiveRecord+ extension for keeping versions of records in uni-temporal inherited tables.
 module Hoardable
+  REGISTRY = Set.new
+
   # Symbols for use with setting contextual data, when creating versions. See
   # {file:README.md#tracking-contextual-data README} for more.
   DATA_KEYS = %i[meta whodunit event_uuid].freeze
@@ -10,60 +12,47 @@ module Hoardable
   # README} for more.
   CONFIG_KEYS = %i[enabled version_updates save_trash].freeze
 
-  VERSION_CLASS_SUFFIX = 'Version'
+  VERSION_CLASS_SUFFIX = "Version"
   private_constant :VERSION_CLASS_SUFFIX
 
   VERSION_TABLE_SUFFIX = "_#{VERSION_CLASS_SUFFIX.tableize}"
   private_constant :VERSION_TABLE_SUFFIX
 
-  DURING_QUERY = '_during @> ?::timestamp'
+  DURING_QUERY = "_during @> ?::timestamp"
   private_constant :DURING_QUERY
 
-  HOARDABLE_CALLBACKS_ENABLED = proc do |source_model|
-    source_model.class.hoardable_config[:enabled] && !source_model.class.name.end_with?(VERSION_CLASS_SUFFIX)
-  end.freeze
+  HOARDABLE_CALLBACKS_ENABLED =
+    proc do |source_model|
+      source_model.class.hoardable_config[:enabled] &&
+        !source_model.class.name.end_with?(VERSION_CLASS_SUFFIX)
+    end.freeze
   private_constant :HOARDABLE_CALLBACKS_ENABLED
 
-  HOARDABLE_SAVE_TRASH = proc do |source_model|
-    source_model.class.hoardable_config[:save_trash]
-  end.freeze
+  HOARDABLE_SAVE_TRASH =
+    proc { |source_model| source_model.class.hoardable_config[:save_trash] }.freeze
   private_constant :HOARDABLE_SAVE_TRASH
 
-  HOARDABLE_VERSION_UPDATES = proc do |source_model|
-    source_model.class.hoardable_config[:version_updates]
-  end.freeze
+  HOARDABLE_VERSION_UPDATES =
+    proc { |source_model| source_model.class.hoardable_config[:version_updates] }.freeze
   private_constant :HOARDABLE_VERSION_UPDATES
 
-  SUPPORTS_ENCRYPTED_ACTION_TEXT = ActiveRecord.version >= ::Gem::Version.new('7.0.4')
+  SUPPORTS_ENCRYPTED_ACTION_TEXT = ActiveRecord.version >= ::Gem::Version.new("7.0.4")
   private_constant :SUPPORTS_ENCRYPTED_ACTION_TEXT
 
-  SUPPORTS_VIRTUAL_COLUMNS = ActiveRecord.version >= ::Gem::Version.new('7.0.0')
-  private_constant :SUPPORTS_VIRTUAL_COLUMNS
-
   @context = {}
-  @config = CONFIG_KEYS.to_h do |key|
-    [key, true]
-  end
+  @config = CONFIG_KEYS.to_h { |key| [key, true] }
 
   class << self
     CONFIG_KEYS.each do |key|
-      define_method(key) do
-        @config[key]
-      end
+      define_method(key) { @config[key] }
 
-      define_method("#{key}=") do |value|
-        @config[key] = value
-      end
+      define_method("#{key}=") { |value| @config[key] = value }
     end
 
     DATA_KEYS.each do |key|
-      define_method(key) do
-        @context[key]
-      end
+      define_method(key) { @context[key] }
 
-      define_method("#{key}=") do |value|
-        @context[key] = value
-      end
+      define_method("#{key}=") { |value| @context[key] = value }
     end
 
     # This is a general use method for setting {file:README.md#tracking-contextual-data Contextual
@@ -102,10 +91,20 @@ module Hoardable
   class Engine < ::Rails::Engine
     isolate_namespace Hoardable
 
-    initializer 'hoardable.action_text' do
+    initializer "hoardable.action_text" do
       ActiveSupport.on_load(:action_text_rich_text) do
-        require_relative 'rich_text'
-        require_relative 'encrypted_rich_text' if SUPPORTS_ENCRYPTED_ACTION_TEXT
+        require_relative "rich_text"
+        require_relative "encrypted_rich_text" if SUPPORTS_ENCRYPTED_ACTION_TEXT
+      end
+    end
+
+    initializer "hoardable.schema_statements" do
+      ActiveSupport.on_load(:active_record_postgresqladapter) do
+        # We need to control the table dumping order of tables, so revert these to just +super+
+        Fx::SchemaDumper::Trigger.module_eval("def tables(streams); super; end")
+
+        ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend(SchemaDumper)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements.prepend(SchemaStatements)
       end
     end
   end

data/lib/hoardable/error.rb

@@ -2,29 +2,26 @@
 
 module Hoardable
   # A subclass of +StandardError+ for general use within {Hoardable}.
-  class Error < StandardError; end
+  class Error < StandardError
+  end
 
   # An error to be raised when 'created_at' columns are missing for {Hoardable::Model}s.
   class CreatedAtColumnMissingError < Error
     def initialize(source_table_name)
-      super(
-        <<~LOG
+      super(<<~LOG)
           '#{source_table_name}' does not have a 'created_at' column, so the start of the first
           version’s temporal period cannot be known. Add a 'created_at' column to '#{source_table_name}'.
         LOG
-      )
     end
   end
 
   # An error to be raised when 'updated_at' columns are missing for {Hoardable::Model}s.
   class UpdatedAtColumnMissingError < Error
     def initialize(source_table_name)
-      super(
-        <<~LOG
+      super(<<~LOG)
           '#{source_table_name}' does not have an 'updated_at' column, so Hoardable cannot look up
           associated record versions with it. Add an 'updated_at' column to '#{source_table_name}'.
         LOG
-      )
     end
   end
 end

data/lib/hoardable/finder_methods.rb

@@ -17,9 +17,7 @@ module Hoardable
     private
 
     def hoardable_ids(ids)
-      ids.map do |id|
-        version_class.where(hoardable_id: id).select(primary_key).ids[0] || id
-      end
+      ids.map { |id| version_class.where(hoardable_id: id).select(primary_key).ids[0] || id }
     end
   end
 end

data/lib/hoardable/has_many.rb

@@ -12,15 +12,9 @@ module Hoardable
         @scope ||= hoardable_scope
       end
 
-      private
-
-      def hoardable_scope
-        if Hoardable.instance_variable_get('@at') && (hoardable_id = @association.owner.hoardable_id)
-          if @association.reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-            @association.reflection.source_reflection.instance_variable_set(
-              '@active_record_primary_key', 'hoardable_id'
-            )
-          end
+      private def hoardable_scope
+        if Hoardable.instance_variable_get("@at") &&
+             (hoardable_id = @association.owner.hoardable_id)
           @association.scope.rewhere(@association.reflection.foreign_key => hoardable_id)
         else
           @association.scope
@@ -32,7 +26,9 @@ module Hoardable
     class_methods do
       def has_many(*args, &block)
         options = args.extract_options!
-        options[:extend] = Array(options[:extend]).push(HasManyExtension) if options.delete(:hoardable)
+        options[:extend] = Array(options[:extend]).push(HasManyExtension) if options.delete(
+          :hoardable
+        )
         super(*args, **options, &block)
 
         # This hack is needed to force Rails to not use any existing method cache so that the

data/lib/hoardable/has_one.rb

@@ -9,13 +9,13 @@ module Hoardable
       def has_one(*args)
         options = args.extract_options!
         hoardable = options.delete(:hoardable)
-        association = super(*args, **options)
         name = args.first
-        return unless hoardable || association[name.to_s].options[:class_name].match?(/RichText$/)
+        association = super(*args, **options).symbolize_keys[name]
+        return unless hoardable || (association.options[:class_name].match?(/RichText$/))
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{name}
-            reflection = _reflections['#{name}']
+            reflection = _reflections.symbolize_keys[:#{name}]
             return super if reflection.klass.name.match?(/^ActionText/)
             return super unless (timestamp = hoardable_client.has_one_at_timestamp)
 

data/lib/hoardable/has_rich_text.rb

@@ -6,16 +6,23 @@ module Hoardable
     extend ActiveSupport::Concern
 
     class_methods do
-      def has_rich_text(name, encrypted: false, hoardable: false)
-        if SUPPORTS_ENCRYPTED_ACTION_TEXT
-          super(name, encrypted: encrypted)
-        else
-          super(name)
-        end
+      def has_rich_text(name, hoardable: false, **opts)
+        super(name, **opts)
         return unless hoardable
 
         reflection_options = reflections["rich_text_#{name}"].options
-        reflection_options[:class_name] = reflection_options[:class_name].sub(/ActionText/, 'Hoardable')
+
+        # load the +ActionText+ class if it hasn’t been already
+        reflection_options[:class_name].constantize
+
+        reflection_options[:class_name] = reflection_options[:class_name].sub(
+          /^ActionText/,
+          "Hoardable"
+        )
+      end
+
+      def has_hoardable_rich_text(name, **opts)
+        has_rich_text(name, hoardable: true, **opts)
       end
     end
   end

data/lib/hoardable/model.rb

@@ -51,24 +51,27 @@ module Hoardable
       define_model_callbacks :reverted, only: :after
       define_model_callbacks :untrashed, only: :after
 
-      TracePoint.new(:end) do |trace|
-        next unless self == trace.self
+      TracePoint
+        .new(:end) do |trace|
+          next unless self == trace.self
 
-        full_version_class_name = "#{name}#{VERSION_CLASS_SUFFIX}"
-        if (namespace_match = full_version_class_name.match(/(.*)::(.*)/))
-          object_namespace = namespace_match[1].constantize
-          version_class_name = namespace_match[2]
-        else
-          object_namespace = Object
-          version_class_name = full_version_class_name
-        end
-        unless Object.const_defined?(full_version_class_name)
-          object_namespace.const_set(version_class_name, Class.new(self) { include VersionModel })
-        end
-        include SourceModel
+          full_version_class_name = "#{name}#{VERSION_CLASS_SUFFIX}"
+          if (namespace_match = full_version_class_name.match(/(.*)::(.*)/))
+            object_namespace = namespace_match[1].constantize
+            version_class_name = namespace_match[2]
+          else
+            object_namespace = Object
+            version_class_name = full_version_class_name
+          end
+          unless Object.const_defined?(full_version_class_name)
+            object_namespace.const_set(version_class_name, Class.new(self) { include VersionModel })
+          end
+          include SourceModel
+          REGISTRY.add(self)
 
-        trace.disable
-      end.enable
+          trace.disable
+        end
+        .enable
     end
   end
 end