concurrent_rails 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c9f6c5865a512a981fb3be8f87dadffbc2751c0bb8937b4929af57b3fa691a7
-  data.tar.gz: 40e7a30066f9cb04a4093fef697e0e36733d6ca9c7302cbe4b3af4ad7d7e29e7
+  metadata.gz: 14fd5aa53c8cb75c74999acd7e1c43410a9564ba4122d83142f0e3ed8565d429
+  data.tar.gz: 71e60b4e355052fcc328ada6b881b9e41330360aaaa582eff9afb90cab19866f
 SHA512:
-  metadata.gz: 31ba76250826eab804ac7941e6bd33bf9887d367bcf4dcd1b7dca306b3c44287ca1d5c9c75396e7ed8b88168675251ca8df597b4b175c1aa5cee1287fbbb9181
-  data.tar.gz: 3beebfc9b8dc305b555dca571570737247c0409dd67976d0a526d6f37ae64531c2fedafb4de62ef3edb90e867db3ace8131abfa152998b1ff047534c62d7d251
+  metadata.gz: 020b3dee7781090195212145f6faf7f19c311cdee6b619e0601dde476fd3dd2dbe811269da5362794d5903f56ca95eaf56e615dcadb55db454d2a705b6599837
+  data.tar.gz: 9abb0931cb4283b4c9947d7498784c3d0ca0c32e70fb0fbaff9aa29ad28cde0c97ba48bde5f2d07837902cfcb912f987f449b9825658f47f93a7ef1f48bacf32

data/README.md

@@ -9,12 +9,11 @@ The goal of this gem is to provide a simple library that allows the developer to
 
 ## Usage
 
