Make sidekiqable first version

Author: r3cha

CLAUDE.md

@@ -44,15 +44,18 @@ bin/setup              # Install dependencies
 - Entry point module that classes extend to gain async capabilities
 - Defines three simple methods: `perform_async`, `perform_in(interval)`, and `perform_at(timestamp)`
 - Each method returns an `AsyncProxy` instance configured for the appropriate scheduling mode
-- No method wrapping or interception - just three straightforward class methods
+- Provides `sidekiqable_options(options)` method for per-class configuration
+- Options set per-class take precedence over global configuration
+- No method wrapping or interception - just straightforward class methods
 
 **`Sidekiqable::AsyncProxy`** (lib/sidekiqable/async_proxy.rb)
 - Simple proxy returned by `perform_async`, `perform_in`, and `perform_at`
 - Uses `method_missing` to catch the actual method call (e.g., `.boo(1, 2)`)
-- Validates arguments are Sidekiq-serializable via `Sidekiq.dump_json`
+- Validates arguments are Sidekiq-serializable via `Sidekiq.dump_json` (can be disabled)
 - Raises error if blocks are passed (cannot be serialized)
 - Enqueues job to `Worker` with compact payload format: `["ClassName.method_name", *args]`
-- Applies global configuration options (queue, retry) before enqueuing
+- Applies configuration options before enqueuing using Sidekiq's `.set()` API
+- Configuration priority: per-class options > global options > Sidekiq defaults
 
 **`Sidekiqable::Worker`** (lib/sidekiqable/worker.rb)
 - Standard Sidekiq worker that executes scheduled method calls
@@ -62,8 +65,10 @@ bin/setup              # Install dependencies
 
 **`Sidekiqable::Configuration`** (lib/sidekiqable/configuration.rb)
 - Global configuration object accessed via `Sidekiqable.configuration`
-- Supports `queue` and `retry` options applied to all jobs
-- Returns hash of Sidekiq options for worker configuration
+- Supports all standard Sidekiq worker options: `queue`, `retry`, `dead`, `backtrace`, `pool`, `tags`
+- Sidekiqable-specific option: `validate_arguments` (default: true)
+- Returns hash of Sidekiq options for worker configuration via `sidekiq_options`
+- Can be configured via `Sidekiqable.configure` or Rails' `config.sidekiqable`
 
 **`Sidekiqable::Railtie`** (lib/sidekiqable/railtie.rb)
 - Rails integration that exposes `config.sidekiqable` for environment-specific configuration
@@ -84,18 +89,83 @@ bin/setup              # Install dependencies
 2. Method executes immediately (no proxy involved)
 3. Returns result directly
 
+### Configuration System
+
+**Three levels of configuration (in order of precedence):**
+
+1. **Per-class options** (highest priority) - Set via `sidekiqable_options` in the class
+   ```ruby
+   class Foo
+     extend Sidekiqable::AsyncableMethods
+     sidekiqable_options queue: 'high', retry: 3
+   end
+   ```
+
+2. **Global configuration** - Set via `Sidekiqable.configure` or Rails `config.sidekiqable`
+   ```ruby
+   Sidekiqable.configure do |config|
+     config.queue = 'default'
+     config.retry = 5
+     config.validate_arguments = true
+   end
+   ```
+
+3. **Sidekiq defaults** (lowest priority) - Used when not configured
+
+**Available options:**
+- Standard Sidekiq options: `queue`, `retry`, `dead`, `backtrace`, `pool`, `tags`
+- Sidekiqable-specific: `validate_arguments` (enables/disables argument serialization validation)
+
+**How options are applied:**
+- `AsyncProxy` merges per-class and global options
+- Uses Sidekiq's `.set()` API to apply options: `Worker.set(options).perform_async(...)`
+- This happens at enqueue time, not worker definition time
+
 ### Implementation Notes
 
 - No method wrapping or hooks - just simple `method_missing` on proxy objects
 - Compact payload format reduces serialization overhead
 - Clear separation between sync and async code paths
 - All complexity is isolated to the `AsyncProxy` class (~50 lines)
+- Configuration is applied dynamically at enqueue time, not on the Worker class itself
 
 ## Testing Notes
 
-- Uses Minitest for testing
+- Uses Minitest for testing with Sidekiq test mode
 - Test helper location: test/test_helper.rb
-- Current test coverage is minimal (placeholder test exists in test/test_sidekiqable.rb)
+- Tests cover: version check, method presence, async enqueuing, delayed jobs, worker execution, block rejection, and sync calls
+- Run with `rake test` or `bundle exec rake test`
+
+## Key Design Decisions
+
+### Why the current API: `Foo.perform_async.bar(1, 2)`?
+
+This syntax was chosen for clarity and simplicity:
+- **Clear intent**: Starting with `perform_async` makes async behavior explicit
+- **No method wrapping**: Avoids complex metaprogramming with `singleton_method_added` hooks
+- **Familiar**: Similar to Sidekiq's standard `Worker.perform_async` pattern
+- **Simple implementation**: Just 3 methods + proxy with `method_missing` (~60 total lines)
+
+Alternative syntaxes considered:
+- `Foo.bar(1, 2).perform_async` - Requires wrapping ALL methods, adds overhead
+- `Foo.async.bar(1, 2)` - Similar to current, but less Sidekiq-like
+- `Foo.bar_async(1, 2)` - Requires suffix convention, less flexible
+
+### Why compact payload format: `["Foo.bar", 1, 2]`?
+
+- **Reduces serialization size**: One less array element per job
+- **Cleaner Sidekiq UI**: Job args look more natural
+- **No edge cases**: Method names can't contain dots in Ruby, so parsing is safe
+
+Alternative considered:
+- `["Foo", "bar", 1, 2]` - More structured but slightly larger payload
+
+### Why dynamic configuration via `.set()`?
+
+Configuration is applied at enqueue time using `Worker.set(options)` rather than defining `sidekiq_options` on the Worker class:
+- **Flexibility**: Per-class options can override global config
+- **Single worker**: One `Worker` class handles all jobs, options vary per caller
+- **Standard Sidekiq pattern**: Uses `.set()` API that all Sidekiq users know
 
 ## Ruby Version
 

lib/sidekiqable/async_proxy.rb

@@ -42,7 +42,6 @@ def apply_config(worker_class)
       global_options = Sidekiqable.configuration.sidekiq_options
       class_options = @target_class.respond_to?(:sidekiqable_options) ? @target_class.sidekiqable_options : {}
 
-      # Merge global and per-class options (class options take precedence)
       options = global_options.merge(class_options)
 
       options.empty? ? worker_class : worker_class.set(options)

lib/sidekiqable/configuration.rb

@@ -5,10 +5,10 @@ class Configuration
     attr_accessor :queue, :retry, :dead, :backtrace, :pool, :tags, :validate_arguments
 
     def initialize
-      @queue = sidekiq_default("queue")
-      @retry = sidekiq_default("retry")
-      @dead = sidekiq_default("dead")
-      @backtrace = sidekiq_default("backtrace")
+      @queue = "default"
+      @retry = true
+      @dead = true
+      @backtrace = false
       @pool = nil
       @tags = nil
       @validate_arguments = true
@@ -24,19 +24,5 @@ def sidekiq_options
         opts[:tags] = tags if tags
       end
     end
-
-    private
-
-    def sidekiq_default(option)
-      Sidekiq::Worker::ClassMethods::DEFAULT_OPTIONS[option]
-    rescue NameError
-      # Fallback to Sidekiq's documented defaults if DEFAULT_OPTIONS is not available
-      case option
-      when "retry" then true
-      when "queue" then "default"
-      when "dead" then true
-      when "backtrace" then false
-      end
-    end
   end
 end

lib/sidekiqable/version.rb

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

lib/sidekiqable/worker.rb

@@ -2,7 +2,7 @@
 
 module Sidekiqable
   class Worker
-    include Sidekiq::Worker
+    include Sidekiq::Job
 
     def perform(callable, *args)
       class_name, method_name = callable.split(".", 2)