rails_async_methods 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 672c0a204c6d32b0c4b33f9da9b1c9964afc45d9626128ddccf52f77a12bd8c1
-  data.tar.gz: a4cf18a167be4b327aaab34b49875280444fb7f6f52743a85aa1564f2cba2f33
+  metadata.gz: 70a7606803b98d462e11d6de8ee772cf66fd9aa7fe2355a4fc4a315a3b9f6372
+  data.tar.gz: 0ef6b6034c8096c385aac47a0f1cfe7d65e30480d55dbb22f9035de0ddf6091c
 SHA512:
-  metadata.gz: 650de1333dc34b7d8307508d12f4d49eda5ab5e249342727500b7431a4fd81d6ae66cd8d9ad3d5a28a06c2000d24dff7dd7ed625cad55bdb8dfb755a6c8cbd61
-  data.tar.gz: 1e17bb9130bbfef087ebc8cfe86051284c44a12c0234287373dd63536157b47a2bbc31f320a129827c38a0950266b792ebe77bb746360466e8884ea92fb3913e
+  metadata.gz: d6f9cd94c505732b33480f69ebac5d8700a87227b3dd3f803cf39699f41f98d4397e6229286a6e3da4b08d04636eba028d91c0da31303bfcfe3aa559a642dd90
+  data.tar.gz: be4580294350b8bc8d2b67f7946a71f7e4f0b16fd5e08ebc472e5f34e4202a0ada9b3133b886a59752fda6075e85953e7e9bc64a44d5df8c68cc55cc10d9b98b

data/README.md

@@ -1,14 +1,15 @@
 # RailsAsyncMethods
-Rails Async Methods is an opinionated gem meant to remove boilerplate while creating asynchronous rails jobs. It provides a declaritive interface for converting any model method into an asychronous method by provided an abstracted wrapper around rails ActiveJob API.
+Rails Async Methods is an opinionated gem meant to remove boilerplate while creating Rails ActiveJobs. It provides a declarative interface for converting any model method into an asychronous method by providing an abstracted wrapper around rails ActiveJob API.
 
 ## Usage
+### Model Declaration
 ```ruby
 class User
   def example_method
     # logic...
   end
+  async :example_method
 end
-async :example_method
 ```
 This will give you access to ```user_instance.async_example_method```, which when called will use ActiveJob's API to create an ActiveJob with your backend of choice and call the example_method when the job is ran.
 
@@ -19,8 +20,30 @@ def example_method_with_args(a:, b:)
 end
 async :example_method_with_args
 ```
-the ```async_example_method_with_args``` method will have a signature that matches the original method. This makes testing and debugging during development faster, as both sync and async method calls will fail when called instead of silently failing as an active job.
+the ```async_example_method_with_args``` method will have a signature that matches the original method. This makes testing and debugging during development faster, as both sync and async method calls will fail when called with improper arguments instead of silently failing as an active job.
 
+### Object Wrapper
+Alternatively, if you don't to declare methods as async in your model, you can utilize the async object wrapper made available globally to all objects.
+```ruby
+class ResourceController < Application Controller
+    def create
+        async(@resource).any_method_available_to_resource
+    end
+end
+```
+If you don't want to wrap objects in a utility method, you can also use the expressive type converter.
+### Type Converter
+```ruby
+class ResourceService
+    def run
+        @resource.to_active_job.any_method_available_to_resource
+    end
+end
+```
+
+Note: Under the hood, the object wrapper just makes a call ```to_active_job```, so these objects work the same. 
+
+It is recommended that you default to the model declaration syntax.
 ### Options
 
 You can pass the following options to your async declaration.
@@ -34,7 +57,8 @@ user_instance.asynchronous_example_method
 
 - job: use a custom job other than the generated ```RailsAsyncMethods::AbstractJob``` - see section on Custom Jobs below i.e.
 ```ruby
-async :example_method, job: CustomExampleMethodJob
+async :example_method, job: CustomExampleMethodJob # defined in model
+async(@resource, job: CustomExampleMethodJob).example_method #callable anywhere
 ```
 
 - ActiveJob configurations
@@ -43,10 +67,16 @@ async :example_method, job: CustomExampleMethodJob
     - wait: give an amount of time for the job to wait until executing
     - priority: delayed job priority
 ```ruby
-async :example_method, queue: :fast, wait_until: 1.week.from_now, wait: 1.week, priority: 1
+async :example_method, 
+      queue: :fast, 
+      wait_until: 1.week.from_now, 
+      wait: 1.week, 
+      priority: 1 # defined in model
+async(@resource, queue: :fast, wait_until: 1.week.from_now, wait: 1.week, priority: 1).example_method # same as calling @resource.async_example_method when above is defined in model
 ```
 
 ## Installation
+First, make sure your [ActiveJob is setup with the backend of your choice](https://edgeguides.rubyonrails.org/active_job_basics.html#job-execution). 
 Add this line to your application's Gemfile:
 
 ```ruby

data/lib/generators/rails_async_methods_generator.rb

@@ -10,7 +10,7 @@ class RailsAsyncMethodsGenerator < Rails::Generators::Base
           queue_as :default
 
           def perform(receiver, method, *args, **kwargs)
-            receiver.send(method, *args, **kwargs)
+            receiver.public_send(method, *args, **kwargs)
           end
         end
       FILE

data/lib/rails_async_methods/core_ext.rb

@@ -0,0 +1,10 @@
+require 'rails_async_methods/wrapper/async_wrapper'
+require 'rails_async_methods/wrapper/async_jobs'
+
+class Object
+  include RailsAsyncMethods::AsyncJobs
+
+  def to_active_job(options = {})
+    RailsAsyncMethods::AsyncWrapper.new(self, options)
+  end
+end

data/lib/rails_async_methods/version.rb

@@ -1,3 +1,3 @@
 module RailsAsyncMethods
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/rails_async_methods/wrapper/async_jobs.rb

@@ -0,0 +1,9 @@
+require 'rails_async_methods/wrapper/async_wrapper'
+
+module RailsAsyncMethods
+  module AsyncJobs
+    def async(receiver, options = {})
+      receiver.to_active_job options
+    end
+  end
+end

data/lib/rails_async_methods/wrapper/async_wrapper.rb

@@ -0,0 +1,28 @@
+require 'rails_async_methods/active_job_options_parser'
+
+module RailsAsyncMethods
+  class AsyncWrapper
+    class NotPersistedError < StandardError; end
+    attr_reader :receiver, :options
+
+    def initialize(receiver, options = {})
+      @receiver = receiver
+      @options = RailsAsyncMethods::ActiveJobOptionsParser.new(options)
+    end
+
+    def method_missing(method, *args, **kwargs)
+      raise NotPersistedError, 'Instance must be persisted to run asynchronously' unless receiver.persisted?
+      raise TypeError, 'Cannot pass a block to an asynchronous method' if block_given?
+
+      if @receiver.methods.include? method
+        @options.job.set(**@options.to_h).perform_later(@receiver, method, *args, **kwargs)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method)
+      @receiver.methods.include?(method) || super
+    end
+  end
+end

data/lib/rails_async_methods.rb

@@ -1,7 +1,10 @@
 require "rails_async_methods/version"
+require "rails_async_methods/core_ext"
 
 module RailsAsyncMethods
   autoload :AsyncMethod, 'rails_async_methods/async_method'
+  autoload :AsyncWrapper, 'rails_async_methods/wrapper/async_wrapper'
+  autoload :AsyncJobs, 'rails_async_methods/wrapper/async_jobs'
 end
 
 ActiveSupport.on_load(:active_record) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_async_methods
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - benngarcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-13 00:00:00.000000000 Z
+date: 2022-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -109,8 +109,11 @@ files:
 - lib/rails_async_methods.rb
 - lib/rails_async_methods/active_job_options_parser.rb
 - lib/rails_async_methods/async_method.rb
+- lib/rails_async_methods/core_ext.rb
 - lib/rails_async_methods/parameter_parser.rb
 - lib/rails_async_methods/version.rb
+- lib/rails_async_methods/wrapper/async_jobs.rb
+- lib/rails_async_methods/wrapper/async_wrapper.rb
 homepage: https://github.com/benngarcia/rails_async_methods
 licenses:
 - MIT