historiographer 4.4.1 → 4.4.3

data/lib/historiographer/history.rb

@@ -78,11 +78,24 @@ module Historiographer
       # "RetailerProductHistory."
       #
       foreign_class_name = base.name.gsub(/History$/) {}        # e.g. "RetailerProductHistory" => "RetailerProduct"
-      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)
+      # Defer foreign class resolution to avoid load order issues
+      base.define_singleton_method :foreign_class do
+        return class_variable_get(:@@foreign_class) if class_variable_defined?(:@@foreign_class)
+        begin
+          foreign_class = foreign_class_name.constantize
+          class_variable_set(:@@foreign_class, foreign_class)
+          foreign_class
+        rescue NameError => e
+          # If the class isn't loaded yet, return nil and it will be retried later
+          nil
+        end
+      end
+
+      # Store the foreign class name for later use
+      class_variable_set(:@@foreign_class_name, foreign_class_name)
+      class_variable_set(:@@association_name, association_name)
 
       #
       # A History class will be linked to the user
@@ -94,12 +107,20 @@ module Historiographer
       #
       # To use histories, a user class must be defined.
       #
-      unless foreign_class.ancestors.include?(Historiographer::Silent)
+      # Set up user association unless Silent module is included
+      # Defer this check until foreign_class is available
+      unless base.foreign_class && base.foreign_class.ancestors.include?(Historiographer::Silent)
         belongs_to :user, foreign_key: :history_user_id
       end
 
-      # Add method_added hook to the original class
-      foreign_class.singleton_class.class_eval do
+      # Add method_added hook to the original class when it's available
+      # This needs to be deferred until the foreign class is loaded
+      base.define_singleton_method :setup_method_delegation do
+        return unless foreign_class
+        return if class_variable_defined?(:@@method_delegation_setup) && class_variable_get(:@@method_delegation_setup)
+        class_variable_set(:@@method_delegation_setup, true)
+        
+        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
@@ -120,9 +141,9 @@ module Historiographer
             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)
+            return if self.history_class.method_defined?(method_name)
 
-            foreign_class.history_class.class_eval do
+            self.history_class.class_eval do
               define_method(method_name) do |*args, **kwargs, &block|
                 forward_method(method_name, *args, **kwargs, &block)
               end
@@ -133,16 +154,30 @@ module Historiographer
         end
       end
 
-      (foreign_class.columns.map(&:name) - ["id"]).each do |method_name|
-        define_method(method_name) do |*args, **kwargs, &block|
-          forward_method(method_name, *args, **kwargs, &block)
+      begin
+        end
+      end
+      
+      # Try to set up method delegation if foreign class is available
+      base.setup_method_delegation if base.foreign_class
+      
+      # Also delegate existing methods from the foreign class
+      if base.foreign_class
+        begin
+          (base.foreign_class.columns.map(&:name) - ["id"]).each do |method_name|
+            define_method(method_name) do |*args, **kwargs, &block|
+              forward_method(method_name, *args, **kwargs, &block)
+            end
+          end
+        rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+          # Table might not exist yet during setup
         end
       end
 
       # Add method_missing for any methods we might have missed
       def method_missing(method_name, *args, **kwargs, &block)
-        original_class = self.class.class_variable_get(:@@original_class)
-        if original_class.method_defined?(method_name)
+        original_class = self.class.foreign_class
+        if original_class && original_class.method_defined?(method_name)
           forward_method(method_name, *args, **kwargs, &block)
         else
           super
@@ -150,8 +185,8 @@ module Historiographer
       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
+        original_class = self.class.foreign_class
+        (original_class && original_class.method_defined?(method_name)) || super
       end
 
       #
@@ -233,9 +268,59 @@ module Historiographer
       # Track custom association methods
       base.class_variable_set(:@@history_association_methods, [])
       
-      # Dynamically define associations on the history class
-      foreign_class.reflect_on_all_associations.each do |association|
-        define_history_association(association)
+      # Register this history class to have its associations set up after initialization
+      history_classes = Thread.current[:historiographer_history_classes] ||= []
+      history_classes << base
+      
+      # Always define the setup_history_associations method
+      base.define_singleton_method :setup_history_associations do |force = false|
+        return if !force && class_variable_defined?(:@@associations_set_up) && class_variable_get(:@@associations_set_up)
+        class_variable_set(:@@associations_set_up, true)
+        
+        return unless foreign_class
+        
+        # Also set up method delegation if not already done
+        setup_method_delegation if respond_to?(:setup_method_delegation)
+        
+        foreign_class.reflect_on_all_associations.each do |association|
+          begin
+            define_history_association(association)
+          rescue => e
+            # Log but don't fail
+            puts "Warning: Could not define history association #{association.name}: #{e.message}" if ENV['DEBUG']
+          end
+        end
+      end
+      
+      # Set up the after_initialize hook if we're in a Rails app
+      if defined?(Rails) && Rails.respond_to?(:application) && Rails.application && Rails.application.config.respond_to?(:after_initialize)
+        Rails.application.config.after_initialize do
+          history_classes.each do |history_class|
+            history_class.setup_method_delegation if history_class.respond_to?(:setup_method_delegation)
+            history_class.setup_history_associations
+          end
+        end
+      else
+        # For non-Rails environments, try to set up associations immediately
+        
+        # Try to set up now if possible
+        begin
+          base.setup_history_associations
+        rescue => e
+          # Will retry later
+        end
+        
+        # Override reflect_on_association to ensure associations are defined
+        base.define_singleton_method :reflect_on_association do |name|
+          setup_history_associations rescue nil
+          super(name)
+        end
+        
+        # Override reflect_on_all_associations to ensure associations are defined
+        base.define_singleton_method :reflect_on_all_associations do |*args|
+          setup_history_associations rescue nil
+          super(*args)
+        end
       end
 
       def snapshot
@@ -254,93 +339,140 @@ module Historiographer
       end
 
       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)
+        # Use the foreign_class method we defined earlier
+        foreign_class
       end
 
       def define_history_association(association)
         if association.is_a?(Symbol) || association.is_a?(String)
           association = original_class.reflect_on_association(association)
+          # If the association doesn't exist on the original class, skip it
+          return unless association
         end
+        
         assoc_name = association.name
-        assoc_module = association.active_record.module_parent
-        assoc_history_class_name = "#{association.class_name}History"
-
-        begin
-          assoc_module.const_get(assoc_history_class_name)
-          assoc_history_class_name = "#{assoc_module}::#{assoc_history_class_name}" unless assoc_history_class_name.match?(Regexp.new("#{assoc_module}::"))
-        rescue
-        end
-
         assoc_foreign_key = association.foreign_key
 
         # Skip through associations to history classes to avoid infinite loops
         return if association.class_name.end_with?('History')
 
-        # Always use the history class if it exists
-        assoc_class = assoc_history_class_name.safe_constantize || OpenStruct.new(name: association.class_name)
-        assoc_class_name = assoc_class.name
+        # Get the associated model's table name
+        original_assoc_class = association.class_name.safe_constantize
+        return unless original_assoc_class  # Can't proceed without the class
+        
+        assoc_table_name = original_assoc_class.table_name
+        history_table_name = "#{assoc_table_name.singularize}_histories"
+        
+        # Check if a history table exists for this association
+        has_history_table = ActiveRecord::Base.connection.tables.include?(history_table_name)
+        
+        if has_history_table
+          # This model has history tracking, use the history class
+          assoc_history_class_name = "#{association.class_name}History"
+          assoc_module = association.active_record.module_parent
+          
+          begin
+            assoc_module.const_get(assoc_history_class_name)
+            assoc_history_class_name = "#{assoc_module}::#{assoc_history_class_name}" unless assoc_history_class_name.match?(Regexp.new("#{assoc_module}::"))
+          rescue
+          end
+          
+          assoc_class = assoc_history_class_name.safe_constantize || OpenStruct.new(name: assoc_history_class_name)
+          assoc_class_name = assoc_class.name
+        else
+          # No history table, use the original model
+          assoc_class_name = association.class_name
+        end
 
         case association.macro
         when :belongs_to
-          # For belongs_to associations, if the target is a history class, we need special handling
+          # Start with all original association options
+          options = association.options.dup
+          
+          # Override the class name and foreign key
+          options[:class_name] = assoc_class_name
+          options[:foreign_key] = assoc_foreign_key
+          
+          # For history associations, we need to handle snapshot filtering differently
+          # We'll create the association but override the accessor method
           if assoc_class_name.match?(/History/)
-            # Override the association method to filter by snapshot_id
-            # The history class uses <model>_id as the foreign key (e.g., author_id for AuthorHistory)
-            history_fk = association.class_name.gsub(/History$/, '').underscore + '_id'
+            # Create the Rails association first
+            belongs_to assoc_name, **options
             
