Rename new promises states

pending > pending
completed > resolved
success > fulfilled
failed > rejected

Author: pitr-ch

lib/concurrent/actor.rb

@@ -35,7 +35,7 @@ def self.current
     end
 
     @root = Concurrent::Promises.delay do
-      Core.new(parent: nil, name: '/', class: Root, initialized: future = Concurrent::Promises.completable_future).reference.tap do
+      Core.new(parent: nil, name: '/', class: Root, initialized: future = Concurrent::Promises.resolvable_future).reference.tap do
         future.wait!
       end
     end
@@ -74,7 +74,7 @@ def self.spawn(*args, &block)
 
     # as {.spawn} but it'll block until actor is initialized or it'll raise exception on error
     def self.spawn!(*args, &block)
-      spawn(to_spawn_options(*args).merge(initialized: future = Concurrent::Promises.completable_future), &block).tap { future.wait! }
+      spawn(to_spawn_options(*args).merge(initialized: future = Concurrent::Promises.resolvable_future), &block).tap { future.wait! }
     end
 
     # @overload to_spawn_options(context_class, name, *args)

lib/concurrent/actor/behaviour/sets_results.rb

@@ -1,7 +1,7 @@
 module Concurrent
   module Actor
     module Behaviour
-      # Collects returning value and sets the CompletableFuture in the {Envelope} or error on failure.
+      # Collects returning value and sets the ResolvableFuture in the {Envelope} or error on failure.
       class SetResults < Abstract
         attr_reader :error_strategy
 
@@ -13,7 +13,7 @@ def initialize(core, subsequent, core_options, error_strategy)
         def on_envelope(envelope)
           result = pass envelope
           if result != MESSAGE_PROCESSED && !envelope.future.nil?
-            envelope.future.succeed result
+            envelope.future.fulfill result
             log(DEBUG) { "finished processing of #{envelope.message.inspect}"}
           end
           nil
@@ -29,7 +29,7 @@ def on_envelope(envelope)
           else
             raise
           end
-          envelope.future.fail error unless envelope.future.nil?
+          envelope.future.reject error unless envelope.future.nil?
         end
       end
     end

lib/concurrent/actor/behaviour/termination.rb

@@ -14,16 +14,16 @@ class Termination < Abstract
 
         def initialize(core, subsequent, core_options, trapping = false, terminate_children = true)
           super core, subsequent, core_options
-          @terminated         = Concurrent::Promises.completable_future
-          @public_terminated  = @terminated.with_hidden_completable
+          @terminated         = Concurrent::Promises.resolvable_future
+          @public_terminated  = @terminated.with_hidden_resolvable
           @trapping           = trapping
           @terminate_children = terminate_children
         end
 
         # @note Actor rejects envelopes when terminated.
         # @return [true, false] if actor is terminated
         def terminated?
-          @terminated.completed?
+          @terminated.resolved?
         end
 
         def trapping?
@@ -62,15 +62,15 @@ def on_envelope(envelope)
         def terminate!(reason = nil, envelope = nil)
           return true if terminated?
 
-          self_termination = Concurrent::Promises.completed_future(reason.nil?, reason.nil? || nil, reason)
+          self_termination = Concurrent::Promises.resolved_future(reason.nil?, reason.nil? || nil, reason)
           all_terminations = if @terminate_children
                                Concurrent::Promises.zip(*children.map { |ch| ch.ask(:terminate!) }, self_termination)
                              else
                                self_termination
                              end
 
-          all_terminations.chain_completable(@terminated)
-          all_terminations.chain_completable(envelope.future) if envelope && envelope.future
+          all_terminations.chain_resolvable(@terminated)
+          all_terminations.chain_resolvable(envelope.future) if envelope && envelope.future
 
           broadcast(true, [:terminated, reason]) # TODO do not end up in Dead Letter Router
           parent << :remove_child if parent

lib/concurrent/actor/core.rb

