hoardable 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dad9a103d70ce10905528d1d7e56e67a4a8fb89e675b3097165ccede6262a015
-  data.tar.gz: a2dc95873a08175254cca315caa3de9b087674df1e4dadd17f42fb26a9080a9d
+  metadata.gz: 2d9f9ea3a4559d3a4515357eabc0c7ee05526ee1308a4e6eef111f2d6207aef6
+  data.tar.gz: be0011cb1ea9d3fcdcd5d1a4f4951d7185371cc1d05c91dfd27ea163b59620b7
 SHA512:
-  metadata.gz: 02b542ba1fe562750eb16bf6f310b08e2340610e01e7db68eaedb9185e4da4a1d7e7a5a42885fb09376759bf936b8b527de4bedec8399b71119541162e57604f
-  data.tar.gz: 77edd48d420fea18333996280d6e31e0daba198b96e67fdc49b4fc7fe1884cb86cc88416e1f486691e2292465818fb50e3c4fc4367d83cc6d751d0adcb39acf6
+  metadata.gz: 20ebc8d7ec2924e43e6bbd806e7aaf08350653b695dc4aef16de28359ceb95d8de16da4c19790e8b1212bc8d8d202caeb3614e05b326977bd470defe48e4b731
+  data.tar.gz: fc3fa92ae0ab25bee4122456b889f86eec75b0eee4efba742dced8737d7bc9ab3a99e63e63839f49089183900df8ed54a315a4561aad634c0e2ea3fa56aa8732

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.
 
@@ -371,7 +372,7 @@ If you are ever unsure if a Hoardable record is a "source" or a "version", you c
 calling `version?` on it. If you want to get the true original source record ID, you can call
 `hoardable_source_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
 ```
 
+## ActionText
+
+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
+assert_equal post.content.to_plain_text, 'Goodbye Cruel World'
+Hoardable.at(datetime) do
+  assert_equal 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 'functions.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/templates/functions.rb.erb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class InstallHoardable < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def up
+    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;$$;
+      SQL
+    )
+  end
+end

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

@@ -1,6 +1,6 @@
 # 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]
     create_table :<%= singularized_table_name %>_versions, id: false, options: 'INHERITS (<%= table_name %>)' do |t|