-This library provides three classes that will help you run tasks in parallel: `ConcurrentRails::Promises`,  `ConcurrentRails::Future` and `ConcurrentRails::Multi`
+This library provides three classes that will help you run tasks in parallel: `ConcurrentRails::Promises`,  `ConcurrentRails::Future` ([in process of being deprecated by concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby#deprecated)) and `ConcurrentRails::Multi`
 
 ### Promises
 
-`Promises` is the recommended way from `concurrent-ruby` to create `Future`s as `Concurrent::Future` will be deprecated at some point.
-Similar to other classes, all you have to do is call `.future` helper and pass a block:
+`Promises` is the recommended way from `concurrent-ruby` to create `Future`s as `Concurrent::Future` will be deprecated at some point. All you have to do is call `#future` and pass a block to be executed asynchronously:
 
 ```ruby
 irb(main):001:0> future = ConcurrentRails::Promises.future(5) { |v| sleep(v); 42 }
@@ -40,7 +39,50 @@ irb(main):002:0> future.value
 => 84
 ```
 
-### Future
+### Delayed futures
+
+Delayed future is a future that is enqueued but not run until `#touch` or any other method that requires a resolution is called.
+
+```ruby
+irb(main):002:0> delay = ConcurrentRails::Promises.delay { 42 }
+=> #<ConcurrentRails::Promises:0x00007f8b55333d48 @executor=:io, @instan...
+
+irb(main):003:0> delay.state
+=> :pending
+
+irb(main):004:0> delay.touch
+=> #<Concurrent::Promises::Future:0x00007f8b553325b0 pending>
+
+irb(main):005:0> delay.state
+=> :fulfilled
+
+irb(main):006:0> delay.value
+=> 42
+```
+
+Three methods will trigger a resolution: `#touch`, `#value` and `#wait`: `#touch` will simply trigger the execution but won't block the main thread, while `#wait` and `#value` will block the main thread until a resolution is given.
+
+### Callbacks
+
+Delayed and regular futures can set a callback to be executed after the resolution of the future. There are three different callbacks:
+
+* `on_resolution`: runs after the future is resolved and yields three parameters to the callback in the following order: `true/false` for future's fulfillment, `value` as the result of the future execution, and `reason`, that will be `nil` if the future fulfilled or the error that the future triggered.
+
+* `on_fulfillment`: runs after the future is fulfilled and yields `value` to the callback
+
+* `on_rejection`: runs after the future is rejected and yields the `error` to the callback
+
+```ruby
+delay = ConcurrentRails::Promises.delay { complex_find_user_query }.
+        on_fulfillment { |user| user.update!(name: 'John Doe') }.
+        on_rejection { |reason| log_error(reason) }
+
+delay.touch
+```
+
+All of these callbacks have a bang version (e.g. `on_fulfillment!`). The bang version will execute the callback on the same thread pool that was initially set up and the version without bang will run asynchronously on a different executor.
+
+### (Deprecated) Future
 
 `ConcurrentRails::Future` will execute your code in a separated thread and you can check the progress of it whenever you need it. When the task is ready, you can access the result with `#result` function:
 
@@ -81,7 +123,7 @@ irb(main):005:0> future.reason
 => #<ZeroDivisionError: divided by 0>
 ```
 
-### Multi
+### (Deprecated) Multi
 
 `ConcurrentRails::Multi` will let you execute multiple tasks in parallel and aggregate the results of each task when they are done. `Multi` accepts an undefined number of `Proc`s.
 
@@ -143,7 +185,7 @@ For more information on how Futures work and how Rails handle multithread check
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'concurrent_rails', '~> 0.1.3'
+gem 'concurrent_rails', '~> 0.2.0'
 ```
 
 And then execute:

data/lib/concurrent_rails.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require 'concurrent_rails/version'
-require 'concurrent_rails/railtie'
 require 'concurrent_rails/future'
 require 'concurrent_rails/multi'
 require 'concurrent_rails/promises'
-
-module ConcurrentRails
-end
+require 'concurrent_rails/railtie'
+require 'concurrent_rails/version'

data/lib/concurrent_rails/adapters/delay.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ConcurrentRails::Adapters
+  module Delay
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def delay(*args, &task)
+        delay_on(:io, *args, &task)
+      end
+
+      def delay_on(executor, *args, &task)
+        new(executor).delay_on_rails(*args, &task)
+      end
+    end
+
+    def delay_on_rails(*args, &task)
+      @instance = rails_wrapped { delay_on(executor, *args, &task) }
+
+      self
+    end
+
+    delegate :touch, to: :instance
+  end
+end

data/lib/concurrent_rails/adapters/future.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConcurrentRails::Adapters
+  module Future
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def future(*args, &task)
+        future_on(:io, *args, &task)
+      end
+
+      def future_on(executor, *args, &task)
+        new(executor).future_on_rails(*args, &task)
+      end
+    end
+
+    def future_on_rails(*args, &task)
+      @instance = rails_wrapped { future_on(executor, *args, &task) }
+
+      self
+    end
+  end
+end

data/lib/concurrent_rails/future.rb

@@ -2,11 +2,10 @@
 
 module ConcurrentRails
   class Future
-    extend Forwardable
-
     def initialize(executor: :io, &block)
       @executor = executor
       @future   = run_on_rails(block)
+      # ActiveSupport::Deprecation.warn('Concurrent::Future is deprecated')
     end
 
     def execute
@@ -15,30 +14,32 @@ module ConcurrentRails
       self
     end
 
-    def value
-      Rails.application.executor.wrap do
-        result = nil
-
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          result = future.value
+    %i[value value!].each do |method_name|
+      define_method method_name do
+        rails_wrapped do
+          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+            future.__send__(method_name)
+          end
         end
-
-        result
       end
     end
 
-    def_delegators :@future, :state, :reason, :rejected?, :complete?, :add_observer
+    delegate :state, :reason, :rejected?, :complete?, :add_observer, to: :future
 
     private
 
     def run_on_rails(block)
-      @future = Rails.application.executor.wrap do
+      @future = rails_wrapped do
         Concurrent::Future.new(executor: executor) do
-          Rails.application.executor.wrap(&block)
+          rails_wrapped(&block)
         end
       end
     end
 
+    def rails_wrapped(&block)
+      Rails.application.executor.wrap(&block)
+    end
+
     attr_reader :executor, :future
   end
 end

data/lib/concurrent_rails/multi.rb

@@ -30,6 +30,10 @@ module ConcurrentRails
       futures.map(&:value)
     end
 
+    def compute!
+      futures.map(&:value!)
+    end
+
     def complete?
       futures.all?(&:complete?)
     end

data/lib/concurrent_rails/promises.rb

@@ -1,48 +1,70 @@
 # frozen_string_literal: true
 
+require 'concurrent_rails/adapters/future'
+require 'concurrent_rails/adapters/delay'
+
 module ConcurrentRails
   class Promises
     include Concurrent::Promises::FactoryMethods
-    extend Forwardable
+    include ConcurrentRails::Adapters::Delay
+    include ConcurrentRails::Adapters::Future
 
-    def self.future(*args, &task)
-      new.run_on_rails(*args, &task)
+    def initialize(executor)
+      @executor = executor
     end
 
-    def then(*args, &task)
-      @future_instance = Rails.application.executor.wrap do
-        future_instance.then(*args, &task)
+    %i[value value!].each do |method_name|
+      define_method(method_name) do |timeout = nil, timeout_value = nil|
+        permit_concurrent_loads do
+          instance.__send__(method_name, timeout, timeout_value)
+        end
       end
-
-      self
     end
 
-    %i[value value!].each do |method_name|
-      define_method method_name do
-        Rails.application.executor.wrap do
-          result = nil
-
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-            result = future_instance.__send__(method_name)
-          end
-
-          result
+    %i[then chain].each do |chainable|
+      define_method(chainable) do |*args, &task|
+        method = "#{chainable}_on"
+        @instance = rails_wrapped do
+          instance.__send__(method, executor, *args, &task)
         end
+
+        self
       end
     end
 
-    def run_on_rails(*args, &task)
-      @future_instance = Rails.application.executor.wrap do
-        future_on(default_executor, *args, &task)
+    %i[on_fulfillment on_rejection on_resolution].each do |method|
+      define_method(method) do |*args, &callback_task|
+        rails_wrapped do
+          @instance = instance.__send__("#{method}_using", executor, *args, &callback_task)
+        end
+
+        self
       end
 
-      self
+      define_method("#{method}!") do |*args, &callback_task|
+        rails_wrapped do
+          @instance = instance.__send__(:add_callback, "callback_#{method}", args, callback_task)
+        end
+
+        self
+      end
     end
 
-    def_delegators :@future_instance, :state, :reason, :rejected?, :complete?
+    delegate :state, :reason, :rejected?, :resolved?, :fulfilled?, :wait,
+             to: :instance
 
     private
 
-    attr_reader :future_instance
+    def rails_wrapped(&block)
+      Rails.application.executor.wrap(&block)
+    end
+
+    def permit_concurrent_loads(&block)
+      rails_wrapped do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads(&block)
+      end
+    end
+
+    attr_reader :executor, :instance
   end
 end

data/lib/concurrent_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConcurrentRails
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-20 00:00:00.000000000 Z
+date: 2021-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.12'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 description: Small library to make concurrent-ruby and Rails play nice together
 email:
 - luizeduardokowalski@gmail.com
@@ -63,19 +91,20 @@ files:
 - README.md
 - Rakefile
 - lib/concurrent_rails.rb
+- lib/concurrent_rails/adapters/delay.rb
+- lib/concurrent_rails/adapters/future.rb
 - lib/concurrent_rails/future.rb
 - lib/concurrent_rails/multi.rb
 - lib/concurrent_rails/promises.rb
 - lib/concurrent_rails/railtie.rb
 - lib/concurrent_rails/version.rb
-- lib/tasks/concurrent_rails_tasks.rake
 homepage: https://github.com/luizkowalski/concurrent_rails
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/luizkowalski/concurrent_rails
   source_code_uri: https://github.com/luizkowalski/concurrent_rails
-  changelog_uri: https://github.com/luizkowalski/concurrent_rails/CHANGELOG.md
+  changelog_uri: https://github.com/luizkowalski/concurrent_rails/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -91,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.17
 signing_key:
 specification_version: 4
 summary: Multithread is hard

data/lib/tasks/concurrent_rails_tasks.rake

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-# desc "Explaining what the task does"
-# task :concurrent_rails do
-#   # Task goes here
-# end