-            # Track this custom method
-            methods_list = class_variable_get(:@@history_association_methods) rescue []
-            methods_list << assoc_name
-            class_variable_set(:@@history_association_methods, methods_list)
+            # Then override the accessor to filter by snapshot_id
+            history_fk = association.class_name.gsub(/History$/, '').underscore + '_id'
             
-            define_method(assoc_name) do
+            define_method("#{assoc_name}_with_snapshot") do
               return nil unless self[assoc_foreign_key]
               assoc_class.where(
                 history_fk => self[assoc_foreign_key],
                 snapshot_id: self.snapshot_id
               ).first
             end
+            
+            # Alias the original method and replace it
+            alias_method "#{assoc_name}_without_snapshot", assoc_name
+            alias_method assoc_name, "#{assoc_name}_with_snapshot"
           else
-            belongs_to assoc_name, class_name: assoc_class_name, foreign_key: assoc_foreign_key
+            belongs_to assoc_name, **options
           end
         when :has_one
+          # Start with all original association options
+          options = association.options.dup
+          
+          # Override the class name and keys
+          options[:class_name] = assoc_class_name
+          options[:foreign_key] = assoc_foreign_key
+          options[:primary_key] = history_foreign_key
+          
           if assoc_class_name.match?(/History/)
-            hfk = history_foreign_key
+            # Create the Rails association first
+            has_one assoc_name, **options
             
-            # Track this custom method
-            methods_list = class_variable_get(:@@history_association_methods) rescue []
-            methods_list << assoc_name
-            class_variable_set(:@@history_association_methods, methods_list)
+            # Then override the accessor to filter by snapshot_id
+            hfk = history_foreign_key
             
-            define_method(assoc_name) do
+            define_method("#{assoc_name}_with_snapshot") do
               assoc_class.where(
                 assoc_foreign_key => self[hfk],
                 snapshot_id: self.snapshot_id
               ).first
             end
+            
+            # Alias the original method and replace it
+            alias_method "#{assoc_name}_without_snapshot", assoc_name
+            alias_method assoc_name, "#{assoc_name}_with_snapshot"
           else
-            has_one assoc_name, class_name: assoc_class_name, foreign_key: assoc_foreign_key, primary_key: history_foreign_key
+            has_one assoc_name, **options
           end
         when :has_many
+          # Start with all original association options
+          options = association.options.dup
+          
+          # Override the class name and keys
+          options[:class_name] = assoc_class_name
+          options[:foreign_key] = assoc_foreign_key
+          options[:primary_key] = history_foreign_key
+          
           if assoc_class_name.match?(/History/)
+            # Create the Rails association first
+            has_many assoc_name, **options
+            
+            # Then override the accessor to filter by snapshot_id
             hfk = history_foreign_key
-            # Track this custom method
-            methods_list = class_variable_get(:@@history_association_methods) rescue []
-            methods_list << assoc_name
-            class_variable_set(:@@history_association_methods, methods_list)
             
-            define_method(assoc_name) do
+            define_method("#{assoc_name}_with_snapshot") do
               assoc_class.where(
                 assoc_foreign_key => self[hfk],
                 snapshot_id: self.snapshot_id
               )
             end
+            
+            # Alias the original method and replace it
+            alias_method "#{assoc_name}_without_snapshot", assoc_name
+            alias_method assoc_name, "#{assoc_name}_with_snapshot"
           else
-            has_many assoc_name, class_name: assoc_class_name, foreign_key: assoc_foreign_key, primary_key: history_foreign_key
+            has_many assoc_name, **options
           end
         end
       end
@@ -353,8 +485,9 @@ module Historiographer
       def history_foreign_key
         return @history_foreign_key if @history_foreign_key
 
-        # CAN THIS BE TABLE OR MODEL?
-        @history_foreign_key = original_class.base_class.name.singularize.foreign_key
+        # Use the table name to generate the foreign key to properly handle namespaced models
+        # E.g. EasyML::Column -> easy_ml_columns -> easy_ml_column_id
+        @history_foreign_key = original_class.base_class.table_name.singularize.foreign_key
       end
 
     end

data/spec/combustion_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'bundler'
+Bundler.require :default, :test
+
+require 'historiographer'
+require 'combustion'
+
+Combustion.path = 'spec/internal'
+Combustion.initialize! :active_record do
+  config.load_defaults Rails::VERSION::STRING.to_f
+end
+
+require 'rspec/rails'
+require 'database_cleaner'
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = false
+  
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+  
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+  
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/db/migrate/20250823000000_create_easy_ml_columns.rb

