sidekiqable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f538c5c15a22aa8109453302ddad6bebcd1bc0cde33de3824409f663c80a77b7
+  data.tar.gz: e5f64ef77a91e6328e83bfc4058f9cbbe433c354d880364b70e393fa6fd72ea5
+SHA512:
+  metadata.gz: 6269de6edc907a4fc4797467ae1956734dab6f9a4addb3fd36e41e92c2b974ebb6e46611d2fe610a649157ebaaa4f2351b44e65eec4603be2c0a24244a2e1335
+  data.tar.gz: 60ad9d4cf92e95a72ff5429c555085932b3609994581951740deb7c1d1feccc1191f4e4daf6d4ac54c8a428b2913920b1262e7c12d07a237d07e1f5d5492d129

data/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(bundle exec rake:*)",
+      "Bash(bundle exec rubocop:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-11-09
+
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,178 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Sidekiqable is a Ruby gem that allows scheduling class methods asynchronously via Sidekiq without writing dedicated workers. It uses a simple proxy pattern where you prefix method calls with `perform_async`, `perform_in`, or `perform_at` (e.g., `Foo.perform_async.bar(1, 2)`).
+
+## Development Commands
+
+### Testing
+```bash
+rake test              # Run all tests
+bundle exec minitest test/test_sidekiqable.rb  # Run specific test file
+```
+
+### Linting
+```bash
+rake rubocop           # Run RuboCop linter
+rubocop -A             # Auto-correct offenses
+```
+
+### Build & Install
+```bash
+bundle exec rake install   # Install gem locally
+bundle exec rake release   # Tag and release to RubyGems
+```
+
+### Interactive Console
+```bash
+bin/console            # Launch IRB with gem loaded
+```
+
+### Setup
+```bash
+bin/setup              # Install dependencies
+```
+
+## Architecture
+
+### Core Components
+
+**`Sidekiqable::AsyncableMethods`** (lib/sidekiqable/asyncable_methods.rb)
+- 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
+- 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` (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 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
+- Receives compact payload: `["ClassName.method_name", *args]`
+- Splits the callable string on first dot to extract class name and method name
+- Constantizes class name and invokes method with args via `public_send`
+
+**`Sidekiqable::Configuration`** (lib/sidekiqable/configuration.rb)
+- Global configuration object accessed via `Sidekiqable.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
+- Automatically loaded when Rails is detected
+
+### Execution Flow
+
+**Async Execution:**
+1. User extends class with `Sidekiqable::AsyncableMethods`
+2. User calls `Foo.perform_async` which returns an `AsyncProxy` instance
+3. User chains method call like `.boo(1, 2)`
+4. Proxy's `method_missing` catches the call
+5. Proxy validates arguments and enqueues job to `Worker` with compact payload `["Foo.boo", 1, 2]`
+6. Worker splits "Foo.boo", constantizes `Foo`, and invokes `boo(1, 2)`
+
+**Sync Execution:**
+1. User calls method normally: `Foo.boo(1, 2)`
+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 with Sidekiq test mode
+- Test helper location: test/test_helper.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
+
+Requires Ruby >= 3.1.0 (specified in sidekiqable.gemspec)
+
+## Dependencies
+
+- sidekiq >= 6.0 (runtime dependency)
+- minitest ~> 5.16 (development)
+- rubocop ~> 1.21 (development)

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,175 @@
+# Sidekiqable
+
+Sidekiqable lets you enqueue any class method or modules asynchronously without writing dedicated Sidekiq workers or ActiveJob wrappers. Prefix method calls with `perform_async`, `perform_in`, or `perform_at` and Sidekiqable will serialize the call into a generic worker.
+
+```ruby
+class ReportMailer
+  extend Sidekiqable::AsyncableMethods
+
+  def self.deliver_daily(user_id)
+    UserMailer.daily_report(user_id).deliver_now
+  end
+end
+
+ReportMailer.perform_async.deliver_daily(42)
+ReportMailer.perform_in(5.minutes).deliver_daily(42)
+```
+
+The scheduled job will execute `ReportMailer.deliver_daily(42)` later via `Sidekiqable::Worker`.
+
+## Installation
+
+Add the gem to your application:
+
+```bash
+bundle add sidekiqable
+```
+
+Or install it manually:
+
+```bash
+gem install sidekiqable
+```
+
+### Rails
+
+When used in a Rails application the included Railtie automatically loads Sidekiqable and exposes `config.sidekiqable` for environment-specific defaults.
+
+## Usage
+
+1. Add `Sidekiqable::AsyncableMethods` to any class whose class methods you want to schedule.
+2. Prefix method calls with the desired Sidekiq scheduling helper (`perform_async`, `perform_in`, or `perform_at`).
+
+```ruby
+class Foo
+  extend Sidekiqable::AsyncableMethods
+
+  def self.boo(a, b)
+    Rails.logger.info("boo(#{a}, #{b})")
+  end
+end
+
+# Immediately enqueue
+Foo.perform_async.boo(1, 2)
+
+# Schedule relative to now
+Foo.perform_in(5.minutes).boo(1, 2)
+
+# Schedule at a specific time
+Foo.perform_at(1.day.from_now).boo(1, 2)
+```
+
+Jobs are enqueued with the payload `["Foo.boo", 1, 2]` and executed by `Sidekiqable::Worker`, which constantizes the class and invokes the method.
+
+### Synchronous execution
+
+Normal method calls execute immediately without any async behavior.
+
+```ruby
+Foo.boo(1, 2) # => executes synchronously and returns the original value
+```
+
+### Configuration
+
+#### Global Configuration
+
+Use the global configuration to set default Sidekiq options for all classes. If not configured, Sidekiqable uses Sidekiq's default values:
+
+```ruby
+Sidekiqable.configure do |config|
+  config.queue = "mailers"       # default: "default"
+  config.retry = 5               # default: true
+  config.dead = true             # default: true
+  config.backtrace = 10          # default: false (or integer for lines)
+  config.tags = ["reporting"]    # default: nil
+  config.validate_arguments = true  # default: true (Sidekiqable-specific)
+end
+```
+
+Inside Rails you can configure via `config.sidekiqable`:
+
+```ruby
+# config/application.rb or an environment file
+config.sidekiqable.queue = "low"
+config.sidekiqable.retry = false
+config.sidekiqable.dead = false
+config.sidekiqable.backtrace = false
+config.sidekiqable.tags = ["background"]
+config.sidekiqable.validate_arguments = false  # disable validation for performance
+```
+
+#### Per-Class Configuration
+
+You can override global options for specific classes using `sidekiqable_options`:
+
+```ruby
+class ReportMailer
+  extend Sidekiqable::AsyncableMethods
+  
+  sidekiqable_options queue: 'high_priority', 
+                      retry: 3,
+                      backtrace: 20,
+                      tags: ['mailer', 'critical']
+  
+  def self.deliver_daily(user_id)
+    # ...
+  end
+end
+
+class BackgroundTask
+  extend Sidekiqable::AsyncableMethods
+  
+  sidekiqable_options queue: 'low_priority', 
+                      retry: false,
+                      dead: false
+  
+  def self.cleanup
+    # ...
+  end
+end
+```
+
+Per-class options take precedence over global configuration. Any Sidekiq option supported by `worker.set()` can be used.
+
+#### Available options
+
+**Sidekiq job options** (uses Sidekiq defaults when not configured):
+
+- `queue`: Use a named queue for jobs
+  - **Default:** `"default"`
+- `retry`: Enable retries for jobs. Can be `true`, `false`, or an integer for max retry attempts
+  - **Default:** `true`
+  - **Example:** `retry: 3` (retry up to 3 times)
+- `dead`: Whether a failing job should go to the Dead queue after exhausting retries
+  - **Default:** `true`
+- `backtrace`: Whether to save error backtrace in the retry payload for the Web UI. Can be `true`, `false`, or an integer for number of lines to save
+  - **Default:** `false`
+  - **Warning:** Backtraces are large and can consume significant Redis space with many retries. Consider using an error service like Honeybadger instead.
+- `pool`: Use the given Redis connection pool to push this job type to a specific shard
+  - **Default:** `nil` (uses default Sidekiq connection)
+- `tags`: Add an Array of tags to each job for filtering in the Web UI
+  - **Default:** `nil`
+  - **Example:** `tags: ["reporting", "daily"]`
+
+**Sidekiqable-specific options:**
+
+- `validate_arguments`: Enable/disable argument serialization validation before enqueuing. When enabled, provides clear error messages for non-serializable arguments. Disable for better performance if you're confident your arguments are always serializable.
+  - **Default:** `true`
+
+### Argument safety
+
+By default, arguments are validated with `Sidekiq.dump_json` before enqueuing to ensure they can be serialized by Sidekiq. This validation can be disabled via `config.validate_arguments = false` if needed. Passing a block while enqueuing will always raise an error because Sidekiq cannot persist blocks.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to execute the test suite. You can also run `bin/console` to experiment with the gem.
+
+To install the gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `lib/sidekiqable/version.rb` and then run `bundle exec rake release`. This tags the release and pushes the `.gem` to RubyGems (once your credentials are configured).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/r3cha/sidekiqable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/r3cha/sidekiqable/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/sidekiqable/async_proxy.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sidekiqable
+  class AsyncProxy
+    def initialize(target_class, mode, schedule_arg = nil)
+      @target_class = target_class
+      @mode = mode
+      @schedule_arg = schedule_arg
+    end
+
+    def method_missing(method_name, *args, &block)
+      raise Sidekiqable::Error, "Cannot enqueue blocks to Sidekiq" if block
+
+      super unless %i[perform_async perform_in perform_at].include?(@mode)
+
+      validate_serializable!(method_name, args) if Sidekiqable.configuration.validate_arguments
+
+      worker_class = Sidekiqable::Worker
+      worker = apply_config(worker_class)
+
+      callable = "#{@target_class.name}.#{method_name}"
+      payload = [callable, *args]
+
+      worker.send(@mode, *payload)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @target_class.respond_to?(method_name, include_private)
+    end
+
+    private
+
+    def validate_serializable!(method_name, args)
+      callable = "#{@target_class.name}.#{method_name}"
+      Sidekiq.dump_json([callable, *args])
+    rescue Sidekiq::Error, JSON::GeneratorError => e
+      raise Sidekiqable::Error,
+            "Arguments for #{@target_class}##{method_name} are not Sidekiq-serializable: #{e.message}"
+    end
+
+    def apply_config(worker_class)
+      global_options = Sidekiqable.configuration.sidekiq_options
+      class_options = @target_class.respond_to?(:sidekiqable_options) ? @target_class.sidekiqable_options : {}
+
+      options = global_options.merge(class_options)
+
+      options.empty? ? worker_class : worker_class.set(options)
+    end
+  end
+end

