concurrent_rails 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc63638fb76dc139c10b9ed53d61e020f7288bbd13f3bed9c4e5129b93c016c9
-  data.tar.gz: e61aae19d4fd6f1023be007ed77a2edf333a922fe0ab522ea533175e975ce941
+  metadata.gz: 18c6a530ca05cc94c234d366dc6b93cec5c646e3b7cb0413858ea066ced8c5a8
+  data.tar.gz: 3ef23ca30903e60b4418b5117a73c05d0effc00979b765532e5565239468fa31
 SHA512:
-  metadata.gz: f236962918393d4f1a8c81edec667564fc862825940a0ef30e33053d1d1061017172b14cb407eb87177ea1db41471de9c7abafb0648ebd63183b107df1ad3604
-  data.tar.gz: e453ea4cdcd0161d0159dfeaec1931e43dbd992120ecb57953935517d28072a79338a731feb1be660108dd24f3bb376f66f013de3c1653d08a5e4f756ecc0b7e
+  metadata.gz: 6e22fe7e8dfffd950cca1e3e70078cd5a5f705faff659269430070b3e871347fd1161765b3c301a553cf36e64c8d38d72670d4dfd501034025987c17e705752f
+  data.tar.gz: 82dda70e0a8d9f2979c42310b9a2766cd906febc41349b05ce55ee15aee308af7f0c20a46454d182ccb24546eeefeaa9fe3934020ebbeff4437429cc9d445270

data/README.md

@@ -8,11 +8,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` ([in the process of being deprecated by concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby#deprecated)) and `ConcurrentRails::Multi`
+This library provides `ConcurrentRails::Promises`, a Rails-aware wrapper around [`Concurrent::Promises`](https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/Promises.html), plus `ConcurrentRails::Testing` helpers for your test suite.
 
 ### Promises
 
-`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:
+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 }
@@ -33,11 +33,40 @@ The benefit of `Promises` over a pure `Future` class is that you can chain futur
 
 ```ruby
 irb(main):001:0> future = ConcurrentRails::Promises.future { 42 }.then { |v| v * 2 }
-=> #<ConcurrentRails::Promises:0x00007fe92eba3460 @future_instance=#...
+=> #<ConcurrentRails::Promises:0x00007fe92eba3460 @instance=#...
 irb(main):002:0> future.value
 => 84
 ```
 
+`then` and `chain` return a **new** `ConcurrentRails::Promises` instance and leave the receiver untouched, matching `Concurrent::Promises` semantics. This means you can branch multiple chains off the same future:
+
+```ruby
+root    = ConcurrentRails::Promises.future { expensive_call }
+doubled = root.then { |v| v * 2 }
+tripled = root.then { |v| v * 3 } # branches off root, not doubled
+```
+
+### Combinators and factories
+
+`zip` and `any_resolved_future` combine multiple promises; `fulfilled_future` and `rejected_future` create already-resolved ones:
+
+```ruby
+a = ConcurrentRails::Promises.future { 1 }
+b = ConcurrentRails::Promises.future { 2 }
+
+ConcurrentRails::Promises.zip(a, b).value                 # => [1, 2]
+ConcurrentRails::Promises.any_resolved_future(a, b).value # => first to settle
+ConcurrentRails::Promises.fulfilled_future(42).value      # => 42
+```
+
+### Scheduled futures
+
+`schedule` runs a task after the given delay (in seconds):
+
+```ruby
+ConcurrentRails::Promises.schedule(10) { cleanup! }
+```
+
 ### Delayed futures
 
 A delayed future is a Future that is enqueued but not run until `#touch` or any other method that requires a resolution is called.
@@ -50,7 +79,7 @@ irb(main):003:0> delay.state
 => :pending
 
 irb(main):004:0> delay.touch
-=> #<Concurrent::Promises::Future:0x00007f8b553325b0 pending>
+=> #<ConcurrentRails::Promises:0x00007f8b55333d48 ...
 
 irb(main):005:0> delay.state
 => :fulfilled
@@ -79,7 +108,12 @@ delay = ConcurrentRails::Promises.delay { complex_find_user_query }.
 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.
