hoardable 0.10.1 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dad9a103d70ce10905528d1d7e56e67a4a8fb89e675b3097165ccede6262a015
-  data.tar.gz: a2dc95873a08175254cca315caa3de9b087674df1e4dadd17f42fb26a9080a9d
+  metadata.gz: eec6cda69bb2bbb1aeec6a0c460881c33abbe1de123ef9178d2c16378374b2bd
+  data.tar.gz: f3f57007e08f958017483dfffd0275b5b70c0ef1522984ea78da4c595a9e5506
 SHA512:
-  metadata.gz: 02b542ba1fe562750eb16bf6f310b08e2340610e01e7db68eaedb9185e4da4a1d7e7a5a42885fb09376759bf936b8b527de4bedec8399b71119541162e57604f
-  data.tar.gz: 77edd48d420fea18333996280d6e31e0daba198b96e67fdc49b4fc7fe1884cb86cc88416e1f486691e2292465818fb50e3c4fc4367d83cc6d751d0adcb39acf6
+  metadata.gz: 04a13fec8198d4c4fda05b5364a7925755e7f2708004e15a564f243b64836577f4393cb502e7dd7d88ea123df29909ccb36a1d603cae8b2e711958250dc45763
+  data.tar.gz: 34a59cb91ed643784e4aa6ab88abac2d3e7a59a59945bcdce6e849aa441bc1490a6870c2661f65c31d246e4cb87bb39c4502e6cb8ce05cb3c42a6ad0e56f1140

data/Gemfile

@@ -5,6 +5,7 @@ source 'https://rubygems.org'
 gem 'benchmark-ips', '~> 2.10'
 gem 'debug', '~> 1.6'
 gem 'minitest', '~> 5.0'
+gem 'rails', '>= 6.1'
 gem 'rake', '~> 13.0'
 gem 'rubocop', '~> 1.21'
 gem 'rubocop-minitest', '~> 0.20'

data/README.md

@@ -29,14 +29,19 @@ Add this line to your application's Gemfile:
 gem 'hoardable'
 ```
 
-And then execute `bundle install`.
-
-If you would like to generate an initializer with the global [configuration](#configuration) options:
+Run `bundle install`, and then run:
 
 ```
-rails g hoardable:initializer
+bin/rails g hoardable:install
+bin/rails db:migrate
 ```
 
+This will generate a PostgreSQL function and an initiailzer.
+
+_Note:_ It is recommended to set `config.active_record.schema_format = :sql` in `application.rb`, so
+that the function and triggers in the migrations that prevent updates to the versions table get
+captured in your schema.
+
 ### Model Installation
 
 You must include `Hoardable::Model` into an ActiveRecord model that you would like to hoard versions
@@ -66,10 +71,6 @@ explicitly, you can do so:
 bin/rails g hoardable:migration Post --foreign-key-type uuid
 ```
 
-_Note:_ If you are on Rails 6.1, you might want to set `config.active_record.schema_format = :sql`
-in `application.rb`, so that the enum type is captured in your schema dump. This is not required in
-Rails 7.
-
 _Note:_ Creating an inherited table does not copy over the indexes from the parent table. If you
 need to query versions often, you should add appropriate indexes to the `_versions` tables.
 
@@ -83,9 +84,9 @@ of that model. As we continue our example from above:
 ```
 $ irb
 >> Post
-=> Post(id: integer, body: text, user_id: integer, created_at: datetime)
+=> Post(id: integer, body: text, user_id: integer, created_at: datetime, hoardable_id: integer)
 >> PostVersion
-=> PostVersion(id: integer, body: text, user_id: integer, created_at: datetime, _data: jsonb, _during: tsrange, hoardable_source_id: integer)
+=> PostVersion(id: integer, body: text, user_id: integer, created_at: datetime, hoardable_id: integer, _data: jsonb, _during: tsrange)
 ```
 
 A `Post` now `has_many :versions`. With the default configuration, whenever an update and deletion
@@ -143,7 +144,7 @@ If you want to look-up the version of a record at a specific time, you can use t
 ```ruby
 post.at(1.day.ago) # => #<PostVersion>
 # or you can use the scope on the version model class
-PostVersion.at(1.day.ago).find_by(hoardable_source_id: post.id) # => #<PostVersion>
+PostVersion.at(1.day.ago).find_by(hoardable_id: post.id) # => #<PostVersion>
 ```
 
 The source model class also has an `.at` method:
@@ -356,7 +357,7 @@ Hoardable.at(datetime) do
   post.comments.size # => 2
   post.id # => 2
   post.version? # => true
