concurrent_rails 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd75cf15aa7d7d0354bea478936bde3967d20a8e38daabff9e3fddf5c11bd5b6
-  data.tar.gz: 8c5faee065ed6de8bb7fedf2b29c3bc371792f579c7a00e6195d4b4e18ee0a29
+  metadata.gz: 9d92e4343775ab47bf053ce94e272124a6b703e4bfb087483c0ff6aa45257744
+  data.tar.gz: 43c84651bafee307b178694a5a3113d9e21d1a8c6995daccc8ffee5963e62170
 SHA512:
-  metadata.gz: 649cf84ed43e2b6c7e70f89840a3091fefea3ade9df62af7d50ee7e7ef309af24729912bd9dbc5adc4112da953d3964e8b0ac4d41b36d3eb256edd73813c979f
-  data.tar.gz: 818ffd9287980e87473f9445b0424a5a006271b3ce4a070a4bd4b6fb08c4405576eff466e4def1c5ddce032614600f3d9a830951d20cfbb29823b7667545780a
+  metadata.gz: 23726c05ee5c47a4cdfa911ae6ff537b87bb72c70cf71cb0ede046682951405c14a0d960dccd4dae0d79921fad335013f0a2afd5ca12b1f949030bdfa1cf983f
+  data.tar.gz: 7b40732c370731530f7295d4f9cb4f40ef7f50c07d9ff3a11e17e9101d78622c5005750d1894b78244536c34fcc87266ab81c31283230ef670948d1ca09b7d3e

data/lib/concurrent_rails/delay_adapter.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
-module ConcurrentRails::DelayAdapter
-  extend ActiveSupport::Concern
+module ConcurrentRails
+  module DelayAdapter
+    extend ActiveSupport::Concern
 
-  class_methods do
-    def delay(*args, &task)
-      delay_on(:io, *args, &task)
-    end
+    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)
+      def delay_on(executor, *args, &task)
+        new(executor).delay_on_rails(*args, &task)
+      end
     end
-  end
 
-  def delay_on_rails(*args, &task)
-    @instance = rails_wrapped { delay_on(executor, *args, &task) }
+    def delay_on_rails(*args, &task)
+      @instance = rails_wrapped { delay_on(executor, *args, &task) }
 
-    self
+      self
+    end
   end
 end

data/lib/concurrent_rails/future.rb

@@ -1,47 +1,49 @@
 # frozen_string_literal: true
 
-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
+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
+    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)
+    %i[value value!].each do |method_name|
+      define_method method_name do
+        permit_concurrent_loads do
+          future.__send__(method_name)
+        end
       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)
+    def run_on_rails(block)
+      @future = rails_wrapped do
+        Concurrent::Future.new(executor: executor) do
+          rails_wrapped(&block)
+        end
       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)
+    def permit_concurrent_loads(&block)
+      rails_wrapped do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads(&block)
+      end
     end
-  end
 
-  attr_reader :executor, :future
+    attr_reader :executor, :future
+  end
 end

data/lib/concurrent_rails/future_adapter.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
-module ConcurrentRails::FutureAdapter
-  extend ActiveSupport::Concern
+module ConcurrentRails
+  module FutureAdapter
+    extend ActiveSupport::Concern
 
-  class_methods do
-    def future(*args, &task)
-      future_on(:io, *args, &task)
-    end
+    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)
+      def future_on(executor, *args, &task)
+        new(executor).future_on_rails(*args, &task)
+      end
     end
-  end
 
-  def future_on_rails(*args, &task)
-    @instance = rails_wrapped { future_on(executor, *args, &task) }
+    def future_on_rails(*args, &task)
+      @instance = rails_wrapped { future_on(executor, *args, &task) }
 
-    self
+      self
+    end
   end
 end

data/lib/concurrent_rails/multi.rb

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

data/lib/concurrent_rails/promises.rb

@@ -3,79 +3,81 @@
 require 'concurrent_rails/future_adapter'
 require 'concurrent_rails/delay_adapter'
 
-class ConcurrentRails::Promises
-  include Concurrent::Promises::FactoryMethods
-  include ConcurrentRails::DelayAdapter
-  include ConcurrentRails::FutureAdapter
-
-  def initialize(executor)
-    @executor = executor
-  end
+module ConcurrentRails
+  class Promises
+    include Concurrent::Promises::FactoryMethods
+    include ConcurrentRails::DelayAdapter
+    include ConcurrentRails::FutureAdapter
+
+    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.public_send(method_name, timeout, timeout_value)
+    %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
-  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)
+    %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
       end
+    end
+
+    def touch
+      @instance = rails_wrapped { instance.touch }
 
       self
     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) }
 
-  def wait(timeout = nil)
-    result = permit_concurrent_loads { instance.__send__(:wait_until_resolved, timeout) }
+      timeout ? result : self
+    end
 
-    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
 
-  %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)
+        self
       end
 
-      self
-    end
+      define_method("#{method}!") do |*args, &callback_task|
+        rails_wrapped do
+          @instance = instance.__send__(:add_callback, "callback_#{method}", args, callback_task)
+        end
 
-    define_method("#{method}!") do |*args, &callback_task|
-      rails_wrapped do
-        @instance = instance.__send__(:add_callback, "callback_#{method}", args, callback_task)
+        self
       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)
+    def permit_concurrent_loads(&block)
+      rails_wrapped do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads(&block)
+      end
     end
-  end
 
-  attr_reader :instance
+    attr_reader :instance
+  end
 end

data/lib/concurrent_rails/railtie.rb

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

data/lib/concurrent_rails/testing.rb

@@ -1,39 +1,41 @@
 # frozen_string_literal: true
 
-class ConcurrentRails::Testing
-  class << self
-    attr_reader :execution_mode
+module ConcurrentRails
+  class Testing
+    class << self
+      attr_reader :execution_mode
 
-    %w[immediate fake real].each do |test_mode|
-      define_method(test_mode) do |&task|
-        @execution_mode = test_mode
-        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("#{test_mode}!") do
-        @execution_mode = test_mode
-      end
+        define_method("#{test_mode}!") do
+          @execution_mode = test_mode
+        end
 
-      define_method("#{test_mode}?") do
-        execution_mode == test_mode
+        define_method("#{test_mode}?") do
+          execution_mode == test_mode
+        end
       end
     end
-  end
 
-  module TestingFuture
-    def future(*args, &task)
-      if ConcurrentRails::Testing.immediate?
-        future_on(:immediate, *args, &task)
-      elsif ConcurrentRails::Testing.fake?
-        yield
-      else
-        super
+    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
-  end
 
-  ConcurrentRails::Promises.extend(TestingFuture)
+    ConcurrentRails::Promises.extend(TestingFuture)
+  end
 end

data/lib/concurrent_rails/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent_rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski