concurrent_rails 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff1bb57ccfc21ffd6e539661e4f939497bdd46329bb77cbe580a9ec0d6374267
-  data.tar.gz: b1c66b86282b56e676d751d846584fbf3047c9532c4380fb2b19b69f8f3cb009
+  metadata.gz: 5667dde5992af86d3d798a7a2f87b9ec6f84ebaa3eedcd4f37fa76ba5caa460e
+  data.tar.gz: 2f8d9f11f5fb55acbb4f9a6277312f754cc9798d3cb3c48c52873d15d6c21416
 SHA512:
-  metadata.gz: da0805e477d67b12438149cc97a331ea3c770198a22529cb7d7d298216e1cb7a216f328b49405bf646c7326a76b29beb722edf088ed0a62fad1a7b3d3f8ca791
-  data.tar.gz: 7c99edc66b92b084375b4b2be896a4a19c6b7e7d04b1a501f92ce7839a8234a08c9822166e5355be3a6d758eee1ffb0c147cd54d511bb337810773cf10b89ea5
+  metadata.gz: efe856cba6102e157f0286451ddfa618e9a56195456f16d4dc090a16aefb0846a5c227793fdc92686021b243a2603ccbb27833edbeb15d94ea974cbcf54ac37e
+  data.tar.gz: 595c6b3011bd8094407efcc1746d8f0c949a2fb4b37d4678923a84b8ef7d0a2f1ca1eb7a4bc61165cbdd7f9256802932a4711635552cfd60978a353b80fa8cfd

data/README.md

@@ -1,6 +1,6 @@
 # ConcurrentRails
 
-![status](https://github.com/luizkowalski/concurrent_rails/actions/workflows/ruby.yml/badge.svg?branch=master)
+![status](https://github.com/luizkowalski/concurrent_rails/actions/workflows/ruby.yml/badge.svg?branch=main)
 
 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 has 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.
 
@@ -8,7 +8,7 @@ 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 process of being deprecated by concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby#deprecated)) and `ConcurrentRails::Multi`
+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`
 
 ### Promises
 
@@ -174,16 +174,18 @@ 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 your 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 
+#<ConcurrentRails::Promises:0x000000013e5fc870
 ...
 irb(main):004:0> result.class
 => ConcurrentRails::Promises # <-- Still a `ConcurrentRails::Promises` class
@@ -217,7 +219,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.2.1'
+gem 'concurrent_rails', '~> 0.5.1'
 ```
 
 And then execute:

data/lib/concurrent_rails/promises.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "concurrent_rails/future_adapter"
-require "concurrent_rails/delay_adapter"
-
 module ConcurrentRails
   class Promises
     include Concurrent::Promises::FactoryMethods
@@ -47,13 +44,13 @@ module ConcurrentRails
     %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)
+          @instance = instance.__send__(:"#{method}_using", executor, *args, &callback_task)
         end
 
         self
       end
 
-      define_method("#{method}!") do |*args, &callback_task|
+      define_method(:"#{method}!") do |*args, &callback_task|
         rails_wrapped do
           @instance = instance.__send__(:add_callback, "callback_#{method}", args, callback_task)
         end
@@ -68,8 +65,8 @@ module ConcurrentRails
 
     private
 
-    def rails_wrapped(&block)
-      Rails.application.executor.wrap(&block)
+    def rails_wrapped(&)
+      Rails.application.executor.wrap(&)
     end
 
     def permit_concurrent_loads(&block)

data/lib/concurrent_rails/testing.rb

@@ -14,20 +14,20 @@ module ConcurrentRails
           result
         end
 
-        define_method("#{test_mode}!") do
+        define_method(:"#{test_mode}!") do
           @execution_mode = test_mode
         end
 
-        define_method("#{test_mode}?") do
+        define_method(:"#{test_mode}?") do
           execution_mode == test_mode
         end
       end
     end
 
     module TestingFuture
-      def future(*args, &task)
+      def future(*args, &)
         if ConcurrentRails::Testing.immediate?
-          future_on(:immediate, *args, &task)
+          future_on(:immediate, *args, &)
         elsif ConcurrentRails::Testing.fake?
           yield
         else

data/lib/concurrent_rails/version.rb

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

data/lib/concurrent_rails.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "concurrent_rails/future"
-require "concurrent_rails/multi"
-require "concurrent_rails/promises"
-require "concurrent_rails/railtie"
-require "concurrent_rails/testing"
-require "concurrent_rails/version"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-05 00:00:00.000000000 Z
+date: 2024-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Small library to make concurrent-ruby and Rails play nice together
 email:
 - luizeduardokowalski@gmail.com
@@ -36,9 +50,7 @@ files:
 - Rakefile
 - lib/concurrent_rails.rb
 - lib/concurrent_rails/delay_adapter.rb
-- lib/concurrent_rails/future.rb
 - lib/concurrent_rails/future_adapter.rb
-- lib/concurrent_rails/multi.rb
 - lib/concurrent_rails/promises.rb
 - lib/concurrent_rails/railtie.rb
 - lib/concurrent_rails/testing.rb
@@ -56,14 +68,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: Multithread is hard

data/lib/concurrent_rails/future.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module ConcurrentRails
-  class Future
-    def initialize(executor: :io, &block)
-      @executor = executor
-      @future   = run_on_rails(block)
-      ActiveSupport::Deprecation.warn("ConcurrentRails::Future is deprecated. See README for details")
-    end
-
-    def execute
-      future.execute
-
-      self
-    end
-
-    %i[value value!].each do |method_name|
-      define_method method_name do
-        permit_concurrent_loads do
-          future.__send__(method_name)
-        end
-      end
-    end
-
-    delegate :state, :reason, :rejected?, :complete?, :add_observer, to: :future
-
-    private
-
-    def run_on_rails(block)
-      @future = rails_wrapped do
-        Concurrent::Future.new(executor: executor) do
-          rails_wrapped(&block)
-        end
-      end
-    end
-
-    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, :future
-  end
-end

data/lib/concurrent_rails/multi.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module ConcurrentRails
-  class Multi
-    def self.enqueue(*actions, executor: :io)
-      raise ArgumentError, "#enqueue accepts `Proc`s only" unless actions.all?(Proc)
-
-      new(actions, executor).enqueue
-    end
-
-    def initialize(actions, executor)
-      @actions    = actions
-      @executor   = executor
-      @exceptions = Concurrent::Array.new
-    end
-
-    def enqueue
-      @futures = actions.map do |action|
-        f = ConcurrentRails::Future.new(executor: executor, &action)
-        f.add_observer(self)
-        f.execute
-      end
-
-      self
-    end
-
-    def compute
-      futures.map(&:value)
-    end
-
-    def compute!
-      futures.map(&:value!)
-    end
-
-    def complete?
-      futures.all?(&:complete?)
-    end
-
-    def errors
-      @exceptions
-    end
-
-    private
-
-    def update(_time, _value, reason)
-      @exceptions << reason if reason
-    end
-
-    attr_reader :actions, :futures, :exceptions, :executor
-  end
-end