@@ -10,20 +10,25 @@ class Create<%= class_name.singularize %>Versions < ActiveRecord::Migration[<%=
       t.enum :_operation, enum_type: '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
-    )
+    reversible do |dir|
+      dir.up do
+        execute(
+          <<~SQL
+            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
+        )
+      end
+      dir.down do
+        execute(
+          <<~SQL
+            DROP TRIGGER <%= singularized_table_name %>_versions_prevent_update
+              ON <%= singularized_table_name %>_versions;
+          SQL
+        )
+      end
+    end
     add_index(:<%= singularized_table_name %>_versions, :id, unique: true)
     add_index(
       :<%= singularized_table_name %>_versions,

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

@@ -1,6 +1,6 @@
 # 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
     reversible do |dir|
       dir.up do
@@ -25,20 +25,25 @@ class Create<%= class_name.singularize %>Versions < ActiveRecord::Migration[<%=
       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
-    )
+    reversible do |dir|
+      dir.up do
+        execute(
+          <<~SQL
+            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
+        )
+      end
+      dir.down do
+        execute(
+          <<~SQL
+            DROP TRIGGER <%= singularized_table_name %>_versions_prevent_update
+              ON <%= singularized_table_name %>_versions;
+          SQL
+        )
+      end
+    end
     add_index(:<%= singularized_table_name %>_versions, :id, unique: true)
     add_index(
       :<%= singularized_table_name %>_versions,

data/lib/hoardable/associations.rb

@@ -7,104 +7,12 @@ 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
+      include HasOneAttached
     end
   end
 end

data/lib/hoardable/attachment.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # A {Hoardable} subclass of {ActiveStorage::Attachment}
+  class Attachment < ActiveStorage::Attachment
+    include Model
+
+    class CreateOne < ActiveStorage::Attached::Changes::CreateOne
+      private
+
+      def build_attachment
+        Attachment.new(record: record, name: name, blob: blob)
+      end
+    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_source_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/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,22 @@ 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
+
+    initializer 'hoardable.active_storage' do
+      ActiveSupport.on_load(:active_storage_attachment) do
+        require_relative 'attachment'
+      end
+    end
+  end
 end

data/lib/hoardable/has_many.rb

@@ -0,0 +1,45 @@
+# 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_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
+
+    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_one_attached.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # Provides temporal version awareness for +ActionText+.
+  module HasOneAttached
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_one_attached(name, **options, &block)
+        hoardable = options.delete(:hoardable)
+        super(name, **options, &block)
+        return unless hoardable
+
+        'ActiveStorage::Attachment'.constantize
+        reflection_options = reflections["#{name}_attachment"].options
+        reflection_options[:class_name] = reflection_options[:class_name].sub(/ActiveStorage/, 'Hoardable')
+
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
+          def #{name}=(attachable)
+            attachment_changes["#{name}"] =
+              if attachable.nil?
+                ActiveStorage::Attached::Changes::DeleteOne.new("#{name}", self)
+              else
+                Hoardable::Attachment::CreateOne.new("#{name}", self, attachable)
+              end
+          end
+        CODE
+      end
+    end
+  end
+  private_constant :HasOneAttached
+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/source_model.rb

@@ -32,6 +32,8 @@ module Hoardable
       include Scopes
 
       around_update(if: [HOARDABLE_CALLBACKS_ENABLED, HOARDABLE_VERSION_UPDATES]) do |_, block|
+        next if self.is_a?(Hoardable::Attachment)
+
         hoardable_client.insert_hoardable_version('update', &block)
       end
 

data/lib/hoardable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hoardable
-  VERSION = '0.10.1'
+  VERSION = '0.11.0'
 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,10 @@ 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 'hoardable/has_one_attached'
 require_relative 'generators/hoardable/migration_generator'
-require_relative 'generators/hoardable/initializer_generator'
+require_relative 'generators/hoardable/install_generator'

data/sig/hoardable.rbs

@@ -17,8 +17,17 @@ module Hoardable
   def self.at: (untyped datetime) -> untyped
   def self.logger: -> untyped
 
+  module FinderMethods
+    def find_one: (untyped id) -> untyped
+    def find_some: (untyped ids) -> untyped
+
+    private
+    def hoardable_source_ids: ([untyped] ids) -> Array[untyped]
+  end
+
   module Scopes
     TABLEOID_AREL_CONDITIONS: Proc
+    self.@klass: bot
 
     private
     def tableoid: -> untyped
@@ -30,6 +39,10 @@ module Hoardable
   class Error < StandardError
   end
 
+  class CreatedAtColumnMissingError < Error
+    def initialize: (untyped source_table_name) -> void
+  end
+
   class DatabaseClient
     @hoardable_version_source_id: untyped
 
@@ -45,7 +58,7 @@ module Hoardable
     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,7 +68,8 @@ 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
 
@@ -65,10 +79,6 @@ module Hoardable
     public
     def version_class: -> untyped
     def hoardable: -> untyped
-
-    module FinderMethods
-      def find_one: (untyped id) -> untyped
-    end
   end
 
   module VersionModel
@@ -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
+    @hoardable_association_overrider: Overrider
+
+    def belongs_to: (*untyped args) -> nil
+    def has_one: (*untyped args) -> nil
+    def has_many: (*untyped args) -> untyped
+
+    private
+    def hoardable_association_overrider: -> Overrider
 
-    module HasManyScope
+    module HasManyExtension
       @scope: untyped
       @association: bot
 
@@ -110,6 +126,14 @@ module Hoardable
       private
       def hoardable_scope: -> untyped
     end
+
+    class Overrider
+      attr_reader klass: Associations
+      def initialize: (Associations klass) -> void
+      def override_belongs_to: (untyped name) -> untyped
+      def override_has_one: (untyped name) -> untyped
+      def override_has_many: (untyped name) -> untyped
+    end
   end
 
   class MigrationGenerator
@@ -121,7 +145,9 @@ module Hoardable
     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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoardable
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - justin talbott
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-07 00:00:00.000000000 Z
+date: 2022-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -104,17 +104,26 @@ 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/functions.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/attachment.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_one_attached.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