-  post.hoardable_source_id # => 1
+  post.hoardable_id # => 1
 end
 ```
 
@@ -369,9 +370,9 @@ version, even though it is masquerading as a `Post`.
 
 If you are ever unsure if a Hoardable record is a "source" or a "version", you can be sure by
 calling `version?` on it. If you want to get the true original source record ID, you can call
-`hoardable_source_id`. 
+`hoardable_id`. 
 
-Sometimes you’ll trash something that `has_many_hoardable :children, dependent: :destroy` and want
+Sometimes you’ll trash something that `has_many :children, dependent: :destroy` and want
 to untrash everything in a similar dependent manner. Whenever a hoardable version is created in a
 database transaction, it will create or re-use a unique event UUID for that transaction and tag all
 versions created with it. That way, when you `untrash!` a record, you can find and `untrash!`
@@ -380,7 +381,7 @@ records that were trashed with it:
 ```ruby
 class Post < ActiveRecord::Base
   include Hoardable::Model
-  has_many_hoardable :comments, dependent: :destroy # `Comment` also includes `Hoardable::Model`
+  has_many :comments, hoardable: true, dependent: :destroy # `Comment` also includes `Hoardable::Model`
 
   after_untrashed do
     Comment
@@ -392,9 +393,42 @@ class Post < ActiveRecord::Base
 end
 ```
 
+## Action Text
+
+Hoardable provides support for ActiveRecord models with `has_rich_text`. First, you must create a
+temporal table for `ActionText::RichText`:
+
+```
+bin/rails g hoardable:migration ActionText::RichText
+bin/rails db:migrate
+```
+
+Then in your model, include `Hoardable::Model` and provide the `hoardable: true` keyword to
+`has_rich_text`:
+
+``` ruby
+class Post < ActiveRecord::Base
+  include Hoardable::Model # or `Hoardable::Associations` if you don't need `PostVersion`
+  has_rich_text :content, hoardable: true
+end
+```
+
+Now the `rich_text_content` relationship will be managed as a Hoardable `has_one` relationship:
+
+``` ruby
+post = Post.create!(content: '<div>Hello World</div>')
+datetime = DateTime.current
+post.update!(content: '<div>Goodbye Cruel World</div>')
+post.content.versions.size # => 1
+post.content.to_plain_text # => 'Goodbye Cruel World'
+Hoardable.at(datetime) do
+  post.content.to_plain_text # => 'Hello World'
+end
+```
+
 ## Gem Comparison
 
-### [`paper_trail`](https://github.com/paper-trail-gem/paper_trail)
+#### [`paper_trail`](https://github.com/paper-trail-gem/paper_trail)
 
 `paper_trail` is maybe the most popular and fully featured gem in this space. It works for other
 database types than PostgeSQL and (by default) stores all versions of all versioned models in a
@@ -407,7 +441,7 @@ same database columns as their parents, which are more efficient for querying as
 for truncating and dropping. The concept of a `temporal` time-frame does not exist for a single
 version since there is only a `created_at` timestamp.
 
-### [`audited`](https://github.com/collectiveidea/audited)
+#### [`audited`](https://github.com/collectiveidea/audited)
 
 `audited` works in a similar manner as `paper_trail`. It stores all versions for all model types in
 a single table, you must opt into using `jsonb` as the column type to store "changes", in case you
@@ -415,7 +449,7 @@ want to query them, and there is no concept of a `temporal` time-frame for a sin
 makes opinionated decisions about contextual data requirements and stores them as top level data
 types on the `audited` table.
 
-### [`discard`](https://github.com/jhawthorn/discard)
+#### [`discard`](https://github.com/jhawthorn/discard)
 
 `discard` only covers soft-deletion. The act of "soft deleting" a record is only captured through
 the time-stamping of a `discarded_at` column on the records table; there is no other capturing of
@@ -424,7 +458,7 @@ record is restored, the previous "discarded" awareness is lost. Since "discarded
 the same table as "undiscarded" records, you must explicitly omit the discarded records from queries
 across your app to keep them from leaking in.
 
-### [`paranoia`](https://github.com/rubysherpas/paranoia)
+#### [`paranoia`](https://github.com/rubysherpas/paranoia)
 
 `paranoia` also only covers soft-deletion. In their README, they recommend using `discard` instead
 of `paranoia` because of the fact they override ActiveRecord’s `delete` and `destroy` methods.
@@ -432,6 +466,13 @@ of `paranoia` because of the fact they override ActiveRecord’s `delete` and `d
 `paranoia` works similarly to `discard` in that it keeps deleted records in the same table and tags
 them with a `deleted_at` timestamp. No other information about the soft-deletion event is stored.
 
+#### [`logidze`](https://github.com/palkan/logidze)
+
+`logidze` is an interesting versioning alternative that leverages the power of PostgreSQL triggers.
+Instead of storing the previous versions or changes in a separate table, it stores them in a
+proprietary JSON format directly on the database row of the record itself. If does not support soft
+deletion.
+
 ## Contributing
 
 This gem still quite new and very open to feedback.

