concurrent_rails 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0352c1516c930c65708383fa734cd7444b02b0a213c0ef1f794e5e31f8e1fdf
-  data.tar.gz: 33ec089c95b33ff31a4652a073feac356e8b23a8d7e30bd214ea0a0dbc4aedcb
+  metadata.gz: fd75cf15aa7d7d0354bea478936bde3967d20a8e38daabff9e3fddf5c11bd5b6
+  data.tar.gz: 8c5faee065ed6de8bb7fedf2b29c3bc371792f579c7a00e6195d4b4e18ee0a29
 SHA512:
-  metadata.gz: a486a3ab777574962127795db050fd2615b69594d0bc88adb5114368c7d90492f2b51b237817f97118a31969396d53171bf66371240577051977a052d935148a
-  data.tar.gz: db095fe9e33e527a3ade62e8a40aec1866718bfce6b55ef519775cd1761d78b1eb1868d8c8b0ab799dcd05f78980ba16e31f5a7912b87ab3e2dd49d917dab004
+  metadata.gz: 649cf84ed43e2b6c7e70f89840a3091fefea3ade9df62af7d50ee7e7ef309af24729912bd9dbc5adc4112da953d3964e8b0ac4d41b36d3eb256edd73813c979f
+  data.tar.gz: 818ffd9287980e87473f9445b0424a5a006271b3ce4a070a4bd4b6fb08c4405576eff466e4def1c5ddce032614600f3d9a830951d20cfbb29823b7667545780a

data/README.md

@@ -174,12 +174,12 @@ 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:
+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:
+`immediate` strategy:
 ```ruby
-irb(main):001:1* result = ConcurrentRails::Testing.immediate! do
+irb(main):001:1* result = ConcurrentRails::Testing.immediate do
 irb(main):002:1*       ConcurrentRails::Promises.future { 42 }
 irb(main):003:0> end
 =>
@@ -191,10 +191,10 @@ irb(main):005:0> result.executor
 => :immediate # <-- default executor (:io) gets replaced
 ```
 
-`fake!` strategy:
+`fake` strategy:
 
 ```ruby
-irb(main):001:1* result = ConcurrentRails::Testing.fake! do
+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
@@ -202,6 +202,8 @@ irb(main):004:0> result.class
 => Integer
 ```
 
+You can also set the stragegy globally using `ConcurrentRails::Testing.fake!` or `ConcurrentRails::Testing.immediate!`
+
 ## Further reading
 
 For more information on how Futures work and how Rails handle multithread check these links:

data/lib/concurrent_rails/delay_adapter.rb

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

data/lib/concurrent_rails/future.rb

@@ -1,49 +1,47 @@
 # 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
+class ConcurrentRails::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
+  def execute
+    future.execute
 
-      self
-    end
+    self
+  end
 
-    %i[value value!].each do |method_name|
-      define_method method_name do
-        permit_concurrent_loads do
-          future.__send__(method_name)
-        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
+  delegate :state, :reason, :rejected?, :complete?, :add_observer, to: :future
 
-    private
+  private
 
-    def run_on_rails(block)
-      @future = rails_wrapped do
-        Concurrent::Future.new(executor: executor) do
-          rails_wrapped(&block)
-        end
+  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 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
+  def permit_concurrent_loads(&block)
+    rails_wrapped do
+      ActiveSupport::Dependencies.interlock.permit_concurrent_loads(&block)
     end
-
-    attr_reader :executor, :future
   end
+
+  attr_reader :executor, :future
 end

data/lib/concurrent_rails/future_adapter.rb

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

data/lib/concurrent_rails/multi.rb

@@ -1,51 +1,49 @@
 # 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)
+class ConcurrentRails::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
+    new(actions, executor).enqueue
+  end
 
-    def enqueue
-      @futures = actions.map do |action|
-        f = ConcurrentRails::Future.new(executor: executor, &action)
-        f.add_observer(self)
-        f.execute
-      end
+  def initialize(actions, executor)
+    @actions    = actions
+    @executor   = executor
+    @exceptions = Concurrent::Array.new
+  end
 
-      self
+  def enqueue
+    @futures = actions.map do |action|
+      f = ConcurrentRails::Future.new(executor: executor, &action)
+      f.add_observer(self)
+      f.execute
     end
 
-    def compute
-      futures.map(&:value)
-    end
+    self
+  end
 
-    def compute!
-      futures.map(&:value!)
-    end
+  def compute
+    futures.map(&:value)
+  end
 
-    def complete?
-      futures.all?(&:complete?)
-    end
+  def compute!
+    futures.map(&:value!)
+  end
 
-    def errors
-      @exceptions
-    end
+  def complete?
+    futures.all?(&:complete?)
+  end
 
-    private
+  def errors
+    @exceptions
+  end
 
-    def update(_time, _value, reason)
-      @exceptions << reason if reason
-    end
+  private
 
-    attr_reader :actions, :futures, :exceptions, :executor
+  def update(_time, _value, reason)
+    @exceptions << reason if reason
   end
+
+  attr_reader :actions, :futures, :exceptions, :executor
 end

data/lib/concurrent_rails/promises.rb

@@ -1,83 +1,81 @@
 # frozen_string_literal: true
 
-require 'concurrent_rails/adapters/future'
-require 'concurrent_rails/adapters/delay'
+require 'concurrent_rails/future_adapter'
+require 'concurrent_rails/delay_adapter'
 
-module ConcurrentRails
-  class Promises
-    include Concurrent::Promises::FactoryMethods
-    include ConcurrentRails::Adapters::Delay
-    include ConcurrentRails::Adapters::Future
+class ConcurrentRails::Promises
+  include Concurrent::Promises::FactoryMethods
+  include ConcurrentRails::DelayAdapter
+  include ConcurrentRails::FutureAdapter
 
-    def initialize(executor)
-      @executor = executor
-    end
+  def initialize(executor)
+    @executor = executor
+  end
 
-    %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
+  %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
     end
+  end
 
-    %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
+  %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
-    end
-
-    def touch
-      @instance = rails_wrapped { instance.touch }
 
       self
     end
+  end
 
-    def wait(timeout = nil)
-      result = permit_concurrent_loads { instance.__send__(:wait_until_resolved, timeout) }
+  def touch
+    @instance = rails_wrapped { instance.touch }
 
-      timeout ? result : self
-    end
+    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
+  def wait(timeout = nil)
+    result = permit_concurrent_loads { instance.__send__(:wait_until_resolved, timeout) }
 
-        self
+    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
 
-      define_method("#{method}!") do |*args, &callback_task|
-        rails_wrapped do
-          @instance = instance.__send__(:add_callback, "callback_#{method}", 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
 
-    delegate :state, :reason, :rejected?, :resolved?, :fulfilled?, to: :instance
+  delegate :state, :reason, :rejected?, :resolved?, :fulfilled?, to: :instance
 
-    attr_reader :executor
+  attr_reader :executor
 
-    private
+  private
 
-    def rails_wrapped(&block)
-      Rails.application.executor.wrap(&block)
-    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
+  def permit_concurrent_loads(&block)
+    rails_wrapped do
+      ActiveSupport::Dependencies.interlock.permit_concurrent_loads(&block)
     end
-
-    attr_reader :instance
   end
+
+  attr_reader :instance
 end

data/lib/concurrent_rails/railtie.rb

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

data/lib/concurrent_rails/testing.rb

@@ -1,37 +1,39 @@
 # frozen_string_literal: true
 
-module ConcurrentRails
-  class Testing
-    class << self
-      attr_reader :execution_mode
+class ConcurrentRails::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
+    %w[immediate fake real].each do |test_mode|
+      define_method(test_mode) do |&task|
+        @execution_mode = test_mode
+        result          = task.call
+        @execution_mode = :real
 
-          result
-        end
+        result
+      end
 
-        define_method("#{exec_method}?") do
-          execution_mode == exec_method
-        end
+      define_method("#{test_mode}!") do
+        @execution_mode = test_mode
       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
+      define_method("#{test_mode}?") do
+        execution_mode == test_mode
       end
+    end
+  end
 
-      ConcurrentRails::Promises.extend(TestingFuture)
+  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

data/lib/concurrent_rails/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-15 00:00:00.000000000 Z
+date: 2021-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  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'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +80,6 @@ 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
@@ -91,9 +91,9 @@ files:
 - README.md
 - Rakefile
 - lib/concurrent_rails.rb
-- lib/concurrent_rails/adapters/delay.rb
-- lib/concurrent_rails/adapters/future.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
@@ -121,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.20
+rubygems_version: 3.2.31
 signing_key:
 specification_version: 4
 summary: Multithread is hard

data/lib/concurrent_rails/adapters/delay.rb

@@ -1,23 +0,0 @@
-# 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
-  end
-end

data/lib/concurrent_rails/adapters/future.rb

@@ -1,23 +0,0 @@
-# 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