concurrent_rails 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc63638fb76dc139c10b9ed53d61e020f7288bbd13f3bed9c4e5129b93c016c9
-  data.tar.gz: e61aae19d4fd6f1023be007ed77a2edf333a922fe0ab522ea533175e975ce941
+  metadata.gz: cb04be405f37c5acf9a5fa5ed21ba327bb92168cc6f830dc52314356ccbfd4dd
+  data.tar.gz: cabf17aba3c7c80939b95d5af80e48cb6fcc8c4260f2278386e3952b2128a59f
 SHA512:
-  metadata.gz: f236962918393d4f1a8c81edec667564fc862825940a0ef30e33053d1d1061017172b14cb407eb87177ea1db41471de9c7abafb0648ebd63183b107df1ad3604
-  data.tar.gz: e453ea4cdcd0161d0159dfeaec1931e43dbd992120ecb57953935517d28072a79338a731feb1be660108dd24f3bb376f66f013de3c1653d08a5e4f756ecc0b7e
+  metadata.gz: 971b987e34b8eb5142d05f774368cec64e363c4c7ecd23555dcd594b8631d4237c85ab969a5392c184ed7a727c78c13586876e1ce6b629ae86bf865ac1ccec1d
+  data.tar.gz: 575157aae6f247f68672327689b7396804d63e1b78162f68a73be51ac56a818039bb40c8af765c5481dbf2b557fb4cee884d93aaf5949ea744ba9599aeb99479

data/README.md

@@ -127,7 +127,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.7'
 ```
 
 And then execute:

data/lib/concurrent_rails/combinator_adapter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  module CombinatorAdapter
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def zip(*promises)
+        new(:io).tap { |p| p.instance_variable_set(:@instance, Concurrent::Promises.zip(*unwrap(promises))) }
+      end
+
+      def any_resolved_future(*promises)
+        new(:io).tap { |p| p.instance_variable_set(:@instance, Concurrent::Promises.any_resolved_future(*unwrap(promises))) }
+      end
+
+      def fulfilled_future(value, executor = :io)
+        new(executor).tap { |p| p.instance_variable_set(:@instance, Concurrent::Promises.fulfilled_future(value)) }
+      end
+
+      def rejected_future(reason, executor = :io)
+        new(executor).tap { |p| p.instance_variable_set(:@instance, Concurrent::Promises.rejected_future(reason)) }
+      end
+
+      private
+
+      def unwrap(promises)
+        promises.map { |p| p.is_a?(ConcurrentRails::Promises) ? p.__send__(:instance) : p }
+      end
+    end
+  end
+end

data/lib/concurrent_rails/delay_adapter.rb

@@ -14,8 +14,9 @@ module ConcurrentRails
       end
     end
 
-    def delay_on_rails(*args, &task)
-      @instance = rails_wrapped { delay_on(executor, *args, &task) }
+    def delay_on_rails(*args)
+      wrapped_task = proc { |*a| rails_wrapped { yield(*a) } }
+      @instance = delay_on(executor, *args, &wrapped_task)
 
       self
     end

data/lib/concurrent_rails/future_adapter.rb

@@ -14,8 +14,9 @@ module ConcurrentRails
       end
     end
 
-    def future_on_rails(*args, &task)
-      @instance = rails_wrapped { future_on(executor, *args, &task) }
+    def future_on_rails(*args)
+      wrapped_task = proc { |*a| rails_wrapped { yield(*a) } }
+      @instance = future_on(executor, *args, &wrapped_task)
 
       self
     end

data/lib/concurrent_rails/promises.rb

@@ -3,8 +3,10 @@
 module ConcurrentRails
   class Promises
     include Concurrent::Promises::FactoryMethods
+    include ConcurrentRails::CombinatorAdapter
     include ConcurrentRails::DelayAdapter
     include ConcurrentRails::FutureAdapter
+    include ConcurrentRails::ScheduleAdapter
 
     def initialize(executor)
       @executor = executor
@@ -12,18 +14,15 @@ module ConcurrentRails
 
     %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
+        wrapped_task = proc { |*a| rails_wrapped { task.call(*a) } }
+        @instance = instance.public_send(method, executor, *args, &wrapped_task)
 
         self
       end
@@ -36,24 +35,22 @@ module ConcurrentRails
     end
 
     def wait(timeout = nil)
-      result = permit_concurrent_loads { instance.__send__(:wait_until_resolved, timeout) }
+      result = rails_wrapped { 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
-          @instance = instance.__send__(:"#{method}_using", executor, *args, &callback_task)
-        end
+        wrapped_callback = proc { |*a| rails_wrapped { callback_task.call(*a) } }
+        @instance = instance.__send__(:"#{method}_using", executor, *args, &wrapped_callback)
 
         self
       end
 
       define_method(:"#{method}!") do |*args, &callback_task|
-        rails_wrapped do
-          @instance = instance.__send__(:add_callback, "callback_#{method}", args, callback_task)
-        end
+        wrapped_callback = proc { |*a| rails_wrapped { callback_task.call(*a) } }
+        @instance = instance.__send__(:add_callback, "callback_#{method}", args, wrapped_callback)
 
         self
       end
@@ -69,12 +66,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/railtie.rb

@@ -2,5 +2,8 @@
 
 module ConcurrentRails
   class Railtie < ::Rails::Railtie
+    initializer "concurrent_rails.executor_hooks" do |app|
+      # TODO: Add something here at some point
+    end
   end
 end

data/lib/concurrent_rails/schedule_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  module ScheduleAdapter
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def schedule(delay, *args, &task)
+        schedule_on(:io, delay, *args, &task)
+      end
+
+      def schedule_on(executor, delay, *args, &task)
+        new(executor).schedule_on_rails(delay, *args, &task)
+      end
+    end
+
+    def schedule_on_rails(delay, *args)
+      wrapped_task = proc { |*a| rails_wrapped { yield(*a) } }
+      @instance = schedule_on(executor, delay, *args, &wrapped_task)
+
+      self
+    end
+  end
+end

data/lib/concurrent_rails/testing.rb

@@ -9,7 +9,7 @@ module ConcurrentRails
         define_method(test_mode) do |&task|
           @execution_mode = test_mode
           result          = task.call
-          @execution_mode = :real
+          @execution_mode = "real"
 
           result
         end

data/lib/concurrent_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConcurrentRails
-  VERSION = "0.7.1"
+  VERSION = "0.8.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.8.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski
@@ -48,10 +48,12 @@ files:
 - README.md
 - Rakefile
 - lib/concurrent_rails.rb
+- lib/concurrent_rails/combinator_adapter.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/schedule_adapter.rb
 - lib/concurrent_rails/testing.rb
 - lib/concurrent_rails/version.rb
 homepage: https://github.com/luizkowalski/concurrent_rails
@@ -76,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.8
 specification_version: 4
 summary: Multithread is hard
 test_files: []