data/lib/generators/hoardable/install_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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__)
+    include Rails::Generators::Migration
+
+    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 create_migration_file
+      migration_template 'install.rb.erb', 'db/migrate/install_hoardable.rb'
+    end
+
+    def self.next_migration_number(dir)
+      ::ActiveRecord::Generators::Base.next_migration_number(dir)
+    end
+  end
+end

data/lib/generators/hoardable/migration_generator.rb

@@ -12,7 +12,7 @@ module Hoardable
     class_option :foreign_key_type, type: :string
 
     def create_versions_table
-      migration_template migration_template_name, "db/migrate/create_#{singularized_table_name}_versions.rb"
+      migration_template 'migration.rb.erb', "db/migrate/create_#{singularized_table_name}_versions.rb"
     end
 
     no_tasks do
@@ -23,12 +23,10 @@ module Hoardable
         'bigint'
       end
 
-      def migration_template_name
-        if Gem::Version.new(ActiveRecord::Migration.current_version.to_s) < Gem::Version.new('7')
-          'migration_6.rb.erb'
-        else
-          'migration.rb.erb'
-        end
+      def primary_key
+        options[:primary_key] || class_name.singularize.constantize.primary_key
+      rescue StandardError
+        'id'
       end
 
       def singularized_table_name

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class InstallHoardable < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def up
+    execute(
+      <<~SQL
+        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
+        $$;
+        CREATE OR REPLACE FUNCTION hoardable_source_set_id() RETURNS trigger
+          LANGUAGE plpgsql AS
+        $$
+        DECLARE
+          _pk information_schema.constraint_column_usage.column_name%TYPE;
+          _id _pk%TYPE;
+        BEGIN
+          SELECT c.column_name
+            FROM information_schema.table_constraints t
+            JOIN information_schema.constraint_column_usage c
+            ON c.constraint_name = t.constraint_name
+            WHERE c.table_name = TG_TABLE_NAME AND t.constraint_type = 'PRIMARY KEY'
+            LIMIT 1
+            INTO _pk;
+          EXECUTE format('SELECT $1.%I', _pk) INTO _id USING NEW;
+          NEW.hoardable_id = _id;
+          RETURN NEW;
+        END;$$;
+        CREATE OR REPLACE FUNCTION hoardable_version_prevent_update() RETURNS trigger
+          LANGUAGE plpgsql AS
+        $$BEGIN
+          RAISE EXCEPTION 'updating a version is not allowed';
+          RETURN NEW;
+        END;$$;
+      SQL
+    )
+  end
+  def down
+    execute(
+      <<~SQL
+        DROP TYPE IF EXISTS hoardable_operation;
+        DROP FUNCTION IF EXISTS hoardable_version_prevent_update();
+        DROP FUNCTION IF EXISTS hoardable_source_set_id();
+      SQL
+    )
+  end
+end

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

@@ -1,33 +1,45 @@
 # frozen_string_literal: true
 
-class Create<%= class_name.singularize %>Versions < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+class Create<%= class_name.singularize.delete(':') %>Versions < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-    create_enum :hoardable_operation, %w[update delete insert]
+    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|
       t.jsonb :_data
       t.tsrange :_during, null: false
       t.uuid :_event_uuid, null: false, index: true
-      t.enum :_operation, enum_type: 'hoardable_operation', null: false, index: true
-      t.<%= foreign_key_type %> :hoardable_source_id, null: false, index: true
+      t.column :_operation, :hoardable_operation, null: false, index: true
     end
-    execute(
-      <<~SQL
-        CREATE OR REPLACE FUNCTION hoardable_version_prevent_update() RETURNS trigger
-          LANGUAGE plpgsql AS
-        $$BEGIN
-          RAISE EXCEPTION 'updating a version is not allowed';
-          RETURN NEW;
-        END;$$;
-
-        CREATE TRIGGER <%= singularized_table_name %>_versions_prevent_update
-          BEFORE UPDATE ON <%= singularized_table_name %>_versions FOR EACH ROW
-          EXECUTE PROCEDURE hoardable_version_prevent_update();
-      SQL
-    )
-    add_index(:<%= singularized_table_name %>_versions, :id, unique: true)
+    reversible do |dir|
+      dir.up do
+        execute(
+          <<~SQL
+            UPDATE <%= table_name %> SET hoardable_id = <%= primary_key %>;
+            CREATE TRIGGER <%= singularized_table_name %>_versions_prevent_update
+              BEFORE UPDATE ON <%= singularized_table_name %>_versions FOR EACH ROW
+              EXECUTE PROCEDURE hoardable_version_prevent_update();
+            CREATE TRIGGER <%= table_name %>_set_hoardable_id
+              BEFORE INSERT ON <%= table_name %> FOR EACH ROW
+              EXECUTE PROCEDURE hoardable_source_set_id();
+          SQL
+        )
+      end
+      dir.down do
+        execute(
+          <<~SQL
+            DROP TRIGGER <%= singularized_table_name %>_versions_prevent_update
+              ON <%= singularized_table_name %>_versions;
+            DROP TRIGGER <%= table_name %>_set_hoardable_id
+              ON <%= table_name %>;
+          SQL
+        )
+      end
+    end
+    change_column_null :<%= table_name %>, :hoardable_id, false
+    add_index(:<%= singularized_table_name %>_versions, :<%= primary_key %>, unique: true)
     add_index(
       :<%= singularized_table_name %>_versions,
-      %i[_during hoardable_source_id],
+      %i[_during hoardable_id],
       name: 'idx_<%= singularized_table_name %>_versions_temporally'
     )
   end