@@ -42,7 +42,7 @@ class Core < Synchronization::LockableObject
       # @option opts [Class] reference a custom descendant of {Reference} to use
       # @option opts [Array<Array(Behavior::Abstract, Array<Object>)>] behaviour_definition, array of pairs
       #   where each pair is behaviour class and its args, see {Behaviour.basic_behaviour_definition}
-      # @option opts [CompletableFuture, nil] initialized, if present it'll be set or failed after {Context} initialization
+      # @option opts [ResolvableFuture, nil] initialized, if present it'll be set or failed after {Context} initialization
       # @option opts [Reference, nil] parent **private api** parent of the actor (the one spawning )
       # @option opts [Proc, nil] logger a proc accepting (level, progname, message = nil, &block) params,
       #   can be used to hook actor instance to any logging system, see {Concurrent::Concern::Logging}
@@ -192,17 +192,17 @@ def ns_initialize(opts, &block)
 
         @args       = opts.fetch(:args, [])
         @block      = block
-        initialized = Type! opts[:initialized], Promises::CompletableFuture, NilClass
+        initialized = Type! opts[:initialized], Promises::ResolvableFuture, NilClass
 
         schedule_execution do
           begin
             build_context
-            initialized.succeed reference if initialized
+            initialized.fulfill reference if initialized
             log DEBUG, 'spawned'
           rescue => ex
             log ERROR, ex
             @first_behaviour.terminate!
-            initialized.fail ex if initialized
+            initialized.reject ex if initialized
           end
         end
       end

lib/concurrent/actor/envelope.rb

@@ -16,7 +16,7 @@ class Envelope
 
       def initialize(message, future, sender, address)
         @message = message
-        @future  = Type! future, Promises::CompletableFuture, NilClass
+        @future  = Type! future, Promises::ResolvableFuture, NilClass
         @sender  = Type! sender, Reference, Thread
         @address = Type! address, Reference
       end
@@ -34,7 +34,7 @@ def address_path
       end
 
       def reject!(error)
-        future.fail error unless future.nil?
+        future.reject error unless future.nil?
       end
     end
   end

lib/concurrent/actor/reference.rb

@@ -51,7 +51,7 @@ def tell(message)
       #   adder = AdHoc.spawn('adder') { -> message { message + 1 } }
       #   adder.ask(1).value # => 2
       #   adder.ask(nil).wait.reason # => #<NoMethodError: undefined method `+' for nil:NilClass>
-      def ask(message, future = Concurrent::Promises.completable_future)
+      def ask(message, future = Concurrent::Promises.resolvable_future)
         message message, future
       end
 
@@ -65,11 +65,11 @@ def ask(message, future = Concurrent::Promises.completable_future)
       # @param [Object] message
       # @param [Promises::Future] future to be fulfilled be message's processing result
       # @return [Object] message's processing result
-      # @raise [Exception] future.reason if future is #failed?
+      # @raise [Exception] future.reason if future is #rejected?
       # @example
       #   adder = AdHoc.spawn('adder') { -> message { message + 1 } }
       #   adder.ask!(1) # => 2
-      def ask!(message, future = Concurrent::Promises.completable_future)
+      def ask!(message, future = Concurrent::Promises.resolvable_future)
         ask(message, future).value!
       end
 
@@ -80,7 +80,7 @@ def map(messages)
       # behaves as {#tell} when no future and as {#ask} when future
       def message(message, future = nil)
         core.on_envelope Envelope.new(message, future, Actor.current || Thread.current, self)
-        return future ? future.with_hidden_completable : self
+        return future ? future.with_hidden_resolvable : self
       end
 
       # @see AbstractContext#dead_letter_routing

lib/concurrent/actor/utils/pool.rb

@@ -45,7 +45,7 @@ def on_message(message)
                                  else
                                    Envelope.new(envelope.message, Concurrent::Promises.future, envelope.sender, envelope.address)
                                  end
-          envelope_to_redirect.future.on_completion! { @balancer << :subscribe } # TODO check safety of @balancer reading
+          envelope_to_redirect.future.on_fulfillment! { @balancer << :subscribe } # TODO check safety of @balancer reading
           redirect @balancer, envelope_to_redirect
         end
       end