+All of these callbacks have a bang version (e.g. `on_fulfillment!`). The bang version runs the callback synchronously on the thread that resolved the future, while the version without bang runs it asynchronously on the promise's executor.
+
+## Caveats
+
+* `Current` attributes (`ActiveSupport::CurrentAttributes`) are **not** propagated to the future's thread. Each task runs inside `Rails.application.executor.wrap`, which resets per-execution state, so `Current.user` and friends will be `nil` inside the block. Pass what you need as arguments instead.
+* `#value` and `#wait` block the calling thread. In development, a thread blocked inside a future wait counts as a running execution, so code reloading has to wait for it. Prefer `#touch` plus callbacks when you don't need the result immediately.
 
 ## Testing
 
@@ -112,7 +146,9 @@ irb(main):004:0> result.class
 => Integer
 ```
 
-You can also set the strategy globally using `ConcurrentRails::Testing.fake!` or `ConcurrentRails::Testing.immediate!`
+Both strategies also apply to `delay` and `schedule` (`fake` runs a scheduled task right away, ignoring the delay).
+
+The block form only changes the mode for the current thread and restores the previous mode when the block exits, even if it raises. You can also set the strategy globally using `ConcurrentRails::Testing.fake!` or `ConcurrentRails::Testing.immediate!`, and reset it with `ConcurrentRails::Testing.real!`
 
 ## Further reading
 
@@ -127,7 +163,7 @@ For more information on how Futures works and how Rails handles multithread chec
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'concurrent_rails', '~> 0.5.1'
+gem 'concurrent_rails', '~> 0.9'
 ```
 
 And then execute:

data/lib/concurrent_rails/promises.rb

@@ -2,58 +2,82 @@
 
 module ConcurrentRails
   class Promises
-    include Concurrent::Promises::FactoryMethods
-    include ConcurrentRails::DelayAdapter
-    include ConcurrentRails::FutureAdapter
+    class << self
+      %i[future delay schedule].each do |factory|
+        define_method(factory) do |*args, &task|
+          public_send(:"#{factory}_on", :io, *args, &task)
+        end
+
+        define_method(:"#{factory}_on") do |executor, *args, &task|
+          new(executor, Concurrent::Promises.public_send(:"#{factory}_on", executor, *args, &wrap_task(task)))
+        end
+      end
+
+      def zip(*promises)
+        new(:io, Concurrent::Promises.zip(*unwrap(promises)))
+      end
+
+      def any_resolved_future(*promises)
+        new(:io, Concurrent::Promises.any_resolved_future(*unwrap(promises)))
+      end
+
+      def fulfilled_future(value, executor = :io)
+        new(executor, Concurrent::Promises.fulfilled_future(value))
+      end
+
+      def rejected_future(reason, executor = :io)
+        new(executor, Concurrent::Promises.rejected_future(reason))
+      end
+
+      def wrap_task(task)
+        proc { |*args| Rails.application.executor.wrap { task.call(*args) } }
+      end
 
-    def initialize(executor)
+      private
+
+      def unwrap(promises)
+        promises.map { |p| p.is_a?(Promises) ? p.__send__(:instance) : p }
+      end
+    end
+
+    def initialize(executor, instance)
       @executor = executor
+      @instance = instance
     end
 
     %i[value value!].each do |method_name|
       define_method(method_name) do |timeout = nil, timeout_value = nil|
-        permit_concurrent_loads do
-          instance.public_send(method_name, timeout, timeout_value)
-        end
+        rails_wrapped { instance.public_send(method_name, timeout, timeout_value) }
       end
     end
 
     %i[then chain].each do |chainable|
       define_method(chainable) do |*args, &task|
-        method = "#{chainable}_on"
-        @instance = rails_wrapped do
-          instance.public_send(method, executor, *args, &task)
-        end
-
-        self
+        self.class.new(executor, instance.public_send(:"#{chainable}_on", executor, *args, &self.class.wrap_task(task)))
       end
     end
 
     def touch
-      @instance = rails_wrapped { instance.touch }
+      instance.touch
 
       self
     end
 
     def wait(timeout = nil)