data/lib/hoardable/associations.rb

@@ -7,104 +7,11 @@ module Hoardable
   module Associations
     extend ActiveSupport::Concern
 
-    # An +ActiveRecord+ extension that allows looking up {VersionModel}s by +hoardable_source_id+ as
-    # if they were {SourceModel}s when using {Hoardable#at}.
-    module HasManyExtension
-      def scope
-        @scope ||= hoardable_scope
-      end
-
-      private
-
-      def hoardable_scope
-        if Hoardable.instance_variable_get('@at') &&
-           (hoardable_source_id = @association.owner.hoardable_source_id)
-          @association.scope.rewhere(@association.reflection.foreign_key => hoardable_source_id)
-        else
-          @association.scope
-        end
-      end
-    end
-    private_constant :HasManyExtension
-
-    # A private service class for installing +ActiveRecord+ association overrides.
-    class Overrider
-      attr_reader :klass
-
-      def initialize(klass)
-        @klass = klass
-      end
-
-      def override_belongs_to(name)
-        klass.define_method("trashable_#{name}") do
-          source_reflection = klass.reflections[name.to_s]
-          source_reflection.version_class.trashed.only_most_recent.find_by(
-            hoardable_source_id: source_reflection.foreign_key
-          )
-        end
-
-        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}
-            super || trashable_#{name}
-          end
-        RUBY
-      end
-
-      def override_has_one(name)
-        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}
-            return super unless (at = Hoardable.instance_variable_get('@at'))
-
-            super&.version_at(at) ||
-              _reflections["profile"].klass.where(_reflections["profile"].foreign_key => id).first
-          end
-        RUBY
-      end
-
-      def override_has_many(name)
-        # This hack is needed to force Rails to not use any existing method cache so that the
-        # {HasManyExtension} scope is always used.
-        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}
-            super.extending
-          end
-        RUBY
-      end
-    end
-    private_constant :Overrider
-
-    class_methods do
-      def belongs_to(*args)
-        options = args.extract_options!
-        trashable = options.delete(:trashable)
-        super(*args, **options)
-        return unless trashable
-
-        hoardable_association_overrider.override_belongs_to(args.first)
-      end
-
-      def has_one(*args)
-        options = args.extract_options!
-        hoardable = options.delete(:hoardable)
-        super(*args, **options)
-        return unless hoardable
-
-        hoardable_association_overrider.override_has_one(args.first)
-      end
-
-      def has_many(*args, &block)
-        options = args.extract_options!
-        options[:extend] = Array(options[:extend]).push(HasManyExtension) if options.delete(:hoardable)
-        super(*args, **options, &block)
-
-        hoardable_association_overrider.override_has_many(args.first)
-      end
-
-      private
-
-      def hoardable_association_overrider
-        @hoardable_association_overrider ||= Overrider.new(self)
-      end
+    included do
+      include HasMany
+      include HasOne
+      include BelongsTo
+      include HasRichText
     end
   end
 end

data/lib/hoardable/belongs_to.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # Provides awareness of trashed source records to +belongs_to+ relationships.
+  module BelongsTo
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def belongs_to(*args)
+        options = args.extract_options!
+        trashable = options.delete(:trashable)
+        super(*args, **options)
+        return unless trashable
+
+        hoardable_override_belongs_to(args.first)
+      end
+
+      private
+
+      def hoardable_override_belongs_to(name)
+        define_method("trashed_#{name}") do
+          source_reflection = reflections[name.to_s]
+          source_reflection.version_class.trashed.only_most_recent.find_by(
+            hoardable_id: source_reflection.foreign_key
+          )
+        end
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}
+            super || trashed_#{name}
+          end
+        RUBY
+      end
+    end
+  end
+  private_constant :BelongsTo
+end

data/lib/hoardable/database_client.rb

@@ -13,30 +13,25 @@ module Hoardable
     delegate :version_class, to: :source_record
 
     def insert_hoardable_version(operation, &block)
-      version = version_class.insert(initialize_version_attributes(operation), returning: :id)
-      version_id = version[0]['id']
+      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.run_callbacks(:versioned, &block)
     end
 
