whodunit 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b45b1b2f4cfb91e98e2c4656c67305403108af39c5069127d91f0521599bc94
-  data.tar.gz: 56472d61e9f422643eefe7dca84b7f050fa8d91bb4274bb2354a4e01f04d5ee4
+  metadata.gz: 323bc72651528d7bf5e205c0388462078acc718ea39b14b5775517644a2115fc
+  data.tar.gz: d20344c823d5716ae218497ca92f61f41c6660c8e8f27a5479b0e52bc64b6b25
 SHA512:
-  metadata.gz: c959a0b51f441b28a855b95a537e5983592ed5eb7eef4cbf5eb42c1d4c120849a27ac4113c784f27defa6703939d6cb02a0c2ccc8bd24f0a0508673351407b97
-  data.tar.gz: a5ca68eebccf5794c9b65521a0c7a232f3178d7aacb6af89c9de3b3bc1365588a6e62a39c52c9821987aaa8735231d289fbc1f28fc7a95be391171d40afbfe31
+  metadata.gz: f893afd5307dfa5cdabd58c8de25baa2e979809f9d2c810cdb5dd029a90ebb07f79a61ab24c149e9545159aafef09b3494e2fe15cdee93a6c66e1ae35c44bd2e
+  data.tar.gz: 9df8c395516af0720e71fd2a5e8b03a3471f4a85684f8b8a7b274222f74a19feeb1bb9a2b5b3e4795fbcf8938aef769a87e1dd380668838198efad31215d4e3b

data/.rubocop.yml

@@ -13,6 +13,7 @@ AllCops:
     - 'coverage/**/*'
     - 'bin/**/*'
     - 'sig/**/*'
+    - 'example/**/*'
 
 # Layout & Formatting
 Layout/LineLength:
@@ -37,9 +38,17 @@ Metrics/MethodLength:
   Exclude:
     - 'spec/**/*'
 
+# Allow longer modules for main configuration
+Metrics/ModuleLength:
+  Exclude:
+    - 'lib/whodunit.rb'
+
 # RSpec specific configurations
 RSpec/ExampleLength:
   Max: 15
+  Exclude:
+    - 'spec/whodunit/reverse_associations_integration_spec.rb'
+    - 'spec/whodunit/reverse_associations_spec.rb'
 
 RSpec/MultipleExpectations:
   Max: 5
@@ -53,10 +62,21 @@ RSpec/ContextWording:
 RSpec/DescribeClass:
   Exclude:
     - 'spec/integration/**/*'
+    - 'spec/whodunit/reverse_associations_integration_spec.rb'
 
 RSpec/VerifiedDoubles:
   Enabled: false
 
+RSpec/MessageSpies:
+  Exclude:
+    - 'spec/whodunit/reverse_associations_integration_spec.rb'
+    - 'spec/whodunit/reverse_associations_spec.rb'
+    - 'spec/whodunit/stampable_spec.rb'
+
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - 'spec/whodunit/reverse_associations_spec.rb'
+
 # Allow positional boolean arguments for standard Ruby method signatures
 Style/OptionalBooleanParameter:
   Exclude:

data/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2025-01-24
+
+### Added
+
+- **Automatic Reverse Associations**: When models include `Whodunit::Stampable`, reverse associations are automatically created on the user class (e.g., `user.created_posts`, `user.updated_comments`, `user.deleted_documents`)
+- **Model Registry System**: Tracks models that include Stampable for automatic reverse association setup
+- **Per-Model Reverse Association Control**: Models can disable reverse associations with `disable_whodunit_reverse_associations!`
+- **Reverse Association Configuration**: Global configuration options including `auto_setup_reverse_associations`, `reverse_association_prefix`, and `reverse_association_suffix`
+- **Smart Model Capability Detection**: Automatically detects which associations to create based on model capabilities (creator, updater, deleter, soft-delete)
+- **Custom Column Support**: Reverse associations respect per-model custom column configurations
+- **Manual Setup Methods**: `setup_whodunit_reverse_associations!` and `setup_all_reverse_associations` for manual control
+
+### Changed
+
+- **Enhanced Stampable Module**: Now automatically registers models for reverse association setup when included
+- **Improved Configuration**: Extended main configuration module with reverse association settings
+- **Better Association Management**: Prevents duplicate associations and handles edge cases gracefully
+
+### Features
+
+- **Zero Configuration**: Reverse associations work automatically with sensible defaults
+- **Thread Safe**: Built on existing thread-safe architecture
+- **Flexible Naming**: Configurable prefixes and suffixes for association names
+- **Comprehensive Testing**: Full test coverage for all reverse association functionality
+- **RuboCop Compliant**: All code follows project style guidelines
+
+## [0.2.1] - 2025-01-21
+
+### Added
+
+- **ApplicationRecord Integration**: `whodunit install` now prompts to automatically add `Whodunit::Stampable` to `ApplicationRecord` for convenient all-model stamping
+- **Enhanced Configuration Template**: Detailed explanations and examples for each configuration option in generated initializer
+- **Post-install Message**: Helpful instructions displayed after gem installation via `bundle add whodunit`
+- **Comprehensive Test Coverage**: Full test suite for ApplicationRecord integration with edge case handling
+
+### Changed
+
+- **Improved CLI Experience**: More user-friendly prompts and messages throughout the installation process
+- **Better Documentation**: Updated README with corrected installation commands and new ApplicationRecord feature
+- **Code Organization**: Extracted ApplicationRecord integration logic into separate module for better maintainability
+
+### Fixed
+
+- **Gemspec Consistency**: Corrected post-install message to show `whodunit install` instead of incorrect Rails generator command
+- **RuboCop Compliance**: Fixed all style issues and reduced complexity across codebase
+
 ## [0.2.0] - 2025-01-20
 
 ### Added

