whodunit 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c68bbab9b951c3ed257a22769b665e0525f8b41ecb23c3f7375488cc099f9f65
-  data.tar.gz: 3e23380c8ba1502e359c768fe4a99fe3af499598801de896cc030075b8db7de5
+  metadata.gz: 0b45b1b2f4cfb91e98e2c4656c67305403108af39c5069127d91f0521599bc94
+  data.tar.gz: 56472d61e9f422643eefe7dca84b7f050fa8d91bb4274bb2354a4e01f04d5ee4
 SHA512:
-  metadata.gz: 14e70828520db567bb75dbc472c961fc292281183f630d66d2543e47680947668cd17fc03db2491fa1b0cd52fc423941ca0e73b83e2bca65cbf811a5fdbfc55c
-  data.tar.gz: 6fe6fb76793405dac3ff6f7ad799aa0736e4a5cdfdd4c878b435210606570ce130a73eb570498efb8fc41e1ff1790c44496aae307dba0af689f5ad3fb416d7e2
+  metadata.gz: c959a0b51f441b28a855b95a537e5983592ed5eb7eef4cbf5eb42c1d4c120849a27ac4113c784f27defa6703939d6cb02a0c2ccc8bd24f0a0508673351407b97
+  data.tar.gz: a5ca68eebccf5794c9b65521a0c7a232f3178d7aacb6af89c9de3b3bc1365588a6e62a39c52c9821987aaa8735231d289fbc1f28fc7a95be391171d40afbfe31

data/.rubocop.yml

@@ -6,7 +6,7 @@ plugins:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.1
   Exclude:
     - 'vendor/**/*'
     - 'tmp/**/*'

data/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2025-01-20
+
+### Added
+
+- New `whodunit install` CLI command to generate configuration initializer
+- Per-model configuration override capability via `whodunit_config` block
+- Column enabling/disabling - set individual columns to `nil` to disable them
+- Configuration validation to prevent disabling both creator and updater columns
+- Comprehensive generator with Rails app detection and safety prompts
+- Enhanced YARD documentation reflecting simplified architecture
+
+### Changed
+
+- **BREAKING**: `soft_delete_column` now defaults to `nil` instead of `:deleted_at`
+- **BREAKING**: Removed automatic soft-delete detection - now purely configuration-based
+- **BREAKING**: Simplified `being_soft_deleted?` logic to check only configured column
+- Migration helpers now respect column enabling/disabling configuration
+- Updated all documentation to reflect simplified, configuration-based approach
+- Improved test infrastructure with better configuration isolation
+
+### Removed
+
+- **BREAKING**: `SoftDeleteDetector` class and all auto-detection logic
+- **BREAKING**: `SOFT_DELETE_COLUMNS` constant and pattern-matching detection
+- Complex database schema introspection for soft-delete detection
+
+### Performance
+
+- Eliminated expensive auto-detection queries during model initialization
+- Reduced computational overhead by trusting user configuration
+- Simplified callback and association setup based on explicit configuration
+
+## [0.1.0] - 2025-01-15
+
 ### Added
 
 - Initial release of Whodunit gem
@@ -36,9 +70,3 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Rails 7.2+
 - Ruby 3.1+
-
-## [0.1.0] - TBD
-
-### Added
-
-- Initial gem structure and basic functionality

data/README.md