-    def find_or_initialize_hoardable_event_uuid
-      Thread.current[:hoardable_event_uuid] ||= ActiveRecord::Base.connection.query('SELECT gen_random_uuid();')[0][0]
-    end
-
-    def hoardable_version_source_id
-      @hoardable_version_source_id ||= query_hoardable_version_source_id
+    def source_primary_key
+      source_record.class.primary_key
     end
 
-    def query_hoardable_version_source_id
-      primary_key = source_record.class.primary_key
-      version_class.where(primary_key => source_record.read_attribute(primary_key)).pluck('hoardable_source_id')[0]
+    def find_or_initialize_hoardable_event_uuid
+      Thread.current[:hoardable_event_uuid] ||= ActiveRecord::Base.connection.query('SELECT gen_random_uuid();')[0][0]
     end
 
     def initialize_version_attributes(operation)
-      source_record.attributes_before_type_cast.without('id').merge(
+      source_attributes_without_primary_key.merge(
         source_record.changes.transform_values { |h| h[0] },
         {
-          'hoardable_source_id' => source_record.id,
+          'hoardable_id' => source_record.id,
           '_event_uuid' => find_or_initialize_hoardable_event_uuid,
           '_operation' => operation,
           '_data' => initialize_hoardable_data.merge(changes: source_record.changes),
@@ -45,6 +40,10 @@ module Hoardable
       )
     end
 
+    def source_attributes_without_primary_key
+      source_record.attributes_before_type_cast.without(source_primary_key)
+    end
+
     def initialize_temporal_range
       ((previous_temporal_tsrange_end || hoardable_source_epoch)..Time.now.utc)
     end

data/lib/hoardable/encrypted_rich_text.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # A {Hoardable} subclass of {ActionText::EncryptedRichText}.
+  class EncryptedRichText < ActionText::EncryptedRichText
+    include Model
+  end
+end

data/lib/hoardable/{hoardable.rb → engine.rb}

@@ -34,6 +34,9 @@ module Hoardable
   end.freeze
   private_constant :HOARDABLE_VERSION_UPDATES
 
+  SUPPORTS_ENCRYPTED_ACTION_TEXT = ActiveRecord.version >= ::Gem::Version.new('7.0')
+  private_constant :SUPPORTS_ENCRYPTED_ACTION_TEXT
+
   @context = {}
   @config = CONFIG_KEYS.to_h do |key|
     [key, true]
@@ -91,4 +94,16 @@ module Hoardable
       @logger ||= ActiveSupport::TaggedLogging.new(Logger.new($stdout))
     end
   end
+
+  # A +Rails+ engine for providing support for +ActionText+
+  class Engine < ::Rails::Engine
+    isolate_namespace Hoardable
+
+    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
+      end
+    end
+  end
 end

data/lib/hoardable/finder_methods.rb

@@ -7,18 +7,18 @@ module Hoardable
   # with the class method +hoardable+.
   module FinderMethods
     def find_one(id)
-      super(hoardable_source_ids([id])[0])
+      super(hoardable_ids([id])[0])
     end
 
     def find_some(ids)
-      super(hoardable_source_ids(ids))
+      super(hoardable_ids(ids))
     end
 
     private
 
-    def hoardable_source_ids(ids)
+    def hoardable_ids(ids)
       ids.map do |id|
-        version_class.where(hoardable_source_id: id).select(primary_key).ids[0] || id
+        version_class.where(hoardable_id: id).select(primary_key).ids[0] || id
       end
     end
   end

data/lib/hoardable/has_many.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # Provides temporal version awareness to +has_many+ relationships.
+  module HasMany
+    extend ActiveSupport::Concern
+
+    # An +ActiveRecord+ extension that allows looking up {VersionModel}s by +hoardable_id+ as
+    # if they were {SourceModel}s when using {Hoardable#at}.
+    module HasManyExtension
+      def scope
+        @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
+          @association.scope.rewhere(@association.reflection.foreign_key => hoardable_id)
+        else
+          @association.scope
+        end
+      end
+    end
+    private_constant :HasManyExtension
+
+    class_methods do
+      def has_many(*args, &block)
+        options = args.extract_options!
+        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
+        # {HasManyExtension} scope is always used.
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{args.first}
+            super.extending
+          end
+        RUBY
+      end
+    end
+  end
+  private_constant :HasMany
+end

data/lib/hoardable/has_one.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # Provides temporal version awareness to +has_one+ relationships.
+  module HasOne
+    extend ActiveSupport::Concern
+
+    class_methods do
+      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$/)
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}
+            return super unless (at = Hoardable.instance_variable_get('@at'))
+
+            super&.version_at(at) ||
+              _reflections['profile'].klass.where(_reflections['profile'].foreign_key => id).first
+          end
+        RUBY
+      end
+    end
+  end
+  private_constant :HasOne
+end

