whodunit 0.1.0 → 0.2.1

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.1"
 end