-      result = permit_concurrent_loads { instance.__send__(:wait_until_resolved, timeout) }
+      result = rails_wrapped { instance.wait(timeout) }
 
       timeout ? result : self
     end
 
     %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
+        instance.public_send(:"#{method}_using", executor, *args, &self.class.wrap_task(callback_task))
 
         self
       end
 
       define_method(:"#{method}!") do |*args, &callback_task|
-        rails_wrapped do
-          @instance = instance.__send__(:add_callback, "callback_#{method}", args, callback_task)
-        end
+        instance.public_send(:"#{method}!", *args, &self.class.wrap_task(callback_task))
 
         self
       end
@@ -69,12 +93,6 @@ module ConcurrentRails
       Rails.application.executor.wrap(&)
     end
 
-    def permit_concurrent_loads(&block)
-      rails_wrapped do
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads(&block)
-      end
-    end
-
     attr_reader :instance
   end
 end

data/lib/concurrent_rails/testing.rb

@@ -2,20 +2,25 @@
 
 module ConcurrentRails
   class Testing
+    ISOLATION_KEY = :concurrent_rails_testing_mode
+
     class << self
-      attr_reader :execution_mode
+      def execution_mode
+        ActiveSupport::IsolatedExecutionState[ISOLATION_KEY] || @default_mode || "real" # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
 
       %w[immediate fake real].each do |test_mode|
         define_method(test_mode) do |&task|
-          @execution_mode = test_mode
-          result          = task.call
-          @execution_mode = :real
+          previous = ActiveSupport::IsolatedExecutionState[ISOLATION_KEY]
+          ActiveSupport::IsolatedExecutionState[ISOLATION_KEY] = test_mode
 
-          result
+          task.call
+        ensure
+          ActiveSupport::IsolatedExecutionState[ISOLATION_KEY] = previous
         end
 
         define_method(:"#{test_mode}!") do
-          @execution_mode = test_mode
+          @default_mode = test_mode
         end
 
         define_method(:"#{test_mode}?") do
@@ -25,17 +30,29 @@ module ConcurrentRails
     end
 
     module TestingFuture
-      def future(*args, &)
+      %i[future delay].each do |factory|
+        define_method(factory) do |*args, &task|
+          if ConcurrentRails::Testing.immediate?
+            public_send(:"#{factory}_on", :immediate, *args, &task)
+          elsif ConcurrentRails::Testing.fake?
+            task.call(*args)
+          else
+            super(*args, &task)
+          end
+        end
+      end
+
+      def schedule(delay, *args, &)
         if ConcurrentRails::Testing.immediate?
-          future_on(:immediate, *args, &)
+          schedule_on(:immediate, delay, *args, &)
         elsif ConcurrentRails::Testing.fake?
-          yield
+          yield(*args)
         else
           super
         end
       end
     end
 
-    ConcurrentRails::Promises.extend(TestingFuture)
+    ConcurrentRails::Promises.singleton_class.prepend(TestingFuture)
   end
 end

data/lib/concurrent_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConcurrentRails
-  VERSION = "0.7.1"
+  VERSION = "0.9.0"
 end

data/lib/concurrent_rails.rb

@@ -5,5 +5,4 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.setup
 
-module ConcurrentRails
-end
+module ConcurrentRails; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
@@ -9,6 +9,20 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -48,10 +62,7 @@ files:
 - README.md
 - Rakefile
 - lib/concurrent_rails.rb
-- lib/concurrent_rails/delay_adapter.rb
-- lib/concurrent_rails/future_adapter.rb
 - lib/concurrent_rails/promises.rb
-- lib/concurrent_rails/railtie.rb
 - lib/concurrent_rails/testing.rb
 - lib/concurrent_rails/version.rb
 homepage: https://github.com/luizkowalski/concurrent_rails
@@ -69,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Multithread is hard
 test_files: []

data/lib/concurrent_rails/delay_adapter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module ConcurrentRails
-  module DelayAdapter
-    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
-  end
-end

data/lib/concurrent_rails/future_adapter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module ConcurrentRails
-  module FutureAdapter
-    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/railtie.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module ConcurrentRails
-  class Railtie < ::Rails::Railtie
-  end
-end