data/lib/sidekiqable/asyncable_methods.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sidekiqable
+  module AsyncableMethods
+    def sidekiqable_options(options = nil)
+      if options
+        @sidekiqable_options = options
+      else
+        @sidekiqable_options ||= {}
+      end
+    end
+
+    def perform_async
+      Sidekiqable::AsyncProxy.new(self, :perform_async)
+    end
+
+    def perform_in(interval)
+      Sidekiqable::AsyncProxy.new(self, :perform_in, interval)
+    end
+
+    def perform_at(timestamp)
+      Sidekiqable::AsyncProxy.new(self, :perform_at, timestamp)
+    end
+  end
+end

data/lib/sidekiqable/configuration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sidekiqable
+  class Configuration
+    attr_accessor :queue, :retry, :dead, :backtrace, :pool, :tags, :validate_arguments
+
+    def initialize
+      @queue = "default"
+      @retry = true
+      @dead = true
+      @backtrace = false
+      @pool = nil
+      @tags = nil
+      @validate_arguments = true
+    end
+
+    def sidekiq_options
+      {}.tap do |opts|
+        opts[:queue] = queue if queue
+        opts[:retry] = @retry unless @retry.nil?
+        opts[:dead] = dead unless dead.nil?
+        opts[:backtrace] = backtrace unless backtrace.nil?
+        opts[:pool] = pool if pool
+        opts[:tags] = tags if tags
+      end
+    end
+  end
+end

