historiographer 4.1.4 → 4.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec4560a7984db99bb67a91f6ed46ffd5e0e0b68b208b9f5c56079d5d0c967c06
-  data.tar.gz: 558f4f69363da666c55ad58bdf4aa1108e405c96d54e2ae4d96f4d7baa87e4a0
+  metadata.gz: fdfddfba56fcb69bb91c73edcf7c1ddff76adc25f517d4b225bcf87bdd356540
+  data.tar.gz: 01e398edc375e2bcf17f22a81c4eb06ab2d507483b05db80b8014ea291f2ac82
 SHA512:
-  metadata.gz: 803285240c47f720ae89ba027d1143e7b0e63ed765bb26399b7d126e2c04449664604a7488553f8996f89c3736d86909ed52702fcc5fb4bf7df2cb2fa5de4a44
-  data.tar.gz: 263c7cd005f3cd3589a1ed47c62d7127844686c5b945e1835995b99151b0bbceb6b72c86bac80e09b17efde796e3eeef2b34a0d9f33fb99945915e14b1c9aef8
+  metadata.gz: 64b288645843cad4862b06724619ec8c98405745b4d6ba572d00baabbc1ce0d4f706cbf95b42c7e1e6214c870ac0c335fb37ea760f599830037f11a94cf5443e
+  data.tar.gz: '09663a6452efd27ce2f566b3764e7dd9f29499a61cb5eecc7b488e8fe31270d57a6ceb84489de983cbd4851ac8906cf6140127113ef06751fc6cb19839821906'

data/README.md

@@ -137,7 +137,7 @@ Historiographer fully supports Single Table Inheritance, both with the default `
 ### Default STI with `type` column
 
 ```ruby
-class Post < ApplicationRecord
+class Post < ActiveRecord::Base
   include Historiographer
 end
 
@@ -145,7 +145,7 @@ class PrivatePost < Post
 end
 
 # The history classes follow the same inheritance pattern:
-class PostHistory < ApplicationRecord
+class PostHistory < ActiveRecord::Base
   include Historiographer::History
 end
 
@@ -170,9 +170,9 @@ history.type #=> "PrivatePostHistory"
 You can also use a custom column for STI instead of the default `type`:
 
 ```ruby
-class MLModel < ApplicationRecord
-  include Historiographer
+class MLModel < ActiveRecord::Base
   self.inheritance_column = :model_type
+  include Historiographer
 end
 
 class XGBoost < MLModel
@@ -291,12 +291,45 @@ trained_version = model.histories.find_by(metadata: { stage: "post_training" })
 ```
 
 This combination of STI and snapshots is particularly valuable for:
+
 - Model governance and compliance
 - A/B testing different model types
 - Debugging model behavior
 - Reproducing historical predictions
 - Maintaining audit trails for regulatory requirements
 
+## Namespaced Models
+
+When using namespaced models, Rails handles foreign key naming differently than with non-namespaced models. For example, if you have a model namespaced like this:
+
+```ruby
+module EasyML
+  class Dataset
+     self.table_name = "easy_ml_datasets"
+  end
+end
+```
+
+Rails will expect foreign keys to be formatted using just the model name (without the namespace) like this:
+
+```ruby
+:dataset_id
+```
+
+Therefore, when creating history migrations for namespaced models, you need to specify the foreign key name explicitly:
+
+```ruby
+class CreateEasyMLDatasetHistories < ActiveRecord::Migration
+  def change
+    create_table :easy_ml_dataset_histories do |t|
+      t.histories(foreign_key: :dataset_id) # instead of using the table name — easy_ml_dataset_id
+    end
+  end
+end
+```
+
+This ensures that the foreign key relationships are properly established between your namespaced models and their history tables.
+
 ## Getting Started
 
 Whenever you include the `Historiographer` gem in your ActiveRecord model, it allows you to insert, update, or delete data as you normally would.
@@ -305,6 +338,11 @@ Whenever you include the `Historiographer` gem in your ActiveRecord model, it al
 class Post < ActiveRecord::Base
   include Historiographer
 end
+
+class PostHistory < ActiveRecord::Base
+  self.table_name = "post_histories"
+  include Historiographer::History
+end
 ```
 
 ### History Modes
@@ -337,6 +375,29 @@ class Comment < ActiveRecord::Base
 end
 ```
 
+The class-level mode setting takes precedence over the global configuration. This allows you to:
+
+- Have different history tracking strategies for different models
+- Set most models to use snapshots while keeping detailed history for critical models
+- Optimize storage by only tracking detailed history where needed
+
+For example:
+
+```ruby
+# Global setting for most models
+Historiographer::Configuration.mode = :snapshot_only
+
+class Order < ActiveRecord::Base
+  include Historiographer
+  # Uses global :snapshot_only mode
+end
+
+class Payment < ActiveRecord::Base
+  include Historiographer
+  historiographer_mode :histories  # Override to record histories of every change
+end
+```
+
 ## Create A Migration
 
 You need a separate table to store histories for each model.