data/README.md

@@ -1,5 +1,11 @@
 # Whodunit
 
+[![Gem Version](https://badge.fury.io/rb/whodunit.svg)](https://badge.fury.io/rb/whodunit)
+[![CI](https://github.com/kanutocd/whodunit/workflows/CI/badge.svg)](https://github.com/kanutocd/whodunit/actions)
+[![Coverage Status](https://codecov.io/gh/kanutocd/whodunit/branch/main/graph/badge.svg)](https://codecov.io/gh/kanutocd/whodunit)
+[![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.1.0-ruby.svg)](https://www.ruby-lang.org/en/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Lightweight creator/updater/deleter tracking for Rails ActiveRecord models.
 
 > **Fun Fact**: The term "whodunit" was coined by literary critic Donald Gordon in 1930 when reviewing a murder mystery novel for _American News of Books_. He described Milward Kennedy's _Half Mast Murder_ as "a satisfactory whodunit" - the first recorded use of this now-famous term for mystery stories! _([Source: Wikipedia](https://en.wikipedia.org/wiki/Whodunit))_
@@ -34,6 +40,26 @@ And then execute:
 
     $ bundle install
 
+### What's Next?
+
+After installation, you have a few options:
+
+1. **Generate Configuration & Setup** (Recommended):
+
+   ```bash
+   whodunit install
+   ```
+
+   This will:
+
+   - Create `config/initializers/whodunit.rb` with all available configuration options
+   - Optionally add `Whodunit::Stampable` to your `ApplicationRecord` for automatic stamping on all models
+   - Provide clear next steps for adding stamp columns to your database
+
+2. **Quick Setup**: Jump directly to adding stamp columns to your models (see Quick Start below)
+
+3. **Learn More**: Check the [Complete Documentation](https://kanutocd.github.io/whodunit) for advanced configuration
+
 ## Quick Start
 
 ### 1. Add Stamp Columns
@@ -106,6 +132,51 @@ user.updater   # => User who last updated this record
 user.deleter   # => User who deleted this record (if soft-delete enabled)
 ```
 
+## Reverse Associations (Automatic)
+
+Whodunit automatically sets up reverse associations on your User model when you include `Whodunit::Stampable` in other models:
+
+```ruby
+# When you include Whodunit::Stampable in Post model:
+class Post < ApplicationRecord
+  include Whodunit::Stampable
+end
+
+# Your User model automatically gets these associations:
+user.created_posts   # => Posts created by this user
+user.updated_posts   # => Posts last updated by this user  
+user.deleted_posts   # => Posts deleted by this user (if soft-delete enabled)
+```
+
+### Configuring Reverse Associations
+
+```ruby
+# config/initializers/whodunit.rb
+Whodunit.configure do |config|
+  # Disable automatic reverse associations globally
+  config.auto_setup_reverse_associations = false
+  
+  # Customize association names with prefix/suffix
+  config.reverse_association_prefix = "whodunit_"
+  config.reverse_association_suffix = "_tracked"
+  # Results in: user.whodunit_created_posts_tracked
+end
+```
+
+### Per-Model Control
+
+```ruby
+class Post < ApplicationRecord
+  include Whodunit::Stampable
+  
+  # Disable reverse associations for this model only
+  disable_whodunit_reverse_associations!
+end
+
+# Or manually set up later
+Post.setup_whodunit_reverse_associations!
+```
+
 ## Soft-Delete Support
 
 Whodunit automatically tracks who deleted records when using soft-delete. Simply configure your soft-delete column:
@@ -138,6 +209,11 @@ Whodunit.configure do |config|
   config.soft_delete_column = :discarded_at # Default: nil
   config.auto_inject_whodunit_stamps = false # Default: true
 
+  # Reverse association configuration
+  config.auto_setup_reverse_associations = false # Default: true
+  config.reverse_association_prefix = "track_"   # Default: ""
+  config.reverse_association_suffix = "_logs"    # Default: ""
+
   # Column data type configuration
   config.column_data_type = :integer       # Default: :bigint (applies to all columns)
   config.creator_column_type = :string     # Default: nil (uses column_data_type)
@@ -327,7 +403,7 @@ end
 | Feature               | Whodunit | PaperTrail | Audited |
 | --------------------- | -------- | ---------- | ------- |
 | User tracking         | ✅       | ✅         | ✅      |
-| Change history        | ❌       | ✅         | ✅      |
+| Change history        | Via [whodunit-chronicles](https://github.com/kanutocd/whodunit-chronicles) | ✅         | ✅      |
 | Performance overhead  | None     | High       | Medium  |
 | Soft-delete detection | ✅       | ❌         | ❌      |
 | Setup complexity      | Low      | Medium     | Medium  |

data/lib/whodunit/generator/application_record_integration.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Whodunit
+  class Generator
+    # Handles ApplicationRecord integration functionality
+    module ApplicationRecordIntegration
+      def self.handle_application_record_integration!
+        application_record_file = "app/models/application_record.rb"
+
+        return unless application_record_exists?(application_record_file)
+
+        content = File.read(application_record_file)
+        return if stampable_already_included?(content)
+
+        return unless user_wants_application_record_integration?
+
+        add_stampable_to_application_record!(application_record_file, content)
+      end
+
+      private_class_method def self.application_record_exists?(file_path)
+        return true if File.exist?(file_path)
+
+        puts "⚠️  ApplicationRecord not found at #{file_path}"
+        false
+      end
+
+      private_class_method def self.stampable_already_included?(content)
+        return false unless content.include?("Whodunit::Stampable")
+
+        puts "✅ Whodunit::Stampable already included in ApplicationRecord"
+        true
+      end
+
+      private_class_method def self.user_wants_application_record_integration?
+        puts ""
+        puts "🤔 Do you want to include Whodunit::Stampable in ApplicationRecord?"
+        puts "   This will automatically enable stamping for ALL your models."
+        puts "   (You can always include it manually in specific models instead)"
+        print "   Add to ApplicationRecord? (Y/n): "
+
+        response = $stdin.gets.chomp.downcase
+        !%w[n no].include?(response)
+      end
+
+      private_class_method def self.add_stampable_to_application_record!(file_path, content)
+        updated_content = try_primary_pattern(content) || try_fallback_pattern(content)
+
+        if updated_content
+          write_updated_application_record!(file_path, updated_content)
+        else
+          show_manual_integration_message
+        end
+      end
+
+      private_class_method def self.try_primary_pattern(content)
+        return unless content.match?(/^(\s*class ApplicationRecord < ActiveRecord::Base\s*)$/)
+
+        content.gsub(
+          /^(\s*class ApplicationRecord < ActiveRecord::Base\s*)$/,
+          "\\1\n  include Whodunit::Stampable"
+        )
+      end
+
+      private_class_method def self.try_fallback_pattern(content)
+        return unless content.match?(/^(\s*class ApplicationRecord.*\n)/)
+
+        content.gsub(
+          /^(\s*class ApplicationRecord.*\n)/,
+          "\\1  include Whodunit::Stampable\n"
+        )
+      end
+
+      private_class_method def self.write_updated_application_record!(file_path, content)
+        File.write(file_path, content)
+        puts "✅ Added Whodunit::Stampable to ApplicationRecord"
+        puts "   All your models will now automatically include stamping!"
+      end
+
+      private_class_method def self.show_manual_integration_message
+        puts "⚠️  Could not automatically modify ApplicationRecord"
+        puts "   Please manually add: include Whodunit::Stampable"
+      end
+    end
+  end
+end

data/lib/whodunit/generator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "generator/application_record_integration"
 
 module Whodunit
   # Generator for creating Whodunit configuration files
@@ -13,18 +14,48 @@ module Whodunit
       # Uncomment and modify the options you want to customize.
 
       # Whodunit.configure do |config|
+      #   # User model configuration
+      #   # Specify which model represents users in your application
       #   config.user_class = 'Account'             # Default: 'User'
+      #                                             # Use 'Account', 'Admin', etc. if your user model has a different name
+      #
+      #   # Column name configuration
+      #   # Customize the names of the tracking columns in your database
       #   config.creator_column = :created_by_id    # Default: :creator_id
+      #                                             # Column that stores who created the record
       #   config.updater_column = :updated_by_id    # Default: :updater_id
+      #                                             # Column that stores who last updated the record
       #   config.deleter_column = :deleted_by_id    # Default: :deleter_id
-      #   config.soft_delete_column = :discarded_at # Default: nil
+      #                                             # Column that stores who deleted the record (soft-delete only)
+      #
+      #   # Soft-delete integration
+      #   # Enable tracking of who deleted records when using soft-delete gems
+      #   config.soft_delete_column = :discarded_at # Default: nil (disabled)
+      #                                             # Set to :deleted_at for Paranoia gem
+      #                                             # Set to :discarded_at for Discard gem
+      #                                             # Set to your custom soft-delete column name
+      #                                             # Set to nil to disable soft-delete tracking
+      #
+      #   # Migration auto-injection
+      #   # Control whether whodunit stamps are automatically added to new migrations
       #   config.auto_inject_whodunit_stamps = false # Default: true
+      #                                               # When true, automatically adds t.whodunit_stamps to create_table migrations
+      #                                               # When false, you must manually add t.whodunit_stamps to your migrations
       #
       #   # Column data type configuration
-      #   config.column_data_type = :integer       # Default: :bigint (applies to all columns)
+      #   # Configure what data types to use for the tracking columns
+      #   config.column_data_type = :integer       # Default: :bigint
+      #                                            # Global default for all stamp columns
+      #                                            # Common options: :bigint, :integer, :string, :uuid
+      #
+      #   # Individual column type overrides
+      #   # Override the data type for specific columns (takes precedence over column_data_type)
       #   config.creator_column_type = :string     # Default: nil (uses column_data_type)
+      #                                            # Useful if your user IDs are strings or UUIDs
       #   config.updater_column_type = :uuid       # Default: nil (uses column_data_type)
+      #                                            # Set to match your user model's primary key type
       #   config.deleter_column_type = :integer    # Default: nil (uses column_data_type)
+      #                                            # Only used when soft_delete_column is configured
       # end
     RUBY
 
@@ -36,6 +67,7 @@ module Whodunit
       ensure_config_directory_exists!(config_dir)
       handle_existing_file!(config_file)
       create_initializer_file!(config_file)
+      ApplicationRecordIntegration.handle_application_record_integration!
       show_success_message(config_file)
     end
 
@@ -76,7 +108,10 @@ module Whodunit
       puts "📝 Next steps:"
       puts "   1. Edit #{config_file} to customize your configuration"
       puts "   2. Uncomment the options you want to change"
-      puts "   3. Restart your Rails server to apply changes"
+      puts "   3. Add stamp columns to your models with migrations:"
+      puts "      rails generate migration AddStampsToUsers"
+      puts "      # Then add: add_whodunit_stamps :users"
+      puts "   4. Restart your Rails server to apply changes"
       puts ""
       puts "📖 For more information, see: https://github.com/kanutocd/whodunit?tab=readme-ov-file#configuration"
     end

data/lib/whodunit/stampable.rb

@@ -52,6 +52,10 @@ module Whodunit
 
       # Set up associations - call on the class
       setup_whodunit_associations
+
+      # Register this model for reverse association setup
+      # This happens immediately, but the check for enabled status is done in register_model
+      Whodunit.register_model(self)
     end
 
     class_methods do # rubocop:disable Metrics/BlockLength
@@ -82,6 +86,31 @@ module Whodunit
         @soft_delete_enabled = false
       end
 
+      # Disable reverse association setup for this model
+      # Call this method in the model class to prevent automatic reverse associations
+      # @example
+      #   class Post < ApplicationRecord
+      #     include Whodunit::Stampable
+      #     disable_whodunit_reverse_associations!
+      #   end
+      def disable_whodunit_reverse_associations!
+        @whodunit_reverse_associations_disabled = true
+        # Remove from registered models if already registered
+        Whodunit.registered_models.delete(self)
+      end
+
+      # Check if reverse associations are enabled for this model
+      # @return [Boolean] true if reverse associations should be set up
+      def whodunit_reverse_associations_enabled?
+        !@whodunit_reverse_associations_disabled
+      end
+
+      # Manually set up reverse associations for this model
+      # Can be called if reverse associations were disabled but you want to set them up later
+      def setup_whodunit_reverse_associations!
+        Whodunit.setup_reverse_associations_for_model(self) if whodunit_reverse_associations_enabled?
+      end
+
       # Get effective configuration value (model override or global default)
       def whodunit_setting(key)
         return @whodunit_config_overrides[key] if @whodunit_config_overrides&.key?(key)

data/lib/whodunit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Whodunit
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/whodunit.rb

@@ -83,6 +83,31 @@ module Whodunit
   # @return [Symbol, nil] the deleter column data type
   mattr_accessor :deleter_column_type, default: nil
 
+  # @!group Reverse Association Configuration
+
+  # Whether to automatically set up reverse associations on the user class (default: true)
+  # When enabled, including Whodunit::Stampable in a model will automatically add
+  # has_many associations to the user class (e.g., has_many :created_posts)
+  # @return [Boolean] auto reverse association setting
+  mattr_accessor :auto_setup_reverse_associations, default: true
+
+  # Prefix for reverse association names (default: "")
+  # Used to generate association names like "created_posts", "updated_comments"
+  # @return [String] the prefix for reverse association names
+  mattr_accessor :reverse_association_prefix, default: ""
+
+  # Suffix for reverse association names (default: "")
+  # Used to generate association names like "posts_created", "comments_updated"
+  # @return [String] the suffix for reverse association names
+  mattr_accessor :reverse_association_suffix, default: ""
+
+  # @!group Model Registry
+
+  # Registry to track models that include Whodunit::Stampable
+  # This is used to set up reverse associations on the user class
+  # @return [Array<Class>] array of model classes that include Stampable
+  mattr_accessor :registered_models, default: []
+
   # Configure Whodunit settings
   #
   # @example
@@ -151,6 +176,135 @@ module Whodunit
     !deleter_column.nil?
   end
 
+  # @!group Model Registration & Reverse Associations
+
+  # Register a model class that includes Whodunit::Stampable
+  # This is called automatically when Stampable is included
+  # @param [Class] model_class the model class to register
+  # @return [void]
+  def self.register_model(model_class)
+    return unless auto_setup_reverse_associations
+    return if registered_models.include?(model_class)
+    return if model_class.respond_to?(:whodunit_reverse_associations_enabled?) &&
+              !model_class.whodunit_reverse_associations_enabled?
+
+    registered_models << model_class
+    setup_reverse_associations_for_model(model_class)
+  end
+
+  # Set up reverse associations on the user class for a specific model
+  # @param [Class] model_class the model class to set up reverse associations for
+  # @return [void]
+  def self.setup_reverse_associations_for_model(model_class)
+    return unless auto_setup_reverse_associations
+
+    user_class_instance = resolve_user_class
+    return unless user_class_instance.respond_to?(:has_many)
+
+    model_plural = model_class.name.underscore.pluralize
+
+    setup_creator_reverse_association(user_class_instance, model_class, model_plural)
+    setup_updater_reverse_association(user_class_instance, model_class, model_plural)
+    setup_deleter_reverse_association(user_class_instance, model_class, model_plural)
+  end
+
+  # Set up all reverse associations for all registered models
+  # This can be called manually if needed (e.g., after configuration changes)
+  # @return [void]
+  def self.setup_all_reverse_associations
+    registered_models.each do |model_class|
+      setup_reverse_associations_for_model(model_class)
+    end
+  end
+
+  # Generate a reverse association name based on action and model name
+  # @param [String] action the action (created, updated, deleted)
+  # @param [String] model_plural the pluralized model name
+  # @return [String] the generated association name
+  def self.generate_reverse_association_name(action, model_plural)
+    "#{reverse_association_prefix}#{action}_#{model_plural}#{reverse_association_suffix}"
+  end
+
+  # Resolve the user class constant
+  # @return [Class, nil] the user class or nil if not found
+  def self.resolve_user_class
+    user_class.constantize
+  rescue StandardError
+    nil
+  end
+
+  # Set up creator reverse association
+  # @param [Class] user_class_instance the user class
+  # @param [Class] model_class the model class
+  # @param [String] model_plural the pluralized model name
+  # @return [void]
+  def self.setup_creator_reverse_association(user_class_instance, model_class, model_plural)
+    return unless model_class.respond_to?(:model_creator_enabled?) && model_class.model_creator_enabled?
+
+    association_name = generate_reverse_association_name("created", model_plural)
+    setup_user_reverse_association(user_class_instance, association_name, model_class, :creator_id)
+  end
+
+  # Set up updater reverse association
+  # @param [Class] user_class_instance the user class
+  # @param [Class] model_class the model class
+  # @param [String] model_plural the pluralized model name
+  # @return [void]
+  def self.setup_updater_reverse_association(user_class_instance, model_class, model_plural)
+    return unless model_class.respond_to?(:model_updater_enabled?) && model_class.model_updater_enabled?
+
+    association_name = generate_reverse_association_name("updated", model_plural)
+    setup_user_reverse_association(user_class_instance, association_name, model_class, :updater_id)
+  end
+
+  # Set up deleter reverse association
+  # @param [Class] user_class_instance the user class
+  # @param [Class] model_class the model class
+  # @param [String] model_plural the pluralized model name
+  # @return [void]
+  def self.setup_deleter_reverse_association(user_class_instance, model_class, model_plural)
+    return unless model_class.respond_to?(:model_deleter_enabled?) && model_class.model_deleter_enabled?
+    return unless model_class.respond_to?(:soft_delete_enabled?) && model_class.soft_delete_enabled?
+
+    association_name = generate_reverse_association_name("deleted", model_plural)
+    setup_user_reverse_association(user_class_instance, association_name, model_class, :deleter_id)
+  end
+
+  # Set up a specific reverse association on the user class
+  # @param [Class] user_class_instance the user class
+  # @param [String] association_name the name of the association
+  # @param [Class] model_class the model class
+  # @param [Symbol] foreign_key_column the foreign key column name
+  # @return [void]
+  def self.setup_user_reverse_association(user_class_instance, association_name, model_class, foreign_key_column)
+    actual_foreign_key = resolve_foreign_key(model_class, foreign_key_column)
+
+    # Check if association already exists to avoid duplicates
+    return if user_class_instance.reflect_on_association(association_name.to_sym)
+
+    user_class_instance.has_many association_name.to_sym,
+                                 class_name: model_class.name,
+                                 foreign_key: actual_foreign_key,
+                                 dependent: :nullify
+  end
+
+  # Resolve the actual foreign key column name from model configuration
+  # @param [Class] model_class the model class
+  # @param [Symbol] foreign_key_column the default foreign key column
+  # @return [Symbol] the actual foreign key column name
+  def self.resolve_foreign_key(model_class, foreign_key_column)
+    return foreign_key_column unless model_class.respond_to?(:whodunit_setting)
+
+    column_mapping = {
+      creator_id: :creator_column,
+      updater_id: :updater_column,
+      deleter_id: :deleter_column
+    }
+
+    setting_key = column_mapping[foreign_key_column]
+    setting_key ? (model_class.whodunit_setting(setting_key) || foreign_key_column) : foreign_key_column
+  end
+
   # Validate that column configuration is valid
   # @raise [Whodunit::Error] if both creator_column and updater_column are nil
   def self.validate_column_configuration!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: whodunit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ken C. Demanawa
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-20 00:00:00.000000000 Z
+date: 2025-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -217,6 +217,7 @@ files:
 - lib/whodunit/controller_methods.rb
 - lib/whodunit/current.rb
 - lib/whodunit/generator.rb
+- lib/whodunit/generator/application_record_integration.rb
 - lib/whodunit/migration_helpers.rb
 - lib/whodunit/railtie.rb
 - lib/whodunit/stampable.rb
@@ -234,7 +235,11 @@ metadata:
   bug_tracker_uri: https://github.com/kanutocd/whodunit/issues
   documentation_uri: https://kanutocd.github.io/whodunit
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: "\U0001F389 Thanks for installing Whodunit!\n\nWhat's next?\n\n1.
+  Generate configuration (recommended):\n   whodunit install\n\n2. Add stamp columns
+  to your models:\n   rails generate migration AddStampsToUsers\n   # Then add: add_whodunit_stamps
+  :users\n\n3. Include Whodunit::Stampable in your models:\n   class User < ApplicationRecord\n
+  \    include Whodunit::Stampable\n   end\n\n\U0001F4D6 Complete documentation: https://kanutocd.github.io/whodunit\n"
 rdoc_options: []
 require_paths:
 - lib