data/lib/hoardable/has_rich_text.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # Provides temporal version awareness for +ActionText+.
+  module HasRichText
+    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
+        return unless hoardable
+
+        reflection_options = reflections["rich_text_#{name}"].options
+        reflection_options[:class_name] = reflection_options[:class_name].sub(/ActionText/, 'Hoardable')
+      end
+    end
+  end
+  private_constant :HasRichText
+end

data/lib/hoardable/model.rb

@@ -53,11 +53,17 @@ module Hoardable
       TracePoint.new(:end) do |trace|
         next unless self == trace.self
 
-        version_class_name = "#{name}#{VERSION_CLASS_SUFFIX}"
-        unless Object.const_defined?(version_class_name)
-          Object.const_set(version_class_name, Class.new(self) { include VersionModel })
+        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
 
         trace.disable

data/lib/hoardable/rich_text.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # A {Hoardable} subclass of {ActionText::RichText}
+  class RichText < ActionText::RichText
+    include Model
+  end
+end

data/lib/hoardable/scopes.rb

@@ -62,10 +62,10 @@ module Hoardable
       scope :at, lambda { |datetime|
         raise(CreatedAtColumnMissingError, @klass.table_name) unless @klass.column_names.include?('created_at')
 
-        include_versions.where(id: version_class.at(datetime).select('id')).or(
+        include_versions.where(id: version_class.at(datetime).select(@klass.primary_key)).or(
           exclude_versions
             .where("#{table_name}.created_at < ?", datetime)
-            .where.not(id: version_class.select(:hoardable_source_id).where(DURING_QUERY, datetime))
+            .where.not(id: version_class.select(:hoardable_id).where(DURING_QUERY, datetime))
         ).hoardable
       }
     end

data/lib/hoardable/source_model.rb

@@ -51,7 +51,7 @@ module Hoardable
         dependent: nil,
         class_name: version_class.to_s,
         inverse_of: :hoardable_source,
-        foreign_key: :hoardable_source_id
+        foreign_key: :hoardable_id
       )
     end
 
@@ -60,7 +60,7 @@ module Hoardable
     #
     # @return [Boolean]
     def trashed?
-      versions.trashed.only_most_recent.first&.hoardable_source_id == id
+      !self.class.exists?(self.class.primary_key => id)
     end
 
     # Returns a boolean of whether the record is actually a +version+ cast as an instance of the
@@ -68,7 +68,7 @@ module Hoardable
     #
     # @return [Boolean]
     def version?
-      !!hoardable_client.hoardable_version_source_id
+      hoardable_id != id
     end
 
     # Returns the +version+ at the supplied +datetime+ or +time+, or +self+ if there is none.
@@ -98,13 +98,8 @@ module Hoardable
       version.is_a?(version_class) ? version.revert! : self
     end
 
-    # Returns the +hoardable_source_id+ that represents the original {SourceModel} record’s ID. Will
-    # return nil if the current {SourceModel} record is not an instance of a {VersionModel} cast as
-    # {SourceModel}.
-    #
-    # @return [Integer, nil]
-    def hoardable_source_id
-      hoardable_client.hoardable_version_source_id || id
+    def hoardable_id
+      read_attribute('hoardable_id')
     end
 
     delegate :version_class, to: :class

data/lib/hoardable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hoardable
-  VERSION = '0.10.1'
+  VERSION = '0.12.2'
 end

data/lib/hoardable/version_model.rb

@@ -7,6 +7,13 @@ module Hoardable
     extend ActiveSupport::Concern
 
     class_methods do
+      # This is needed to allow {FinderMethods} to work with the version class.
+      #
+      # @!visibility private
+      def version_class
+        self
+      end
+
       # This is needed to omit the pseudo row of 'tableoid' when using +ActiveRecord+’s +insert+.
       #
       # @!visibility private
@@ -20,6 +27,7 @@ module Hoardable
       belongs_to(
         :hoardable_source,
         inverse_of: :versions,
+        foreign_key: :hoardable_id,
         class_name: superclass.model_name
       )
 
@@ -37,7 +45,7 @@ module Hoardable
       # Returns only trashed +versions+ that are currently orphans.
       scope :trashed, lambda {
         left_outer_joins(:hoardable_source)
-          .where(superclass.table_name => { id: nil })
+          .where(superclass.table_name => { superclass.primary_key => nil })
           .where(_operation: 'delete')
       }
 
@@ -78,7 +86,7 @@ module Hoardable
 
       transaction do
         hoardable_source.tap do |reverted|
-          reverted.update!(hoardable_source_attributes.without('id'))
+          reverted.update!(hoardable_source_attributes.without(self.class.superclass.primary_key))
           reverted.instance_variable_set(:@hoardable_version, self)
           reverted.run_callbacks(:reverted)
         end