@@ -391,12 +452,18 @@ The primary model should include `Historiographer`:
 class Post < ActiveRecord::Base
   include Historiographer
 end
+
+class PostHistory < ActiveRecord::Base
+  self.table_name = "post_histories"
+  include Historiographer::History
+end
 ```
 
 You should also make a `PostHistory` class if you're going to query `PostHistory` from Rails:
 
 ```ruby
 class PostHistory < ActiveRecord::Base
+  self.table_name = "post_histories"
 end
 ```
 

data/lib/historiographer/history.rb

@@ -61,6 +61,7 @@ module Historiographer
     extend ActiveSupport::Concern
 
     included do |base|
+      clear_validators!
       #
       # A History class (e.g. RetailerProductHistory) will gain
       # access to a current scope, returning
@@ -91,6 +92,67 @@ module Historiographer
       foreign_class = foreign_class_name.constantize
       association_name   = foreign_class_name.split("::").last.underscore.to_sym # e.g. "RetailerProduct" => :retailer_product
 
+      # Store the original class for method delegation
+      class_variable_set(:@@original_class, foreign_class)
+
+      # Add method_added hook to the original class
+      foreign_class.singleton_class.class_eval do
+        # Keep track of original method_added if it exists
+        if method_defined?(:method_added)
+          alias_method :original_method_added, :method_added
+        end
+
+        method_map = Hash.new(0)
+        define_method(:method_added) do |method_name|
+          # Skip if we're already in the process of defining a method
+          return if Thread.current[:defining_historiographer_method]
+
+          begin
+            Thread.current[:defining_historiographer_method] = true
+            
+            # Call original method_added if it exists
+            original_method_added(method_name) if respond_to?(:original_method_added)
+
+            # Get the method object to check if it's from our class (not inherited)
+            method_obj = instance_method(method_name)
+            return unless method_obj.owner == self
+
+            # Skip if we've already defined this method in the history class
+            return if foreign_class.history_class.method_defined?(method_name)
+
+            # Define the method in the history class
+            foreign_class.history_class.class_eval do
+              define_method(method_name) do |*args, &block|
+                forward_method(method_name, *args, &block)
+              end
+            end
+          ensure
+            Thread.current[:defining_historiographer_method] = false
+          end
+        end
+      end
+
+      foreign_class.columns.map(&:name).each do |method_name|
+        define_method(method_name) do |*args, &block|
+          forward_method(method_name, *args, &block)
+        end
+      end
+
+      # Add method_missing for any methods we might have missed
+      def method_missing(method_name, *args, &block)
+        original_class = self.class.class_variable_get(:@@original_class)
+        if original_class.method_defined?(method_name)
+          forward_method(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        original_class = self.class.class_variable_get(:@@original_class)
+        original_class.method_defined?(method_name) || super
+      end
+
       #
       # Historiographer will automatically setup the association
       # to the primary class (e.g. RetailerProduct)
@@ -147,19 +209,19 @@ module Historiographer
       #
       # If the record was not already persisted, proceed as normal.
       #
-      def save(*args)
+      def save(*args, **kwargs)
         if persisted? && (changes.keys - %w(history_ended_at snapshot_id)).any?
           false
         else
-          super
+          super(*args, **kwargs)
         end
       end
 
-      def save!(*args)
+      def save!(*args, **kwargs)
         if persisted? && (changes.keys - %w(history_ended_at snapshot_id)).any?
           false
         else
-          super
+          super(*args, **kwargs)
         end
       end
 
@@ -167,11 +229,66 @@ module Historiographer
       # Orders by history_started_at and id to handle cases where multiple records
       # have the same history_started_at timestamp
       scope :latest_snapshot, -> {
-        where.not(snapshot_id: nil).order('id DESC').limit(1)&.first || none
+        where.not(snapshot_id: nil)
+          .select('DISTINCT ON (snapshot_id) *')
+          .order('snapshot_id, history_started_at DESC, id DESC')
       }
+
+      # Dynamically define associations on the history class
+      foreign_class.reflect_on_all_associations.each do |association|
+        define_history_association(association)
+      end
+
     end
 
     class_methods do
+      def original_class
+        unless class_variable_defined?(:@@original_class)
+          class_variable_set(:@@original_class, self.name.gsub(/History$/, '').constantize)
+        end
+
+        class_variable_get(:@@original_class)
+      end
+
+      def define_history_association(association)
+        if association.is_a?(Symbol) || association.is_a?(String)
+          association = original_class.reflect_on_association(association)
+        end
+        assoc_name = association.name
+        assoc_history_class_name = "#{association.class_name}History"
+        assoc_foreign_key = association.foreign_key
+
+        # Skip if the association is already defined
+        return if method_defined?(assoc_name)
+
+        # Skip through associations to history classes to avoid infinite loops
+        return if association.class_name.end_with?('History')
+
+        # We're writing a belongs_to
+        # The dataset belongs_to the datasource
+        # dataset#datasource_id => datasource.id
+        # 
+        # For the history class, we're writing a belongs_to
+        # the DatasetHistory belongs_to the DatasourceHistory
+        # dataset_history#datasource_id => datasource_history.easy_ml_datasource_id
+        #
+        # The missing piece for us here is whatever DatasourceHistory would call easy_ml_datasource_id (history foreign key?)
+
+        case association.macro
+        when :belongs_to
+          belongs_to assoc_name, ->(history_instance) {
+            where(snapshot_id: history_instance.snapshot_id)
+          }, class_name: assoc_history_class_name, foreign_key: assoc_foreign_key, primary_key: assoc_foreign_key
+        when :has_one
+          has_one assoc_name, ->(history_instance) {
+            where(snapshot_id: history_instance.snapshot_id)
+          }, class_name: assoc_history_class_name, foreign_key: assoc_foreign_key, primary_key: history_foreign_key
+        when :has_many
+          has_many assoc_name, ->(history_instance) {
+            where(snapshot_id: history_instance.snapshot_id)
+          }, class_name: assoc_history_class_name, foreign_key: assoc_foreign_key, primary_key: history_foreign_key
+        end
+      end
       #
       # The foreign key to the primary class.
       #
@@ -180,7 +297,8 @@ module Historiographer
       def history_foreign_key
         return @history_foreign_key if @history_foreign_key
 
-        @history_foreign_key = sti_base_class.table_name.singularize.foreign_key
+        # CAN THIS BE TABLE OR MODEL?
+        @history_foreign_key = sti_base_class.name.singularize.foreign_key
       end
 
       def sti_base_class
@@ -194,5 +312,30 @@ module Historiographer
         @sti_base_class = base_class
       end
     end
+
+    def original_class
+      self.class.original_class
+    end
+
+  private
+    def dummy_instance
+      return @dummy_instance if @dummy_instance
+
+      cannot_keep_cols = %w(history_started_at history_ended_at history_user_id snapshot_id)
+      cannot_keep_cols += [self.class.inheritance_column.to_sym] if self.original_class.sti_enabled?
+      cannot_keep_cols += [self.class.history_foreign_key] 
+      cannot_keep_cols.map!(&:to_s)
+
+      attrs = attributes.clone
+      attrs[original_class.primary_key] = attrs[self.class.history_foreign_key]
+
+      instance = original_class.find_or_initialize_by(original_class.primary_key => attrs[original_class.primary_key])
+      instance.assign_attributes(attrs.except(*cannot_keep_cols))
+      @dummy_instance = instance
+    end
+
+    def forward_method(method_name, *args, &block)
+      dummy_instance.send(method_name, *args, &block)
+    end
   end
 end

data/lib/historiographer/history_migration.rb

@@ -16,10 +16,11 @@ module Historiographer
     # Will automatically add user_id, history_started_at,
     # and history_ended_at columns
     #
-    def histories(except: [], only: [], no_business_columns: false, index_names: {})
+    def histories(except: [], only: [], no_business_columns: false, index_names: {}, foreign_key: nil)
       index_names.symbolize_keys!
-      original_table_name = self.name.gsub(/_histories$/) {}.pluralize
-      foreign_key         = original_table_name.singularize.foreign_key
+      history_table_name = self.name
+      original_table_name = history_table_name.gsub(/_histories$/) {}.pluralize
+      foreign_key ||= original_table_name.singularize.foreign_key
 
       class_definer = Class.new(ActiveRecord::Base) do
       end

data/lib/historiographer/version.rb

@@ -1,3 +1,3 @@
 module Historiographer
-  VERSION = "4.1.4"
+  VERSION = "4.1.7"
 end

data/lib/historiographer.rb

@@ -85,7 +85,6 @@ module Historiographer
     after_save :record_history, if: :should_record_history?
     validate :validate_history_user_id_present, if: :should_validate_history_user_id_present?
 
-
     def should_alert_history_user_id_present?
       !snapshot_mode? && !is_history_class? && Thread.current[:skip_history_user_id_validation] != true
     end
@@ -184,15 +183,15 @@ module Historiographer
 
     begin
       class_name.constantize
-    rescue StandardError
+    rescue NameError
       # Get the base table name without _histories suffix
-      base_table = base.table_name.sub(/_histories$/, '')
+      base_table = base.table_name.singularize.sub(/_histories$/, '')
       
-      history_class_initializer = Class.new(base) do
+      history_class_initializer = Class.new(ActiveRecord::Base) do
         self.table_name = "#{base_table}_histories"
         
         # Handle STI properly
-        self.inheritance_column = base.inheritance_column if base.respond_to?(:inheritance_column)
+        self.inheritance_column = base.inheritance_column if base.sti_enabled?
       end
 
       # Split the class name into module parts and the actual class name
@@ -217,63 +216,22 @@ module Historiographer
     base.singleton_class.prepend(Module.new do
       def belongs_to(name, scope = nil, **options, &extension)
         super
-        define_history_association(name, :belongs_to, options)
+        history_class.define_history_association(name)
       end
 
       def has_one(name, scope = nil, **options, &extension)
         super
-        define_history_association(name, :has_one, options)
+        history_class.define_history_association(name)
       end
 
       def has_many(name, scope = nil, **options, &extension)
         super
-        define_history_association(name, :has_many, options)
+        history_class.define_history_association(name)
       end
 
       def has_and_belongs_to_many(name, scope = nil, **options, &extension)
         super
-        define_history_association(name, :has_and_belongs_to_many, options)
-      end
-
-      private
-
-      def define_history_association(name, type, options)
-        return if is_history_class?
-        return if @defining_association
-        return if %i[histories current_history].include?(name)
-        @defining_association = true
-
-        history_class = "#{self.name}History".constantize
-        history_class_name = "#{name.to_s.singularize.camelize}History"
-
-        # Get the original association's foreign key
-        original_reflection = self.reflect_on_association(name)
-        foreign_key = original_reflection.foreign_key
-
-        if type == :has_many || type == :has_and_belongs_to_many
-          history_class.send(
-            type, 
-            name, 
-            -> (owner) { where("#{name.to_s.singularize}_histories.snapshot_id = ?", owner.snapshot_id) }, 
-            **options.merge(
-              class_name: history_class_name, 
-              foreign_key: foreign_key,
-              primary_key: foreign_key
-            )
-          )
-        else
-          history_class.send(
-            type, 
-            name, 
-            -> (owner) { where("#{name}_histories.snapshot_id = ?", owner.snapshot_id) }, 
-            **options.merge(
-              class_name: history_class_name, 
-              foreign_key: foreign_key,
-              primary_key: foreign_key
-            )
-          )
-        end
-        @defining_association = false
+        history_class.define_history_association(name)
       end
     end)
 
@@ -318,7 +276,6 @@ module Historiographer
       save!(*args, &block)
       @no_history = false
     end
-
     
     def snapshot(tree = {}, snapshot_id = nil)
       return if is_history_class?
@@ -334,15 +291,16 @@ module Historiographer
         return if existing_snapshot.present?
 
         null_snapshot = history_class.where(foreign_key => attrs[primary_key], snapshot_id: nil)
+        snapshot = nil
         if null_snapshot.present?
-          null_snapshot.update(snapshot_id: snapshot_id)
+          snapshot = null_snapshot.update(snapshot_id: snapshot_id)
         else
-          record_history(snapshot_id: snapshot_id)
+          snapshot = record_history(snapshot_id: snapshot_id)
         end
 
         # Recursively snapshot associations, avoiding infinite loops
         self.class.reflect_on_all_associations.each do |association|
-          associated_records = send(association.name).reload
+          associated_records = send(association.name)&.reload
           Array(associated_records).each do |record|
             model_name = record.class.name
             record_id = record.id
@@ -356,6 +314,8 @@ module Historiographer
             record.snapshot(new_tree, snapshot_id) if record.respond_to?(:snapshot)
           end
         end
+
+        snapshot
       end
     end
 
@@ -383,6 +343,14 @@ module Historiographer
       attrs
     end
 
+    def snapshots
+      histories.where.not(snapshot_id: nil)
+    end
+
+    def latest_snapshot
+      snapshots.order('id DESC').limit(1)&.first || history_class.none
+    end
+
     private
 
     def history_user_absent_action
@@ -403,7 +371,7 @@ module Historiographer
       current_history = histories.where(history_ended_at: nil).order('id desc').limit(1).last
 
       if history_class.history_foreign_key.present? && history_class.present?
-        history_class.create!(attrs).tap do |history|
+        history_class.create!(attrs).tap do |new_history|
           current_history.update!(history_ended_at: now) if current_history.present?
         end
       else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: historiographer
 version: !ruby/object:Gem::Version
-  version: 4.1.4
+  version: 4.1.7
 platform: ruby
 authors:
 - brettshollenberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-19 00:00:00.000000000 Z
+date: 2024-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord