laters 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6ad4e042b43cac1765ea61b494fc1ec86ebe4fcfb68c888be4e2a7fdded4985
-  data.tar.gz: 86b3ffe9dab1b85dc2ca73dac4417d3a8b71d25aadda551927e32d4389784a64
+  metadata.gz: 85e450085da66e2a32ab240a767416ee4f4c7cb04d891a4e6d4b1ec8c2febe15
+  data.tar.gz: 7ffc6eae552ccab18d82b24e736e4c1969fcb6aa51425c82489cea16e5cd0f79
 SHA512:
-  metadata.gz: ce904311b5114eef4e8c7b4d2569a49c46ca17e184a570ae3829eda0a7f508b850fba966307d8de583eecb253e683a3280aee9ebfe793b90ee67d9d58085199e
-  data.tar.gz: 2c8d9566b52771b4494bc01736f5db1e677d68a5ff36798534d18440ee0e9245c5bd8380ac6b8dcb73916523382b7de4c66e7e7e311384e235308b808d5a0073
+  metadata.gz: 4930a10d29d4704bc1848100d84d035f38d560f8c9ef5985d7e3d21d9c77c3541750f845762ec311be29cafa17e294ede912c230802fb4dc5ccd3428c97913fb
+  data.tar.gz: 4cf150e51867955a1941a42af2df24444962d934f7fe551b8fb4380d12bd12acd3466b0c6ebf0afc51635ed3ead2bf7e238693d46c8b025225759fb8abc724ae

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+# 0.3.0 (18-3-2025)
+
+## New Features
+- Added scheduled job support via `wait`, `wait_until`, and `priority` options
+- Support ActiveJob scheduling options with the same interface as `perform_later`
+
+## Bug Fixes and Improvements
+- Fixed compatibility issues with newer Ruby and Rails versions
+- Fixed DidYouMean deprecation warnings by upgrading Thor dependency
+- Fixed Logger class compatibility with ActiveSupport
+- Improved test suite with additional edge cases
+
+# 0.2.0 (15-3-2025)
+
+## Major Enhancements
+- Added official support for Rails 5.0 through 8.0
+- Added support for Ruby 3.0 through 3.4
+- Added comprehensive YARD documentation for all methods and classes
+
+## Improvements
+- Enhanced callback support with comprehensive tests (`before_laters`, `after_laters`, `around_laters`)
+- Added proper keyword arguments support throughout the codebase
+- Fixed compatibility with ActiveJob in Rails 7+
+- Updated Thor dependency to fix DidYouMean warnings
+- Added test cases for all scheduling and parameter options
+- Added time-related testing helpers to improve test reliability
+
+# 0.1.2 (26-8-2020)
+
+- Add build badge to readme
+- Remove Zeitwerk
+
 # 0.1.1 (23-8-2020)
 
 - Rename gem to `laters`

data/CLAUDE.md

@@ -0,0 +1,30 @@
+# CLAUDE.md - Laters Ruby Gem
+
+## Build/Test Commands
+- Run all tests: `bundle exec rake spec`
+- Run single test: `bundle exec rspec spec/path_to_spec.rb:line_number`
+- Run RuboCop lint: `bundle exec rubocop`
+- Install dependencies: `bundle install`
+- Test with specific Rails version: `RAILS_VERSION=7.0 bundle install && bundle exec rake`
+
+## Code Style Guidelines
+- Follow standard Ruby style conventions
+- Use RuboCop 1.25+ for linting
+- RSpec tests use expect syntax (not should syntax)
+- Use 2 space indentation
+- Private methods are grouped with `private` keyword
+- Callbacks are defined after regular methods
+- Class methods are defined before instance methods
+- ActiveRecord models follow Rails naming conventions
+- Error handling uses custom `Laters::Error` class
+- Use keyword arguments in method signatures for Rails 7+ compatibility
+- Documentation in README for public API features
+
+## Project Structure
+The gem follows standard Rails gem structure with:
+- `lib/laters.rb` as main entry point
+- ActiveRecord models include `Laters::Concern`
+- Test suite uses RSpec with Combustion for Rails engine testing
+- Queue configuration via `run_in_queue` class method
+- Callbacks: `before_laters`, `after_laters`, `around_laters`
+- Compatible with Rails 5.0 through 8 and Ruby 3.0 through 3.4

data/README.md

@@ -1,8 +1,12 @@
-# Laters
+# Laters 👋
+[![Gem Version](https://badge.fury.io/rb/laters.svg)](https://badge.fury.io/rb/laters)
 
-Run any instance_method of ActiveRecord models via a job by adding `_later` to it. Laters 👋, means See you later in
+Run any instance_method of ActiveRecord models via a job by adding `_later` to it. Laters, means See you later in
 Dutch 🇳🇱
 
+Compatible with Rails 5.0 through 8 and Ruby 3.0 through 3.4.
+
+
 ## Installation
 
 Add to your Gemfile
@@ -23,7 +27,7 @@ class User < ApplicationRecord
   include Laters::Concern
 
   after_create_commit :notify_user_later
-  after_commit :refresh_cache_later
+  after_commit :generate_ai_summary_later
 
   private
 
@@ -32,8 +36,18 @@ class User < ApplicationRecord
     Sms.send(to: user.phone, message: 'Hey!')
   end
 
-  def refresh_cache!
-    # Expensive calculation
+  def generate_ai_summary
+    # Call Claude API to generate a summary asynchronously
+    prompt = "Summarize this user profile: #{name}, #{bio}"
+    
+    response = AnthropicClient.complete(
+      model: "claude-3-7-sonnet",
+      prompt: prompt,
+      max_tokens: 150
+    )
+    
+    # Store the AI-generated summary
+    update(ai_summary: response.completion)
   end
 end
 ```
@@ -48,7 +62,27 @@ class User < ApplicationRecord
 end
 ```
 
-If you need callbacks, they are provided as standart model callbacks:
+### Scheduling Options
+
+You can use ActiveJob's scheduling options when calling methods with `_later`:
+
+```rb
+# Run 5 minutes from now
+user.send_welcome_email_later(wait: 5.minutes)
+
+# Run at a specific time
+user.send_welcome_email_later(wait_until: 1.day.from_now)
+
+# Set a priority (if supported by your queue adapter)
+user.send_welcome_email_later(priority: 10)
+
+# With method arguments
+user.send_email_later('Welcome!', cc: admin@example.com, wait: 10.minutes)
+```
+
+### Callbacks
+
+If you need callbacks, they are provided as standard model callbacks:
 
 ```rb
 class User < ApplicationRecord

data/Rakefile

@@ -1,6 +1,19 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
+# Silence the DidYouMean deprecation warnings 
+if defined?(DidYouMean) && DidYouMean.respond_to?(:correct_error) && defined?(DidYouMean::SPELL_CHECKERS)
+  # Monkey patch DidYouMean to suppress deprecation warnings
+  DidYouMean::SPELL_CHECKERS.singleton_class.prepend(Module.new do
+    def merge!(error_name, spell_checker)
+      DidYouMean.correct_error(error_name, spell_checker)
+    end
+  end)
+end
+
+# Silence URI redefinition warnings in Ruby 3.2+
+$VERBOSE = nil if RUBY_VERSION >= '3.2.0'
+
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec

data/lib/laters/concern.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Laters
+  # Main concern that provides asynchronous execution of ActiveRecord model methods
+  #
+  # This module adds the ability to defer execution of an instance method
+  # to a background job by calling a method with the `_later` suffix.
+  #
+  # @example
+  #   class User < ActiveRecord::Base
+  #     include Laters::Concern
+  #     
+  #     def send_welcome_email
+  #       # Some long running task
+  #     end
+  #   end
+  #   
+  #   # Basic usage (executes in background)
+  #   user.send_welcome_email_later
+  #
+  #   # With scheduling options
+  #   user.send_welcome_email_later(wait: 5.minutes)
+  #   user.send_welcome_email_later(wait_until: 1.day.from_now)
+  #
+  module Concern
+    extend ActiveSupport::Concern
+    include ActiveModel::Callbacks
+
+    # Define laters callbacks when concern is included
+    included { define_model_callbacks :laters }
+
+    class_methods do
+      # @return [Symbol, nil] The queue name to use for background jobs
+      attr_reader :job_queue
+
+      private
+
+      # Configure the queue to use for background jobs
+      #
+      # @param [Symbol] queue The queue name to use for jobs
+      # @return [Symbol] The configured queue name
+      # @example
+      #   class Comment < ActiveRecord::Base
+      #     include Laters::Concern
+      #     run_in_queue :low
+      #   end
+      def run_in_queue(queue)
+        @job_queue = queue
+      end
+    end
+
+    private
+
+    # Handles method calls with _later suffix by enqueueing background jobs
+    #
+    # @param [Symbol] method The method being called
+    # @param [Array] args Arguments to pass to the method
+    # @param [Hash] kwargs Keyword arguments to pass to the method
+    #   Special kwargs for job scheduling are extracted:
+    #   @option kwargs [Integer] :wait Time in seconds to wait before executing
+    #   @option kwargs [Time] :wait_until Specific time to execute the job
+    #   @option kwargs [Integer] :priority Priority for the job
+    # @param [Proc] block Block to pass to the method (unused)
+    # @return [ActiveJob::Base] The enqueued job
+    # @raise [NoMethodError] If the method doesn't exist
+    def method_missing(method, *args, **kwargs, &block)
+      if (method_to_call = deferrable_method_name(method))
+        # Extract ActiveJob options if they exist in kwargs
+        job_options = { queue: self.class.job_queue || :default }
+        
+        # Move scheduling options from kwargs to job_options
+        job_options[:wait] = kwargs.delete(:wait) if kwargs.key?(:wait)
+        job_options[:wait_until] = kwargs.delete(:wait_until) if kwargs.key?(:wait_until)
+        job_options[:priority] = kwargs.delete(:priority) if kwargs.key?(:priority)
+        
+        # Set all options at once
+        InstanceMethodJob
+          .set(job_options)
+          .perform_later(self, method_to_call, *args, **kwargs)
+      else
+        super
+      end
+    end
+
+    # Determines if the object responds to a method with _later suffix
+    #
+    # @param [Symbol] method_name The method name to check
+    # @param [Boolean] include_private Whether to include private methods
+    # @return [Boolean] True if the method can be handled
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.ends_with?('_later') || super
+    end
+
+    # Extracts the actual method name from a method with _later suffix
+    #
+    # @param [Symbol] deferring_method Name of the deferring method that was called
+    # @return [String, nil] The actual method name to call or nil if not applicable
+    # @example
+    #   deferrable_method_name(:send_email_later) # => "send_email"
+    #   deferrable_method_name(:save_later) # => "save!" (if save! exists)
+    def deferrable_method_name(deferring_method)
+      return unless (method = deferring_method.to_s).ends_with? '_later'
+
+      method.chomp! '_later'
+      if respond_to? "#{method}!", true
+        "#{method}!"
+      elsif respond_to? method, true
+        method
+      end
+    end
+  end
+end

data/lib/laters/instance_method_job.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Laters
+  # Job class that executes deferred instance methods with callbacks
+  #
+  # This job is responsible for executing a method on an ActiveRecord object
+  # in the background. It runs all registered callbacks around the method execution.
+  #
+  # @example
+  #   # This job is automatically used by the Laters::Concern
+  #   InstanceMethodJob.perform_later(user, "send_welcome_email", arg1, arg2)
+  #
+  class InstanceMethodJob < (Rails.application.config.respond_to?(:active_job) ? 
+                             Rails.application.config.active_job.base_job || ActiveJob::Base : 
+                             ActiveJob::Base)
+    # Executes the specified method on the given object
+    #
+    # @param [Object] object The object to call the method on
+    # @param [String] method_name The name of the method to call
+    # @param [Array] args Arguments to pass to the method
+    # @param [Hash] kwargs Keyword arguments to pass to the method
+    # @return [Object] The result of the method call
+    # @raise [Exception] Any exception raised by the method
+    def perform(object, method_name, *args, **kwargs)
+      if object.respond_to? :id
+        Rails.logger.info "Calling deferred #{method_name} on #{object.class} ##{object.id}"
+      else
+        Rails.logger.info "Calling deferred #{object.class}##{method_name}"
+      end
+
+      object.run_callbacks(:laters) { object.send(method_name, *args, **kwargs) }
+    end
+  end
+end

data/lib/laters/version.rb

@@ -1,3 +1,3 @@
 module Laters
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/lib/laters.rb

@@ -1,14 +1,11 @@
 require 'laters/version'
+
+require 'active_support'
 require 'active_model'
 require 'active_job'
-require 'zeitwerk'
-loader = Zeitwerk::Loader.for_gem
-loader.push_dir('app/models/concerns')
-loader.push_dir('app/jobs')
-loader.setup
+require 'laters/concern'
+require 'laters/instance_method_job'
 
 module Laters
   class Error < StandardError; end
 end
-
-loader.eager_load

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: laters
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kieran Klaassen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-23 00:00:00.000000000 Z
+date: 2025-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -17,28 +17,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 - !ruby/object:Gem::Dependency
-  name: zeitwerk
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.2.0
 description: Deferrable empowers a class to run every single defined method wrapped
   in an ActiveJob of any class that includes it
 email:
@@ -48,13 +54,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
-- app/jobs/laters/instance_method_job.rb
-- app/models/concerns/laters/concern.rb
 - lib/laters.rb
+- lib/laters/concern.rb
+- lib/laters/instance_method_job.rb
 - lib/laters/version.rb
 homepage: https://github.com/kieranklaassen/laters
 licenses:
@@ -71,14 +78,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 3.0.0
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '3.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Run any instance_method in ActiveRecord models via a job by adding `_later`

data/app/jobs/laters/instance_method_job.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Laters
-  class InstanceMethodJob < ActiveJob::Base
-    def perform(object, method_name, *args)
-      if object.respond_to? :id
-        Rails.logger.info "Calling deferred #{method_name} on #{object.class} ##{object.id}"
-      else
-        Rails.logger.info "Calling deferred #{object.class}##{method_name}"
-      end
-
-      object.run_callbacks(:laters) { object.send(method_name, *args) }
-    end
-  end
-end

data/app/models/concerns/laters/concern.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Laters
-  module Concern
-    extend ActiveSupport::Concern
-    include ActiveModel::Callbacks
-
-    included { define_model_callbacks :laters }
-
-    class_methods do
-      attr_reader :job_queue
-
-      private
-
-      def run_in_queue(queue)
-        @job_queue = queue
-      end
-    end
-
-    private
-
-    def method_missing(method, *args, &block)
-      if (method_to_call = deferrable_method_name(method))
-        InstanceMethodJob
-          .set(queue: self.class.job_queue || :default)
-          .perform_later(self, method_to_call, *args)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      method_name.to_s.ends_with?('_later') || super
-    end
-
-    # @param [Symbol] deferring_method Name of the deferring method that was called
-    def deferrable_method_name(deferring_method)
-      return unless (method = deferring_method.to_s).ends_with? '_later'
-
-      method.chomp! '_later'
-      if respond_to? "#{method}!", true
-        "#{method}!"
-      elsif respond_to? method, true
-        method
-      end
-    end
-  end
-end