concurrent_rails 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14fd5aa53c8cb75c74999acd7e1c43410a9564ba4122d83142f0e3ed8565d429
-  data.tar.gz: 71e60b4e355052fcc328ada6b881b9e41330360aaaa582eff9afb90cab19866f
+  metadata.gz: a0352c1516c930c65708383fa734cd7444b02b0a213c0ef1f794e5e31f8e1fdf
+  data.tar.gz: 33ec089c95b33ff31a4652a073feac356e8b23a8d7e30bd214ea0a0dbc4aedcb
 SHA512:
-  metadata.gz: 020b3dee7781090195212145f6faf7f19c311cdee6b619e0601dde476fd3dd2dbe811269da5362794d5903f56ca95eaf56e615dcadb55db454d2a705b6599837
-  data.tar.gz: 9abb0931cb4283b4c9947d7498784c3d0ca0c32e70fb0fbaff9aa29ad28cde0c97ba48bde5f2d07837902cfcb912f987f449b9825658f47f93a7ef1f48bacf32
+  metadata.gz: a486a3ab777574962127795db050fd2615b69594d0bc88adb5114368c7d90492f2b51b237817f97118a31969396d53171bf66371240577051977a052d935148a
+  data.tar.gz: db095fe9e33e527a3ade62e8a40aec1866718bfce6b55ef519775cd1761d78b1eb1868d8c8b0ab799dcd05f78980ba16e31f5a7912b87ab3e2dd49d917dab004

data/README.md