@@ -106,14 +106,25 @@ user.updater   # => User who last updated this record
 user.deleter   # => User who deleted this record (if soft-delete enabled)
 ```
 
-## Smart Soft-Delete Detection
+## Soft-Delete Support
 
-Whodunit automatically detects popular soft-delete solutions:
+Whodunit automatically tracks who deleted records when using soft-delete. Simply configure your soft-delete column:
 
-- **Discard** (`gem 'discard'`)
-- **Paranoia** (`gem 'paranoia'`)
-- **ActsAsParanoid** (`gem 'acts_as_paranoid'`)
-- **Custom implementations** with timestamp columns like `deleted_at`, `discarded_at`, etc.
+```ruby
+# Most common soft-delete column (default)
+config.soft_delete_column = :deleted_at
+
+# For Discard gem users
+config.soft_delete_column = :discarded_at
+
+# For custom implementations
+config.soft_delete_column = :archived_at
+
+# Disable soft-delete support
+config.soft_delete_column = nil
+```
+
+When configured, Whodunit will automatically add the `deleter_id` column to migrations when the soft-delete column is detected in your table.
 
 ## Configuration
 
@@ -124,7 +135,8 @@ Whodunit.configure do |config|
   config.creator_column = :created_by_id    # Default: :creator_id
   config.updater_column = :updated_by_id    # Default: :updater_id
   config.deleter_column = :deleted_by_id    # Default: :deleter_id
-  config.auto_detect_soft_delete = false   # Default: true
+  config.soft_delete_column = :discarded_at # Default: nil
+  config.auto_inject_whodunit_stamps = false # Default: true
 
   # Column data type configuration
   config.column_data_type = :integer       # Default: :bigint (applies to all columns)
@@ -142,6 +154,46 @@ By default, all stamp columns use `:bigint` data type. You can customize this in
 - **Individual**: Set specific column types to override the global default
 - **Per-migration**: Override types on a per-migration basis (see Migration Helpers)
 
+### Automatic Injection (Rails Integration)
+
+By default, Whodunit automatically adds stamp columns to your migrations, just like how Rails automatically handles `timestamps`:
+
+```ruby
+# Automatic injection is enabled by default!
+# Your migrations automatically get whodunit stamps:
+class CreatePosts < ActiveRecord::Migration[8.0]
+  def change
+    create_table :posts do |t|
+      t.string :title
+      t.text :body
+      t.timestamps
+      # t.whodunit_stamps automatically added after t.timestamps!
+    end
+  end
+end
+
+# Disable automatic injection globally:
+Whodunit.configure do |config|
+  config.auto_inject_whodunit_stamps = false
+end
+
+# Skip auto-injection for specific tables:
+create_table :system_logs do |t|
+  t.string :message
+  t.timestamps skip_whodunit_stamps: true
+end
+
+# Or add manually if you want specific options:
+create_table :posts do |t|
+  t.string :title
+  t.whodunit_stamps include_deleter: true  # Manual override
+  t.timestamps
+  # No auto-injection since already added manually
+end
+```
+
+This feature respects soft-delete auto-detection and includes the deleter column when appropriate.
+
 ## Manual User Setting
 
 For background jobs, tests, or special scenarios:

data/exe/whodunit

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/whodunit/generator"
+
+# Parse command line arguments
+command = ARGV[0]
+
+case command
+when "install"
+  Whodunit::Generator.install_initializer
+when "help", "--help", "-h", nil
+  puts Whodunit::Generator.help_message
+else
+  puts "Unknown command: #{command}"
+  puts Whodunit::Generator.help_message
+  exit 1
+end

data/lib/whodunit/controller_methods.rb

@@ -147,8 +147,8 @@ module Whodunit
     #   without_whodunit_user do
     #     Post.bulk_import(data)  # No creator_id will be set
     #   end
-    def without_whodunit_user(&block)
-      with_whodunit_user(nil, &block)
+    def without_whodunit_user(&)
+      with_whodunit_user(nil, &)
     end
 
     class_methods do

data/lib/whodunit/generator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Whodunit
+  # Generator for creating Whodunit configuration files
+  class Generator
+    INITIALIZER_CONTENT = <<~RUBY
+      # frozen_string_literal: true
+
+      # Whodunit configuration
+      # This file was generated by `whodunit install` command.
+      # Uncomment and modify the options you want to customize.
+
+      # Whodunit.configure do |config|
+      #   config.user_class = 'Account'             # Default: 'User'
+      #   config.creator_column = :created_by_id    # Default: :creator_id
+      #   config.updater_column = :updated_by_id    # Default: :updater_id
+      #   config.deleter_column = :deleted_by_id    # Default: :deleter_id
+      #   config.soft_delete_column = :discarded_at # Default: nil
+      #   config.auto_inject_whodunit_stamps = false # Default: true
+      #
+      #   # 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)
+      #   config.updater_column_type = :uuid       # Default: nil (uses column_data_type)
+      #   config.deleter_column_type = :integer    # Default: nil (uses column_data_type)
+      # end
+    RUBY
+
+    def self.install_initializer
+      config_dir = "config/initializers"
+      config_file = File.join(config_dir, "whodunit.rb")
+
+      validate_rails_application!
+      ensure_config_directory_exists!(config_dir)
+      handle_existing_file!(config_file)
+      create_initializer_file!(config_file)
+      show_success_message(config_file)
+    end
+
+    private_class_method def self.validate_rails_application!
+      return if File.exist?("config/application.rb")
+
+      puts "❌ Error: This doesn't appear to be a Rails application."
+      puts "   Make sure you're in the root directory of your Rails app."
+      exit 1
+    end
+
+    private_class_method def self.ensure_config_directory_exists!(config_dir)
+      return if Dir.exist?(config_dir)
+
+      puts "📁 Creating #{config_dir} directory..."
+      FileUtils.mkdir_p(config_dir)
+    end
+
+    private_class_method def self.handle_existing_file!(config_file)
+      return unless File.exist?(config_file)
+
+      puts "⚠️  #{config_file} already exists!"
+      print "   Do you want to overwrite it? (y/N): "
+      response = $stdin.gets.chomp.downcase
+      return if %w[y yes].include?(response)
+
+      puts "   Cancelled."
+      exit 0
+    end
+
+    private_class_method def self.create_initializer_file!(config_file)
+      File.write(config_file, INITIALIZER_CONTENT)
+      puts "✅ Generated #{config_file}"
+    end
+
+    private_class_method def self.show_success_message(config_file)
+      puts ""
+      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 ""
+      puts "📖 For more information, see: https://github.com/kanutocd/whodunit?tab=readme-ov-file#configuration"
+    end
+
+    def self.help_message
+      <<~HELP
+        Whodunit - Lightweight creator/updater/deleter tracking for ActiveRecord
+
+        Usage:
+          whodunit install    Generate config/initializers/whodunit.rb
+          whodunit help       Show this help message
+
+        Examples:
+          whodunit install    # Creates config/initializers/whodunit.rb with sample configuration
+
+        For more information, visit: https://github.com/kanutocd/whodunit
+      HELP
+    end
+  end
+end

data/lib/whodunit/migration_helpers.rb

@@ -4,15 +4,20 @@ module Whodunit
   # Database migration helpers for adding whodunit stamp columns.
   #
   # This module provides convenient methods for adding creator/updater/deleter
-  # tracking columns to database tables. It intelligently detects soft-delete
-  # implementations and adds appropriate indexes for performance.
+  # tracking columns to database tables based on configuration. Uses the configured
+  # column names and data types, and adds appropriate indexes for performance.
+  #
+  # The helpers respect column enabling/disabling configuration:
+  # - Only adds columns that are enabled (not nil) in configuration
+  # - Uses configured column names and data types
+  # - Deleter column inclusion based on soft_delete_column configuration
   #
   # @example Add stamps to existing table
   #   class AddWhodunitStampsToPosts < ActiveRecord::Migration[7.0]
   #     def change
   #       add_whodunit_stamps :posts
-  #       # Adds creator_id, updater_id columns
-  #       # Adds deleter_id if soft-delete detected
+  #       # Adds enabled columns: creator_id, updater_id
+  #       # Adds deleter_id if soft_delete_column is configured
   #     end
   #   end
   #
@@ -28,38 +33,57 @@ module Whodunit
   #     end
   #   end
   #
-  # @example Custom data types
+  # @example Custom data types and explicit deleter inclusion
   #   add_whodunit_stamps :posts,
   #     creator_type: :string,
   #     updater_type: :uuid,
   #     include_deleter: true
   #
+  # @example With custom column configuration
+  #   # In config/initializers/whodunit.rb:
+  #   Whodunit.configure do |config|
+  #     config.creator_column = :created_by_id
+  #     config.deleter_column = nil  # Disable deleter column
+  #     config.soft_delete_column = :archived_at
+  #   end
+  #
+  #   # Migration will use custom column names and only add enabled columns
+  #
   # @since 0.1.0
   module MigrationHelpers
-    # Add creator/updater stamp columns to an existing table.
+    # Add creator/updater/deleter stamp columns to an existing table.
     #
-    # This method adds the configured creator and updater columns to an existing table.
-    # It optionally adds a deleter column based on soft-delete detection or explicit configuration.
+    # This method adds the configured whodunit columns to an existing table based on
+    # the current configuration. Only adds columns that are enabled (not nil).
+    # The deleter column is included based on soft_delete_column configuration when
+    # include_deleter is :auto, or explicitly when include_deleter is true.
     # Indexes are automatically added for performance.
     #
     # @param table_name [Symbol] the table to add stamps to
-    # @param include_deleter [Symbol, Boolean] :auto to auto-detect soft-delete,
+    # @param include_deleter [Symbol, Boolean] :auto to check soft_delete_column configuration,
     #   true to force inclusion, false to exclude
     # @param creator_type [Symbol, nil] data type for creator column (defaults to configured type)
     # @param updater_type [Symbol, nil] data type for updater column (defaults to configured type)
     # @param deleter_type [Symbol, nil] data type for deleter column (defaults to configured type)
     # @return [void]
-    # @example Basic usage
+    # @example Basic usage (uses configuration)
     #   add_whodunit_stamps :posts
     # @example With custom types
     #   add_whodunit_stamps :posts, creator_type: :string, updater_type: :uuid
-    # @example Force deleter column
+    # @example Force deleter column inclusion
     #   add_whodunit_stamps :posts, include_deleter: true
+    # @example Exclude deleter column
+    #   add_whodunit_stamps :posts, include_deleter: false
     def add_whodunit_stamps(table_name, include_deleter: :auto, creator_type: nil, updater_type: nil, deleter_type: nil)
-      add_column table_name, Whodunit.creator_column, creator_type || Whodunit.creator_data_type, null: true
-      add_column table_name, Whodunit.updater_column, updater_type || Whodunit.updater_data_type, null: true
+      if Whodunit.creator_enabled?
+        add_column table_name, Whodunit.creator_column, creator_type || Whodunit.creator_data_type, null: true
+      end
+
+      if Whodunit.updater_enabled?
+        add_column table_name, Whodunit.updater_column, updater_type || Whodunit.updater_data_type, null: true
+      end
 
-      if should_include_deleter?(table_name, include_deleter)
+      if should_include_deleter?(include_deleter)
         add_column table_name, Whodunit.deleter_column, deleter_type || Whodunit.deleter_data_type, null: true
       end
 
@@ -69,22 +93,30 @@ module Whodunit
     # Remove stamp columns from an existing table.
     #
     # This method removes the configured creator, updater, and optionally deleter
-    # columns from an existing table. Only removes columns that actually exist.
+    # columns from an existing table. Only removes columns that are enabled in
+    # configuration and actually exist in the database.
     #
     # @param table_name [Symbol] the table to remove stamps from
-    # @param include_deleter [Symbol, Boolean] :auto to auto-detect soft-delete,
+    # @param include_deleter [Symbol, Boolean] :auto to check soft_delete_column configuration,
     #   true to force removal, false to exclude
     # @param _options [Hash] additional options (reserved for future use)
     # @return [void]
-    # @example Basic usage
+    # @example Basic usage (uses configuration)
     #   remove_whodunit_stamps :posts
     # @example Force deleter removal
     #   remove_whodunit_stamps :posts, include_deleter: true
+    # @example Exclude deleter removal
+    #   remove_whodunit_stamps :posts, include_deleter: false
     def remove_whodunit_stamps(table_name, include_deleter: :auto, **_options)
-      remove_column table_name, Whodunit.creator_column if column_exists?(table_name, Whodunit.creator_column)
-      remove_column table_name, Whodunit.updater_column if column_exists?(table_name, Whodunit.updater_column)
+      if Whodunit.creator_enabled? && column_exists?(table_name, Whodunit.creator_column)
+        remove_column table_name, Whodunit.creator_column
+      end
+
+      if Whodunit.updater_enabled? && column_exists?(table_name, Whodunit.updater_column)
+        remove_column table_name, Whodunit.updater_column
+      end
 
-      if should_include_deleter?(table_name, include_deleter) &&
+      if should_include_deleter?(include_deleter) &&
          column_exists?(table_name, Whodunit.deleter_column)
         remove_column table_name, Whodunit.deleter_column
       end
@@ -96,15 +128,19 @@ module Whodunit
     # 1. Inside a create_table block (pass table definition as first argument)
     # 2. As a standalone method in migrations (attempts to infer table name)
     #
+    # Only adds columns that are enabled in configuration. For new tables,
+    # deleter column is only added when explicitly requested (include_deleter: true)
+    # to be conservative.
+    #
     # @param table_def [ActiveRecord::ConnectionAdapters::TableDefinition, nil]
     #   the table definition (when used in create_table block) or nil
-    # @param include_deleter [Symbol, Boolean] :auto to auto-detect soft-delete,
+    # @param include_deleter [Symbol, Boolean] :auto to check soft_delete_column configuration,
     #   true to force inclusion, false to exclude
     # @param creator_type [Symbol, nil] data type for creator column (defaults to configured type)
     # @param updater_type [Symbol, nil] data type for updater column (defaults to configured type)
     # @param deleter_type [Symbol, nil] data type for deleter column (defaults to configured type)
     # @return [void]
-    # @example In create_table block
+    # @example In create_table block (uses configuration)
     #   create_table :posts do |t|
     #     t.string :title
     #     t.whodunit_stamps
@@ -113,6 +149,10 @@ module Whodunit
     #   def change
     #     whodunit_stamps  # Adds to inferred table
     #   end
+    # @example Force deleter column in new table
+    #   create_table :posts do |t|
+    #     t.whodunit_stamps include_deleter: true
+    #   end
     def whodunit_stamps(table_def = nil, include_deleter: :auto, creator_type: nil, updater_type: nil,
                         deleter_type: nil)
       if table_def.nil?
@@ -135,8 +175,13 @@ module Whodunit
 
     # Handle stamps when called within create_table block
     def handle_table_definition_stamps(table_def, include_deleter, creator_type, updater_type, deleter_type)
-      table_def.column Whodunit.creator_column, creator_type || Whodunit.creator_data_type, null: true
-      table_def.column Whodunit.updater_column, updater_type || Whodunit.updater_data_type, null: true
+      if Whodunit.creator_enabled?
+        table_def.column Whodunit.creator_column, creator_type || Whodunit.creator_data_type, null: true
+      end
+
+      if Whodunit.updater_enabled?
+        table_def.column Whodunit.updater_column, updater_type || Whodunit.updater_data_type, null: true
+      end
 
       if should_include_deleter_for_new_table?(include_deleter)
         table_def.column Whodunit.deleter_column, deleter_type || Whodunit.deleter_data_type, null: true
@@ -145,46 +190,37 @@ module Whodunit
       add_whodunit_indexes_for_create_table(table_def, include_deleter)
     end
 
-    # Determine if deleter column should be included
-    def should_include_deleter?(table_name, include_deleter)
-      case include_deleter
-      when :auto
-        soft_delete_detected_for_table?(table_name)
-      when true
-        true
-      else
-        false
-      end
+    # Determine if deleter column should be included based on configuration.
+    # When :auto, checks if soft_delete_column is configured (not nil).
+    # @param include_deleter [Symbol, Boolean] the inclusion preference
+    # @return [Boolean] true if deleter column should be included
+    def should_include_deleter?(include_deleter)
+      include_deleter == :auto ? soft_delete_enabled? : include_deleter.eql?(true)
     end
 
-    # For new tables, be more conservative with auto-detection
+    # For new tables, be more conservative - only include deleter when explicitly requested.
+    # This prevents adding deleter columns to tables that may not need them.
+    # @param include_deleter [Symbol, Boolean] the inclusion preference
+    # @return [Boolean] true only when explicitly requested (true)
     def should_include_deleter_for_new_table?(include_deleter)
-      case include_deleter
-      when true
-        true
-      else
-        false # Don't auto-add for new tables, let user be explicit
-      end
+      include_deleter.eql?(true)
     end
 
-    # Detect soft-delete patterns in existing table
-    def soft_delete_detected_for_table?(table_name)
-      return false unless table_exists?(table_name)
-
-      soft_delete_columns = %w[
-        deleted_at destroyed_at discarded_at archived_at
-        soft_deleted_at soft_destroyed_at removed_at
-      ]
-
-      soft_delete_columns.any? { |col| column_exists?(table_name, col) || column_exists?(table_name, col.to_sym) }
+    # Check if soft-delete is enabled based on configuration.
+    # Uses the configured soft_delete_column - if it's set (not nil), soft delete is enabled.
+    # @return [Boolean] true if soft_delete_column is configured
+    def soft_delete_enabled?
+      # Simple configuration-based check - trust the user's configuration
+      Whodunit.soft_delete_enabled?
     end
 
     # Add indexes for performance
     def add_whodunit_indexes(table_name, include_deleter)
-      add_index table_name, Whodunit.creator_column, name: "index_#{table_name}_on_creator"
-      add_index table_name, Whodunit.updater_column, name: "index_#{table_name}_on_updater"
+      add_index table_name, Whodunit.creator_column, name: "index_#{table_name}_on_creator" if Whodunit.creator_enabled?
 
-      return unless should_include_deleter?(table_name, include_deleter)
+      add_index table_name, Whodunit.updater_column, name: "index_#{table_name}_on_updater" if Whodunit.updater_enabled?
+
+      return unless should_include_deleter?(include_deleter)
 
       add_index table_name, Whodunit.deleter_column, name: "index_#{table_name}_on_deleter"
     end
@@ -195,8 +231,10 @@ module Whodunit
       return unless table_def.respond_to?(:index)
 
       table_name = table_def.respond_to?(:name) ? table_def.name : "table"
-      table_def.index Whodunit.creator_column, name: "index_#{table_name}_on_creator"
-      table_def.index Whodunit.updater_column, name: "index_#{table_name}_on_updater"
+
+      table_def.index Whodunit.creator_column, name: "index_#{table_name}_on_creator" if Whodunit.creator_enabled?
+
+      table_def.index Whodunit.updater_column, name: "index_#{table_name}_on_updater" if Whodunit.updater_enabled?
 
       return unless should_include_deleter_for_new_table?(include_deleter)
 

data/lib/whodunit/railtie.rb

@@ -24,11 +24,17 @@ module Whodunit
       #
       # This initializer adds the MigrationHelpers module to ActiveRecord,
       # making methods like add_whodunit_stamps available in migrations.
+      # It also extends TableDefinition for automatic whodunit_stamps injection.
       #
       # @api private
       initializer "whodunit.extend_active_record" do |_app|
         ActiveSupport.on_load(:active_record) do
           extend Whodunit::MigrationHelpers
+
+          # Extend TableDefinition for automatic whodunit_stamps injection
+          ActiveRecord::ConnectionAdapters::TableDefinition.include(
+            Whodunit::TableDefinitionExtension
+          )
         end
       end
 

data/lib/whodunit/stampable.rb

@@ -36,78 +36,121 @@ module Whodunit
   #   end
   #
   # @since 0.1.0
+  # rubocop:disable Metrics/ModuleLength
   module Stampable
     extend ActiveSupport::Concern
 
     included do
-      # Set up callbacks
+      # Set up callbacks - the if conditions will check per-model settings at runtime
       before_create :set_whodunit_creator, if: :creator_column?
       before_update :set_whodunit_updater, if: :updater_column?
 
-      # Only add destroy callback if soft-delete is detected
-      if Whodunit.auto_detect_soft_delete &&
-         Whodunit::SoftDeleteDetector.enabled_for?(self)
-        before_destroy :set_whodunit_deleter, if: :deleter_column?
-      end
+      # Add deleter tracking for both hard and soft deletes
+      # The if conditions will check per-model settings at runtime
+      before_destroy :set_whodunit_deleter, if: :deleter_column?
+      before_update :set_whodunit_deleter, if: :being_soft_deleted?
 
       # Set up associations - call on the class
       setup_whodunit_associations
     end
 
     class_methods do # rubocop:disable Metrics/BlockLength
+      # Per-model configuration storage
+      attr_accessor :whodunit_config_overrides
+
+      # Configure per-model settings
+      def whodunit_config
+        @whodunit_config_overrides ||= {}
+        yield @whodunit_config_overrides if block_given?
+        @whodunit_config_overrides
+      end
+
       def soft_delete_enabled?
-        @soft_delete_enabled ||= Whodunit::SoftDeleteDetector.enabled_for?(self)
+        @soft_delete_enabled ||= model_soft_delete_enabled?
       end
 
       def enable_whodunit_deleter!
         before_destroy :set_whodunit_deleter, if: :deleter_column?
+        before_update :set_whodunit_deleter, if: :being_soft_deleted?
         setup_deleter_association
         @soft_delete_enabled = true
       end
 
       def disable_whodunit_deleter!
         skip_callback :destroy, :before, :set_whodunit_deleter
+        skip_callback :update, :before, :set_whodunit_deleter
         @soft_delete_enabled = false
       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)
+
+        Whodunit.public_send(key)
+      end
+
+      # Check if creator column is enabled for this model
+      def model_creator_enabled?
+        creator_column = whodunit_setting(:creator_column)
+        !creator_column.nil?
+      end
+
+      # Check if updater column is enabled for this model
+      def model_updater_enabled?
+        updater_column = whodunit_setting(:updater_column)
+        !updater_column.nil?
+      end
+
+      # Check if deleter column is enabled for this model
+      def model_deleter_enabled?
+        deleter_column = whodunit_setting(:deleter_column)
+        !deleter_column.nil?
+      end
+
+      # Check if soft delete is enabled for this model
+      def model_soft_delete_enabled?
+        soft_delete_column = whodunit_setting(:soft_delete_column)
+        !soft_delete_column.nil?
+      end
+
       private
 
       def setup_whodunit_associations
-        setup_creator_association if creator_column_exists?
-        setup_updater_association if updater_column_exists?
-        setup_deleter_association if deleter_column_exists? && soft_delete_enabled?
+        setup_creator_association if creator_column_exists? && model_creator_enabled?
+        setup_updater_association if updater_column_exists? && model_updater_enabled?
+        setup_deleter_association if deleter_column_exists? && model_deleter_enabled? && soft_delete_enabled?
       end
 
       def creator_column_exists?
-        column_names.include?(Whodunit.creator_column.to_s)
+        model_creator_enabled? && column_names.include?(whodunit_setting(:creator_column).to_s)
       end
 
       def updater_column_exists?
-        column_names.include?(Whodunit.updater_column.to_s)
+        model_updater_enabled? && column_names.include?(whodunit_setting(:updater_column).to_s)
       end
 
       def deleter_column_exists?
-        column_names.include?(Whodunit.deleter_column.to_s)
+        model_deleter_enabled? && column_names.include?(whodunit_setting(:deleter_column).to_s)
       end
 
       def setup_creator_association
         belongs_to :creator,
-                   class_name: Whodunit.user_class_name,
-                   foreign_key: Whodunit.creator_column,
+                   class_name: whodunit_setting(:user_class).to_s,
+                   foreign_key: whodunit_setting(:creator_column),
                    optional: true
       end
 
       def setup_updater_association
         belongs_to :updater,
-                   class_name: Whodunit.user_class_name,
-                   foreign_key: Whodunit.updater_column,
+                   class_name: whodunit_setting(:user_class).to_s,
+                   foreign_key: whodunit_setting(:updater_column),
                    optional: true
       end
 
       def setup_deleter_association
         belongs_to :deleter,
-                   class_name: Whodunit.user_class_name,
-                   foreign_key: Whodunit.deleter_column,
+                   class_name: whodunit_setting(:user_class).to_s,
+                   foreign_key: whodunit_setting(:deleter_column),
                    optional: true
       end
     end
@@ -124,61 +167,98 @@ module Whodunit
     def set_whodunit_creator
       return unless Whodunit::Current.user_id
 
-      self[Whodunit.creator_column] = Whodunit::Current.user_id
+      self[self.class.whodunit_setting(:creator_column)] = Whodunit::Current.user_id
     end
 
     # Set the updater ID when a record is updated.
     #
     # This method is automatically called before_update if the model has an updater column.
     # It sets the updater_id to the current user from Whodunit::Current.
-    # Does not run on new records (creation).
+    # Does not run on new records (creation) or during soft-delete operations.
     #
     # @return [void]
     # @api private
     def set_whodunit_updater
       return unless Whodunit::Current.user_id
+
       return if new_record? # Don't set updater on creation
 
-      self[Whodunit.updater_column] = Whodunit::Current.user_id
+      return if being_soft_deleted? # Don't set updater during soft-delete
+
+      self[self.class.whodunit_setting(:updater_column)] = Whodunit::Current.user_id
     end
 
-    # Set the deleter ID when a record is destroyed.
+    # Set the deleter ID when a record is destroyed or soft-deleted.
+    #
+    # This method is automatically called in two scenarios:
+    # 1. before_destroy for hard deletes (if deleter column exists)
+    # 2. before_update for soft-deletes (when being_soft_deleted? returns true)
     #
-    # This method is automatically called before_destroy if the model has a deleter column
-    # and soft-delete is enabled. It sets the deleter_id to the current user from Whodunit::Current.
+    # It sets the deleter_id to the current user from Whodunit::Current.
     #
     # @return [void]
     # @api private
     def set_whodunit_deleter
       return unless Whodunit::Current.user_id
 
-      self[Whodunit.deleter_column] = Whodunit::Current.user_id
+      self[self.class.whodunit_setting(:deleter_column)] = Whodunit::Current.user_id
     end
 
     # @!group Column Presence Checks
 
-    # Check if the model has a creator column.
+    # Check if the model has a creator column and it's enabled.
     #
-    # @return [Boolean] true if the creator column exists
+    # @return [Boolean] true if the creator column exists and is enabled
     # @api private
     def creator_column?
-      self.class.column_names.include?(Whodunit.creator_column.to_s)
+      return false unless self.class.model_creator_enabled?
+
+      column_name = self.class.whodunit_setting(:creator_column).to_s
+      self.class.column_names.include?(column_name)
     end
 
-    # Check if the model has an updater column.
+    # Check if the model has an updater column and it's enabled.
     #
-    # @return [Boolean] true if the updater column exists
+    # @return [Boolean] true if the updater column exists and is enabled
     # @api private
     def updater_column?
-      self.class.column_names.include?(Whodunit.updater_column.to_s)
+      return false unless self.class.model_updater_enabled?
+
+      column_name = self.class.whodunit_setting(:updater_column).to_s
+      self.class.column_names.include?(column_name)
     end
 
-    # Check if the model has a deleter column.
+    # Check if the model has a deleter column and it's enabled.
     #
-    # @return [Boolean] true if the deleter column exists
+    # @return [Boolean] true if the deleter column exists and is enabled
     # @api private
     def deleter_column?
-      self.class.column_names.include?(Whodunit.deleter_column.to_s)
+      return false unless self.class.model_deleter_enabled?
+
+      column_name = self.class.whodunit_setting(:deleter_column).to_s
+      self.class.column_names.include?(column_name)
+    end
+
+    # Check if the current update operation is a soft-delete.
+    #
+    # Uses ActiveRecord's dirty tracking to detect if any soft-delete columns
+    # are being changed from nil to a timestamp, which indicates a soft-delete operation.
+    #
+    # @return [Boolean] true if this update is setting a soft-delete timestamp
+    # @api private
+    def being_soft_deleted?
+      return false unless deleter_column?
+      return false unless Whodunit::Current.user_id
+
+      soft_delete_column = self.class.whodunit_setting(:soft_delete_column)
+      return false unless soft_delete_column
+
+      # Simple: just check the configured soft-delete column
+      column_name = soft_delete_column.to_s
+      attribute_changed?(column_name) &&
+        attribute_was(column_name).nil? &&
+        !send(column_name).nil?
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/whodunit/table_definition_extension.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Whodunit
+  # Extension for ActiveRecord::ConnectionAdapters::TableDefinition to automatically
+  # inject whodunit_stamps when creating tables.
+  #
+  # This module monkey-patches the TableDefinition's column creation methods to
+  # automatically add whodunit stamp columns when auto-injection is enabled.
+  #
+  # @example Enabling auto-injection
+  #   Whodunit.configure do |config|
+  #     config.auto_inject_whodunit_stamps = true
+  #   end
+  #
+  #   # Now this migration will automatically include whodunit stamps:
+  #   class CreatePosts < ActiveRecord::Migration[8.0]
+  #     def change
+  #       create_table :posts do |t|
+  #         t.string :title
+  #         t.text :body
+  #         t.timestamps
+  #         # t.whodunit_stamps automatically added at the end!
+  #       end
+  #     end
+  #   end
+  #
+  # @since 0.1.0
+  module TableDefinitionExtension
+    extend ActiveSupport::Concern
+
+    included do
+      # Track whether whodunit_stamps have been automatically added
+      attr_accessor :_whodunit_stamps_added
+    end
+
+    # Override timestamps to trigger automatic whodunit_stamps injection
+    def timestamps(**options)
+      result = super
+
+      # Auto-inject whodunit_stamps after timestamps if enabled and not already added
+      if Whodunit.auto_inject_whodunit_stamps &&
+         !@_whodunit_stamps_added &&
+         !options[:skip_whodunit_stamps]
+        whodunit_stamps(include_deleter: :auto)
+        @_whodunit_stamps_added = true
+      end
+
+      result
+    end
+
+    # Also override whodunit_stamps to track that they've been added
+    def whodunit_stamps(**options)
+      @_whodunit_stamps_added = true
+      super
+    end
+  end
+end

data/lib/whodunit/version.rb

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

data/lib/whodunit.rb

@@ -3,10 +3,10 @@
 require "active_support/all"
 require_relative "whodunit/version"
 require_relative "whodunit/current"
-require_relative "whodunit/soft_delete_detector"
 require_relative "whodunit/stampable"
 require_relative "whodunit/migration_helpers"
 require_relative "whodunit/controller_methods"
+require_relative "whodunit/table_definition_extension"
 require_relative "whodunit/railtie"
 
 # Lightweight creator/updater/deleter tracking for ActiveRecord models.
@@ -55,9 +55,15 @@ module Whodunit
   # @return [Symbol] the deleter column name
   mattr_accessor :deleter_column, default: :deleter_id
 
-  # Whether to automatically detect soft-delete implementations (default: true)
-  # @return [Boolean] auto-detection setting
-  mattr_accessor :auto_detect_soft_delete, default: true
+  # The column name used for soft-delete timestamps (default: nil)
+  # Set to a column name to enable soft-delete support (e.g., :deleted_at, :discarded_at)
+  # Set to nil to disable soft-delete support entirely
+  # @return [Symbol, nil] the soft-delete column name
+  mattr_accessor :soft_delete_column, default: nil
+
+  # Whether to automatically add whodunit_stamps to create_table migrations (default: true)
+  # @return [Boolean] auto-injection setting
+  mattr_accessor :auto_inject_whodunit_stamps, default: true
 
   # @!group Data Type Configuration
 
@@ -88,8 +94,10 @@ module Whodunit
   #
   # @yield [self] configuration block
   # @return [void]
+  # @raise [Whodunit::Error] if both creator_column and updater_column are set to nil
   def self.configure
     yield self
+    validate_column_configuration!
   end
 
   # Get the user class name as a string
@@ -118,4 +126,38 @@ module Whodunit
   def self.deleter_data_type
     deleter_column_type || column_data_type
   end
+
+  # Check if soft-delete is enabled
+  # @return [Boolean] true if soft-delete is configured (soft_delete_column is not nil)
+  def self.soft_delete_enabled?
+    !soft_delete_column.nil?
+  end
+
+  # Check if creator column is enabled
+  # @return [Boolean] true if creator_column is not nil
+  def self.creator_enabled?
+    !creator_column.nil?
+  end
+
+  # Check if updater column is enabled
+  # @return [Boolean] true if updater_column is not nil
+  def self.updater_enabled?
+    !updater_column.nil?
+  end
+
+  # Check if deleter column is enabled
+  # @return [Boolean] true if deleter_column is not nil
+  def self.deleter_enabled?
+    !deleter_column.nil?
+  end
+
+  # Validate that column configuration is valid
+  # @raise [Whodunit::Error] if both creator_column and updater_column are nil
+  def self.validate_column_configuration!
+    return if creator_enabled? || updater_enabled?
+
+    raise Whodunit::Error,
+          "At least one of creator_column or updater_column must be configured (not nil). " \
+          "Setting both to nil would disable all stamping functionality."
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whodunit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -193,11 +193,11 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.9.37
 description: A lightweight Rails gem that provides simple auditing by tracking who
-  created, updated, and deleted ActiveRecord models. Features smart soft-delete detection
-  and zero performance overhead.
+  created, updated, and deleted ActiveRecord models.
 email:
 - kenneth.c.demanawa@gmail.com
-executables: []
+executables:
+- whodunit
 extensions: []
 extra_rdoc_files: []
 files:
@@ -209,16 +209,18 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- exe/whodunit
 - gemfiles/rails_7_2.gemfile
 - gemfiles/rails_8_2.gemfile
 - gemfiles/rails_edge.gemfile
 - lib/whodunit.rb
 - lib/whodunit/controller_methods.rb
 - lib/whodunit/current.rb
+- lib/whodunit/generator.rb
 - lib/whodunit/migration_helpers.rb
 - lib/whodunit/railtie.rb
-- lib/whodunit/soft_delete_detector.rb
 - lib/whodunit/stampable.rb
+- lib/whodunit/table_definition_extension.rb
 - lib/whodunit/version.rb
 - sig/whodunit.rbs
 homepage: https://github.com/kanutocd/whodunit
@@ -230,7 +232,7 @@ metadata:
   source_code_uri: https://github.com/kanutocd/whodunit.git
   changelog_uri: https://github.com/kanutocd/whodunit/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/kanutocd/whodunit/issues
-  documentation_uri: https://github.com/kanutocd/whodunit/blob/main/README.md
+  documentation_uri: https://kanutocd.github.io/whodunit
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -238,9 +240,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/whodunit/soft_delete_detector.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module Whodunit
-  # Smart detection of soft-delete implementations.
-  #
-  # This class provides multi-layered detection for various soft-delete implementations
-  # including popular gems like Discard and Paranoia, as well as custom implementations.
-  #
-  # @example Check if a model has soft-delete enabled
-  #   class Post < ApplicationRecord
-  #     # has deleted_at column
-  #   end
-  #
-  #   Whodunit::SoftDeleteDetector.enabled_for?(Post)  # => true
-  #
-  # @example With Discard gem
-  #   class Post < ApplicationRecord
-  #     include Discard::Model
-  #   end
-  #
-  #   Whodunit::SoftDeleteDetector.enabled_for?(Post)  # => true
-  #
-  # @since 0.1.0
-  class SoftDeleteDetector
-    # Main detection method that checks if soft-delete is enabled for a model.
-    #
-    # Uses multiple detection strategies:
-    # 1. Gem-based detection (Discard, Paranoia, etc.)
-    # 2. Column pattern detection (deleted_at, discarded_at, etc.)
-    # 3. Method-based detection (respond_to? soft-delete methods)
-    #
-    # @param model [Class] the ActiveRecord model class to check
-    # @return [Boolean] true if soft-delete is detected, false otherwise
-    # @example
-    #   Whodunit::SoftDeleteDetector.enabled_for?(Post)  # => true
-    #   Whodunit::SoftDeleteDetector.enabled_for?(User)  # => false
-    def self.enabled_for?(model)
-      return false unless model.respond_to?(:columns)
-
-      gem_based_detection?(model) ||
-        column_pattern_detection(model) ||
-        method_based_detection(model)
-    end
-
-    # Detect popular soft-delete gems.
-    #
-    # Detects the following gems:
-    # - Discard (checks for Discard module inclusion)
-    # - Paranoia (checks for paranoid? method and Paranoid ancestors)
-    # - ActsAsParanoid (checks for acts_as_paranoid method)
-    #
-    # @param model [Class] the ActiveRecord model class to check
-    # @return [Boolean] true if a gem-based soft-delete is detected
-    # @api private
-    def self.gem_based_detection?(model)
-      # Discard gem
-      return true if model.included_modules.any? { |mod| mod.to_s.include?("Discard") }
-
-      # Paranoia gem
-      return true if model.respond_to?(:paranoid?) ||
-                     model.respond_to?(:acts_as_paranoid) ||
-                     model.ancestors.any? { |a| a.to_s.include?("Paranoid") }
-
-      # ActsAsParanoid (older version)
-      return true if model.respond_to?(:acts_as_paranoid)
-
-      false
-    end
-
-    # Detect soft-delete by column patterns.
-    #
-    # Looks for common soft-delete column names:
-    # - deleted_at, destroyed_at, discarded_at, archived_at
-    # - soft_deleted_at, soft_destroyed_at, removed_at
-    #
-    # Only considers timestamp columns (datetime, timestamp, date).
-    #
-    # @param model [Class] the ActiveRecord model class to check
-    # @return [Boolean] true if soft-delete columns are found
-    # @api private
-    def self.column_pattern_detection(model)
-      soft_delete_columns = %w[
-        deleted_at destroyed_at discarded_at archived_at
-        soft_deleted_at soft_destroyed_at removed_at
-      ]
-
-      model.columns.any? do |column|
-        soft_delete_columns.include?(column.name) &&
-          timestamp_column?(column)
-      end
-    end
-
-    # Detect soft-delete by method presence.
-    #
-    # Checks if the model responds to common soft-delete method names.
-    # This catches custom implementations that follow standard naming conventions.
-    #
-    # @param model [Class] the ActiveRecord model class to check
-    # @return [Boolean] true if soft-delete methods are found
-    # @api private
-    def self.method_based_detection(model)
-      soft_delete_methods = %w[
-        deleted_at destroyed_at discarded_at archived_at
-        soft_deleted_at soft_destroyed_at removed_at
-      ]
-
-      soft_delete_methods.any? { |method| model.respond_to?(method) }
-    end
-
-    # Check if a column is a timestamp type.
-    #
-    # @param column [Object] the column object (responds to #type)
-    # @return [Boolean] true if the column is a timestamp type
-    # @api private
-    def self.timestamp_column?(column)
-      %i[datetime timestamp date].include?(column.type)
-    end
-  end
-end