whodunit 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c68bbab9b951c3ed257a22769b665e0525f8b41ecb23c3f7375488cc099f9f65
-  data.tar.gz: 3e23380c8ba1502e359c768fe4a99fe3af499598801de896cc030075b8db7de5
+  metadata.gz: 1ce926c88b69914bd703491e1bf11f890f64a4c4f5679929d1b898306ea18fcd
+  data.tar.gz: 3b277cf8bbf1f36e494f90f959941c38b3829f541b5b36b1168b98a276d830f7
 SHA512:
-  metadata.gz: 14e70828520db567bb75dbc472c961fc292281183f630d66d2543e47680947668cd17fc03db2491fa1b0cd52fc423941ca0e73b83e2bca65cbf811a5fdbfc55c
-  data.tar.gz: 6fe6fb76793405dac3ff6f7ad799aa0736e4a5cdfdd4c878b435210606570ce130a73eb570498efb8fc41e1ff1790c44496aae307dba0af689f5ad3fb416d7e2
+  metadata.gz: 68b739ee97b145af1451991f589dfd9353da7ff579592e9f45071c532ed095e2b83e166b30b987bdbd6a22f1f47b421d1dc76fce7818491889376a0249ecdd21
+  data.tar.gz: 3796e3c88a21640063c504d27f3fa34a16f077eac5653826cd7a0a4ad513288dec0aa88383afa633daac57d25719711e2325cc33e01079f00725f76d2d22270d

data/.rubocop.yml

@@ -6,13 +6,14 @@ plugins:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.1
   Exclude:
     - 'vendor/**/*'
     - 'tmp/**/*'
     - 'coverage/**/*'
     - 'bin/**/*'
     - 'sig/**/*'
+    - 'example/**/*'
 
 # Layout & Formatting
 Layout/LineLength:

data/CHANGELOG.md

@@ -7,6 +7,60 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+
+- 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 +90,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

@@ -34,6 +34,23 @@ 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,14 +123,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:
+
+```ruby
+# Most common soft-delete column (default)
+config.soft_delete_column = :deleted_at
 
-- **Discard** (`gem 'discard'`)
-- **Paranoia** (`gem 'paranoia'`)
-- **ActsAsParanoid** (`gem 'acts_as_paranoid'`)
-- **Custom implementations** with timestamp columns like `deleted_at`, `discarded_at`, etc.
+# 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 +152,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 +171,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/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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "generator/application_record_integration"
+
+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|
+      #   # 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
+      #                                             # 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
+      #   # 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
+
+    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)
+      ApplicationRecordIntegration.handle_application_record_integration!
+      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. 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
+
+    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