@@ -0,0 +1,26 @@
+class CreateEasyMlColumns < ActiveRecord::Migration[7.0]
+  def change
+    create_table :easy_ml_columns do |t|
+      t.string :name
+      t.string :data_type
+      t.timestamps
+    end
+    
+    create_table :easy_ml_column_histories do |t|
+      t.integer :easy_ml_column_id, null: false
+      t.string :name
+      t.string :data_type
+      t.timestamps
+      
+      t.datetime :history_started_at, null: false
+      t.datetime :history_ended_at
+      t.integer :history_user_id
+      t.string :snapshot_id
+      
+      t.index :easy_ml_column_id
+      t.index :history_started_at
+      t.index :history_ended_at
+      t.index :snapshot_id
+    end
+  end
+end

data/spec/db/migrate/20250824000000_create_test_articles.rb

@@ -0,0 +1,26 @@
+class CreateTestArticles < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_articles do |t|
+      t.string :title
+      t.integer :test_category_id
+      t.timestamps
+    end
+    
+    create_table :test_article_histories do |t|
+      t.integer :test_article_id, null: false
+      t.string :title
+      t.integer :test_category_id
+      t.timestamps
+      
+      t.datetime :history_started_at, null: false
+      t.datetime :history_ended_at
+      t.integer :history_user_id
+      t.string :snapshot_id
+      
+      t.index :test_article_id
+      t.index :history_started_at
+      t.index :history_ended_at
+      t.index :snapshot_id
+    end
+  end
+end

data/spec/db/migrate/20250824000001_create_test_categories.rb

@@ -0,0 +1,26 @@
+class CreateTestCategories < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_categories do |t|
+      t.string :name
+      t.integer :test_articles_count, default: 0
+      t.timestamps
+    end
+    
+    create_table :test_category_histories do |t|
+      t.integer :test_category_id, null: false
+      t.string :name
+      t.integer :test_articles_count, default: 0
+      t.timestamps
+      
+      t.datetime :history_started_at, null: false
+      t.datetime :history_ended_at
+      t.integer :history_user_id
+      t.string :snapshot_id
+      
+      t.index :test_category_id
+      t.index :history_started_at
+      t.index :history_ended_at
+      t.index :snapshot_id
+    end
+  end
+end

data/spec/db/migrate/20250825000000_create_bylines.rb

@@ -0,0 +1,11 @@
+class CreateBylines < ActiveRecord::Migration[7.1]
+  def change
+    create_table :bylines do |t|
+      t.string :name, null: false
+      t.integer :author_id
+      t.timestamps
+    end
+    
+    add_index :bylines, :author_id
+  end
+end

data/spec/db/migrate/20250826000000_create_test_users.rb

@@ -0,0 +1,8 @@
+class CreateTestUsers < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_users do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/spec/db/migrate/20250826000001_create_test_user_histories.rb

@@ -0,0 +1,18 @@
+class CreateTestUserHistories < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_user_histories do |t|
+      t.integer :test_user_id, null: false
+      t.string :name
+      t.timestamps
+      t.datetime :history_started_at, null: false
+      t.datetime :history_ended_at
+      t.integer :history_user_id
+      t.string :snapshot_id
+      
+      t.index :test_user_id
+      t.index :history_started_at
+      t.index :history_ended_at
+      t.index :snapshot_id
+    end
+  end
+end

data/spec/db/migrate/20250826000002_create_test_websites.rb

@@ -0,0 +1,9 @@
+class CreateTestWebsites < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_websites do |t|
+      t.string :name
+      t.integer :user_id
+      t.timestamps
+    end
+  end
+end

data/spec/db/migrate/20250826000003_create_test_website_histories.rb

@@ -0,0 +1,19 @@
+class CreateTestWebsiteHistories < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_website_histories do |t|
+      t.integer :test_website_id, null: false
+      t.string :name
+      t.integer :user_id
+      t.timestamps
+      t.datetime :history_started_at, null: false
+      t.datetime :history_ended_at
+      t.integer :history_user_id
+      t.string :snapshot_id
+      
+      t.index :test_website_id
+      t.index :history_started_at
+      t.index :history_ended_at
+      t.index :snapshot_id
+    end
+  end
+end