@@ -113,24 +121,16 @@ module Hoardable
       _data&.dig('changes')
     end
 
-    # Returns the ID of the {SourceModel} that created this {VersionModel}
-    def hoardable_source_id
-      read_attribute('hoardable_source_id')
-    end
-
     private
 
     def insert_untrashed_source
       superscope = self.class.superclass.unscoped
-      superscope.insert(hoardable_source_attributes.merge('id' => hoardable_source_id))
-      superscope.find(hoardable_source_id)
+      superscope.insert(hoardable_source_attributes.merge(superscope.primary_key => hoardable_id))
+      superscope.find(hoardable_id)
     end
 
     def hoardable_source_attributes
-      @hoardable_source_attributes ||=
-        attributes_before_type_cast
-        .without('hoardable_source_id')
-        .reject { |k, _v| k.start_with?('_') }
+      attributes_before_type_cast.without(self.class.column_names - self.class.superclass.column_names)
     end
   end
 end

data/lib/hoardable.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
+require 'active_record'
 require_relative 'hoardable/version'
-require_relative 'hoardable/hoardable'
+require_relative 'hoardable/engine'
 require_relative 'hoardable/finder_methods'
 require_relative 'hoardable/scopes'
 require_relative 'hoardable/error'
@@ -10,5 +11,9 @@ require_relative 'hoardable/source_model'
 require_relative 'hoardable/version_model'
 require_relative 'hoardable/model'
 require_relative 'hoardable/associations'
+require_relative 'hoardable/has_many'
+require_relative 'hoardable/belongs_to'
+require_relative 'hoardable/has_one'
+require_relative 'hoardable/has_rich_text'
 require_relative 'generators/hoardable/migration_generator'
-require_relative 'generators/hoardable/initializer_generator'
+require_relative 'generators/hoardable/install_generator'

data/sig/hoardable.rbs

@@ -8,6 +8,7 @@ module Hoardable
   HOARDABLE_CALLBACKS_ENABLED: ^(untyped) -> untyped
   HOARDABLE_SAVE_TRASH: ^(untyped) -> untyped
   HOARDABLE_VERSION_UPDATES: ^(untyped) -> untyped
+  SUPPORTS_ENCRYPTED_ACTION_TEXT: untyped
   self.@context: Hash[untyped, untyped]
   self.@config: untyped
   self.@at: nil
@@ -17,8 +18,20 @@ module Hoardable
   def self.at: (untyped datetime) -> untyped
   def self.logger: -> untyped
 
+  class Engine
+  end
+
+  module FinderMethods
+    def find_one: (untyped id) -> untyped
+    def find_some: (untyped ids) -> untyped
+
+    private
+    def hoardable_ids: ([untyped] ids) -> Array[untyped]
+  end
+
   module Scopes
     TABLEOID_AREL_CONDITIONS: Proc
+    self.@klass: bot
 
     private
     def tableoid: -> untyped
@@ -30,22 +43,24 @@ module Hoardable
   class Error < StandardError
   end
 
-  class DatabaseClient
-    @hoardable_version_source_id: untyped
+  class CreatedAtColumnMissingError < Error
+    def initialize: (untyped source_table_name) -> void
+  end
 
+  class DatabaseClient
     attr_reader source_record: SourceModel
     def initialize: (SourceModel source_record) -> void
     def insert_hoardable_version: (untyped operation) -> untyped
+    def source_primary_key: -> untyped
     def find_or_initialize_hoardable_event_uuid: -> untyped
-    def hoardable_version_source_id: -> untyped
-    def query_hoardable_version_source_id: -> untyped
     def initialize_version_attributes: (untyped operation) -> untyped
+    def source_attributes_without_primary_key: -> untyped
     def initialize_temporal_range: -> Range
     def initialize_hoardable_data: -> untyped
     def assign_hoardable_context: (:event_uuid | :meta | :note | :whodunit key) -> nil
     def unset_hoardable_version_and_event_uuid: -> nil
     def previous_temporal_tsrange_end: -> untyped
-    def hoardable_source_epoch: -> Time
+    def hoardable_source_epoch: -> untyped
   end
 
   module SourceModel
@@ -55,9 +70,10 @@ module Hoardable
     attr_reader hoardable_version: untyped
     def trashed?: -> untyped
     def version?: -> untyped
-    def at: (untyped datetime) -> SourceModel
+    def at: (untyped datetime) -> SourceModel?
+    def version_at: (untyped datetime) -> untyped
     def revert_to!: (untyped datetime) -> SourceModel?
-    def hoardable_source_id: -> untyped
+    def hoardable_id: -> untyped
 
     private
     def hoardable_client: -> DatabaseClient
@@ -65,25 +81,19 @@ module Hoardable
     public
     def version_class: -> untyped
     def hoardable: -> untyped
-
-    module FinderMethods
-      def find_one: (untyped id) -> untyped
-    end
   end
 
   module VersionModel
-    @hoardable_source_attributes: untyped
-
     def revert!: -> untyped
     def untrash!: -> untyped
     def changes: -> untyped
-    def hoardable_source_id: -> untyped
 
     private
     def insert_untrashed_source: -> untyped
     def hoardable_source_attributes: -> untyped
 
     public
+    def version_class: -> VersionModel
     def scope_attributes: -> untyped
   end
 
@@ -98,10 +108,16 @@ module Hoardable
   end
 
   module Associations
-    def belongs_to_trashable: (untyped name, ?nil scope, **untyped) -> untyped
-    def has_many_hoardable: (untyped name, ?nil scope, **untyped) -> untyped
+    include HasRichText
+    include BelongsTo
+    include HasOne
+    include HasMany
+  end
 
-    module HasManyScope
+  module HasMany
+    def has_many: (*untyped args) -> untyped
+
+    module HasManyExtension
       @scope: untyped
       @association: bot
 
@@ -112,16 +128,41 @@ module Hoardable
     end
   end
 
+  module BelongsTo
+    def belongs_to: (*untyped args) -> nil
+
+    private
+    def hoardable_override_belongs_to: (untyped name) -> untyped
+  end
+
+  module HasOne
+    def has_one: (*untyped args) -> nil
+  end
+
+  module HasRichText
+    def has_rich_text: (untyped name, ?encrypted: false, ?hoardable: false) -> nil
+  end
+
   class MigrationGenerator
     @singularized_table_name: untyped
 
     def create_versions_table: -> untyped
     def foreign_key_type: -> String
-    def migration_template_name: -> String
+    def primary_key: -> String
     def singularized_table_name: -> untyped
   end
 
-  class InitializerGenerator
+  class InstallGenerator
     def create_initializer_file: -> untyped
+    def create_migration_file: -> untyped
+    def self.next_migration_number: (untyped dir) -> untyped
+  end
+
+  class RichText
+    include Model
+  end
+
+  class EncryptedRichText
+    include Model
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoardable
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.12.2
 platform: ruby
 authors:
 - justin talbott
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-07 00:00:00.000000000 Z
+date: 2022-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -104,17 +104,23 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/generators/hoardable/initializer_generator.rb
+- lib/generators/hoardable/install_generator.rb
 - lib/generators/hoardable/migration_generator.rb
+- lib/generators/hoardable/templates/install.rb.erb
 - lib/generators/hoardable/templates/migration.rb.erb
-- lib/generators/hoardable/templates/migration_6.rb.erb
 - lib/hoardable.rb
 - lib/hoardable/associations.rb
+- lib/hoardable/belongs_to.rb
 - lib/hoardable/database_client.rb
+- lib/hoardable/encrypted_rich_text.rb
+- lib/hoardable/engine.rb
 - lib/hoardable/error.rb
 - lib/hoardable/finder_methods.rb
-- lib/hoardable/hoardable.rb
+- lib/hoardable/has_many.rb
+- lib/hoardable/has_one.rb
+- lib/hoardable/has_rich_text.rb
 - lib/hoardable/model.rb
+- lib/hoardable/rich_text.rb
 - lib/hoardable/scopes.rb
 - lib/hoardable/source_model.rb
 - lib/hoardable/version.rb

data/lib/generators/hoardable/initializer_generator.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/generators'
-
-module Hoardable
-  # Generates an initializer file for {Hoardable} configuration.
-  class InitializerGenerator < Rails::Generators::Base
-    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
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-class Create<%= class_name.singularize %>Versions < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
-  def change
-    reversible do |dir|
-      dir.up do
-        execute <<~SQL
-          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
-    end
-    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
-      t.column :_operation, :hoardable_operation, null: false, index: true
-      t.<%= foreign_key_type %> :hoardable_source_id, null: false, index: true
-    end
-    execute(
-      <<~SQL
-        CREATE OR REPLACE FUNCTION hoardable_version_prevent_update() RETURNS trigger
-          LANGUAGE plpgsql AS
-        $$BEGIN
-          RAISE EXCEPTION 'updating a version is not allowed';
-          RETURN NEW;
-        END;$$;
-
-        CREATE TRIGGER <%= singularized_table_name %>_versions_prevent_update
-          BEFORE UPDATE ON <%= singularized_table_name %>_versions FOR EACH ROW
-          EXECUTE PROCEDURE hoardable_version_prevent_update();
-      SQL
-    )
-    add_index(:<%= singularized_table_name %>_versions, :id, unique: true)
-    add_index(
-      :<%= singularized_table_name %>_versions,
-      %i[_during hoardable_source_id],
-      name: 'idx_<%= singularized_table_name %>_versions_temporally'
-    )
-  end
-end