data/lib/sidekiqable/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/ordered_options"
+require "rails/railtie"
+
+module Sidekiqable
+  class Railtie < ::Rails::Railtie
+    config.sidekiqable = ActiveSupport::OrderedOptions.new
+
+    initializer "sidekiqable.configure" do |app|
+      options = app.config.sidekiqable
+
+      Sidekiqable.configure do |config|
+        config.queue = options.queue if options.key?(:queue)
+        config.retry = options.retry if options.key?(:retry)
+      end
+    end
+  end
+end

data/lib/sidekiqable/version.rb

@@ -0,0 +1,3 @@
+module Sidekiqable
+  VERSION = "0.0.1"
+end

data/lib/sidekiqable/worker.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sidekiqable
+  class Worker
+    include Sidekiq::Job
+
+    def perform(callable, *args)
+      class_name, method_name = callable.split(".", 2)
+      klass = constantize!(class_name)
+      klass.public_send(method_name, *args)
+    end
+
+    private
+
+    def constantize!(name)
+      Object.const_get(name)
+    rescue NameError => e
+      raise Sidekiqable::Error, "Failed to constantize #{name}: #{e.message}"
+    end
+  end
+end

data/lib/sidekiqable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+require_relative "sidekiqable/version"
+require_relative "sidekiqable/configuration"
+require_relative "sidekiqable/worker"
+require_relative "sidekiqable/async_proxy"
+require_relative "sidekiqable/asyncable_methods"
+require_relative "sidekiqable/railtie" if defined?(Rails::Railtie)
+
+module Sidekiqable
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/sig/sidekiqable.rbs

@@ -0,0 +1,4 @@
+module Sidekiqable
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: sidekiqable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sidekiqable Maintainers
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Sidekiqable lets you enqueue class method invocations directly by chaining
+  perform_async, perform_in, or perform_at without writing boilerplate workers.
+email:
+- opensource@sidekiqable.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".claude/settings.local.json"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sidekiqable.rb
+- lib/sidekiqable/async_proxy.rb
+- lib/sidekiqable/asyncable_methods.rb
+- lib/sidekiqable/configuration.rb
+- lib/sidekiqable/railtie.rb
+- lib/sidekiqable/version.rb
+- lib/sidekiqable/worker.rb
+- sig/sidekiqable.rbs
+homepage: https://github.com/r3cha/sidekiqable
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/r3cha/sidekiqable
+  source_code_uri: https://github.com/r3cha/sidekiqable
+  changelog_uri: https://github.com/r3cha/sidekiqable/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Schedule class methods asynchronously with Sidekiq via a proxy pattern.
+test_files: []