@@ -2,8 +2,7 @@
 
 ![status](https://github.com/luizkowalski/concurrent_rails/actions/workflows/ruby.yml/badge.svg?branch=master)
 
-Multithread is hard. [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) did an amazing job
-implementing the concepts of multithread in the Ruby world. The problem is that Rails doesn't play nice with it. Rails have a complex way of managing threads called Executor and concurrent-ruby (most specifically, [Future](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)) does not work seamlessly with it.
+Multithread is hard. [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby) did an amazing job implementing the concepts of multithread in the Ruby world. The problem is that Rails doesn't play nice with it. Rails have a complex way of managing threads called Executor and concurrent-ruby (most specifically, [Future](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)) does not work seamlessly with it.
 
 The goal of this gem is to provide a simple library that allows the developer to work with Futures without having to care about Rails's Executor and the whole pack of problems that come with it: autoload, thread pools, active record connections, etc.
 
@@ -84,7 +83,7 @@ All of these callbacks have a bang version (e.g. `on_fulfillment!`). The bang ve
 
 ### (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:
+`ConcurrentRails::Future` will execute your code in a separate 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:
 
 ```ruby
 irb(main):001:0> future = ConcurrentRails::Future.new do
@@ -174,6 +173,37 @@ irb(main):007:0> multi.errors
 
 It is worth mention that a failed proc will return `nil`.
 
+## Testing
+If you are using RSpec, you will notice that it might not play well with threads. ActiveRecord opens a database connection for every thread and since RSpec tests are wrapped in a transaction, by the time you promise tries to access something on the database, for example, a user, gems like Database Cleaner probably already triggered and deleted the user, resulting in `ActiveRecord::RecordNotFound` errors. You have a couple of solutions like disable transactional fixtures if you are using it or update the Database Cleaner strategy (that will result in much slower tests).
+Since none of these solutions were satisfactory to me, I created `ConcurrentRails::Testing` with two strategies: `immediate!` and `fake!`. When you wrap a Promise's `future` with `immediate!`, the executor gets replaced from `:io` to `:immediate`. It still returns a promise anyway. This is not the case with `fake!` strategy: it executes the task outside the `ConcurrentRails` engine and returns whatever `.value` would return:
+
+`immediate!` strategy:
+```ruby
+irb(main):001:1* result = ConcurrentRails::Testing.immediate! do
+irb(main):002:1*       ConcurrentRails::Promises.future { 42 }
+irb(main):003:0> end
+=>
+#<ConcurrentRails::Promises:0x000000013e5fc870 
+...
+irb(main):004:0> result.class
+=> ConcurrentRails::Promises # <-- Still a `ConcurrentRails::Promises` class
+irb(main):005:0> result.executor
+=> :immediate # <-- default executor (:io) gets replaced
+```
+
+`fake!` strategy:
+
+```ruby
+irb(main):001:1* result = ConcurrentRails::Testing.fake! do
+irb(main):002:1*       ConcurrentRails::Promises.future { 42 }
+irb(main):003:0> end
+=> 42 # <-- yields the task but does not return a Promise
+irb(main):004:0> result.class
+=> Integer
+```
+
+## Further reading
+
 For more information on how Futures work and how Rails handle multithread check these links:
 
 [Future documentation](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)
@@ -185,19 +215,19 @@ 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.2.0'
+gem 'concurrent_rails', '~> 0.2.1'
 ```
 
 And then execute:
 
 ```bash
-$ bundle
+bundle
 ```
 
 Or install it yourself as:
 
 ```bash
-$ gem install concurrent_rails
+gem install concurrent_rails
 ```
 
 ## Contributing

data/lib/concurrent_rails.rb

@@ -4,4 +4,5 @@ require 'concurrent_rails/future'
 require 'concurrent_rails/multi'
 require 'concurrent_rails/promises'
 require 'concurrent_rails/railtie'
+require 'concurrent_rails/testing'
 require 'concurrent_rails/version'

data/lib/concurrent_rails/adapters/delay.rb

@@ -19,7 +19,5 @@ module ConcurrentRails::Adapters
 
       self
     end
-
-    delegate :touch, to: :instance
   end
 end

data/lib/concurrent_rails/future.rb

@@ -5,7 +5,7 @@ module ConcurrentRails
     def initialize(executor: :io, &block)
       @executor = executor
       @future   = run_on_rails(block)
-      # ActiveSupport::Deprecation.warn('Concurrent::Future is deprecated')
+      ActiveSupport::Deprecation.warn('ConcurrentRails::Future is deprecated. See README for details')
     end
 
     def execute
@@ -16,10 +16,8 @@ module ConcurrentRails
 
     %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
+        permit_concurrent_loads do
+          future.__send__(method_name)
         end
       end
     end
@@ -40,6 +38,12 @@ module ConcurrentRails
       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, :future
   end
 end

data/lib/concurrent_rails/multi.rb

@@ -3,9 +3,7 @@
 module ConcurrentRails
   class Multi
     def self.enqueue(*actions, executor: :io)
-      unless actions.all? { |action| action.is_a?(Proc) }
-        raise ArgumentError, '#enqueue accepts `Proc`s only'
-      end
+      raise ArgumentError, '#enqueue accepts `Proc`s only' unless actions.all?(Proc)
 
       new(actions, executor).enqueue
     end

data/lib/concurrent_rails/promises.rb

@@ -32,6 +32,18 @@ module ConcurrentRails
       end
     end
 
+    def touch
+      @instance = rails_wrapped { instance.touch }
+
+      self
+    end
+
+    def wait(timeout = nil)
+      result = permit_concurrent_loads { instance.__send__(:wait_until_resolved, 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
@@ -50,8 +62,9 @@ module ConcurrentRails
       end
     end
 
-    delegate :state, :reason, :rejected?, :resolved?, :fulfilled?, :wait,
-             to: :instance
+    delegate :state, :reason, :rejected?, :resolved?, :fulfilled?, to: :instance
+
+    attr_reader :executor
 
     private
 
@@ -65,6 +78,6 @@ module ConcurrentRails
       end
     end
 
-    attr_reader :executor, :instance
+    attr_reader :instance
   end
 end

data/lib/concurrent_rails/testing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  class Testing
+    class << self
+      attr_reader :execution_mode
+
+      %i[immediate fake].each do |exec_method|
+        define_method("#{exec_method}!") do |&task|
+          @execution_mode = exec_method
+          result = task.call
+          @execution_mode = :real
+
+          result
+        end
+
+        define_method("#{exec_method}?") do
+          execution_mode == exec_method
+        end
+      end
+
+      module TestingFuture
+        def future(*args, &task)
+          if ConcurrentRails::Testing.immediate?
+            future_on(:immediate, *args, &task)
+          elsif ConcurrentRails::Testing.fake?
+            yield
+          else
+            super
+          end
+        end
+      end
+
+      ConcurrentRails::Promises.extend(TestingFuture)
+    end
+  end
+end

data/lib/concurrent_rails/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-13 00:00:00.000000000 Z
+date: 2021-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -97,6 +97,7 @@ files:
 - lib/concurrent_rails/multi.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
 licenses:
@@ -120,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.17
+rubygems_version: 3.2.20
 signing_key:
 specification_version: 4
 summary: Multithread is hard