fix success vs succeed naming

Author: pitr-ch

lib/concurrent/actor/behaviour/sets_results.rb

@@ -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.success result
+            envelope.future.succeed result
             log(DEBUG) { "finished processing of #{envelope.message.inspect}"}
           end
           nil

lib/concurrent/actor/core.rb

@@ -197,7 +197,7 @@ def ns_initialize(opts, &block)
         schedule_execution do
           begin
             build_context
-            initialized.success reference if initialized
+            initialized.succeed reference if initialized
             log DEBUG, 'spawned'
           rescue => ex
             log ERROR, ex

lib/concurrent/edge/promises.rb

@@ -66,7 +66,7 @@ def completable_future
       end
 
       # Creates completable future, user is responsible for completing the future once by
-      # {Promises::CompletableFuture#complete}, {Promises::CompletableFuture#success},
+      # {Promises::CompletableFuture#complete}, {Promises::CompletableFuture#succeed},
       # or {Promises::CompletableFuture#fail}
       #
       # @!macro promises.param.default_executor
@@ -95,7 +95,7 @@ def future_on(default_executor, *args, &task)
         ImmediateEventPromise.new(default_executor).future.then(*args, &task)
       end
 
-      # Creates completed future with will be either success with the given value or failed with
+      # Creates completed future with will be either success with the given value or failure with
       # the given reason.
       #
       # @!macro promises.param.default_executor
@@ -108,7 +108,7 @@ def completed_future(success, value, reason, default_executor = :io)
       #
       # @!macro promises.param.default_executor
       # @return [Future]
-      def succeeded_future(value, default_executor = :io)
+      def successful_future(value, default_executor = :io)
         completed_future true, value, nil, default_executor
       end
 
@@ -821,7 +821,7 @@ def failed?(state = internal_state)
 
       # @!macro [new] promises.warn.nil
       #   @note Make sure returned `nil` is not confused with timeout, no value when failed,
-      #     no reason when success, etc.
+      #     no reason when successful, etc.
       #     Use more exact methods if needed, like {#wait}, {#value!}, {#result}, etc.
 
       # @!macro [new] promises.method.value
@@ -831,7 +831,7 @@ def failed?(state = internal_state)
       #   @!macro promises.warn.blocks
       #   @!macro promises.warn.nil
       #   @!macro promises.param.timeout
-      # @return [Object, nil] the value of the Future when success, nil on timeout or failure.
+      # @return [Object, nil] the value of the Future when successful, nil on timeout or failure.
       def value(timeout = nil)
         touch
         internal_state.value if wait_until_complete timeout
@@ -854,7 +854,7 @@ def reason(timeout = nil)
       #
       # @!macro promises.warn.blocks
       # @!macro promises.param.timeout
-      # @return [Array(Boolean, Object, Exception), nil] triplet of success, value, reason, or nil
+      # @return [Array(Boolean, Object, Exception), nil] triplet of success?, value, reason, or nil
       #   on timeout.
       def result(timeout = nil)
         touch
@@ -870,7 +870,7 @@ def wait!(timeout = nil)
       end
 
       # @!macro promises.method.value
-      # @return [Object, nil] the value of the Future when success, nil on timeout.
+      # @return [Object, nil] the value of the Future when successful, nil on timeout.
       # @raise [Exception] {#reason} on failure
       def value!(timeout = nil)
         touch
@@ -1173,8 +1173,8 @@ def complete(success, value, reason, raise_on_reassign = true)
       # which triggers all dependent futures.
       #
       # @!macro promise.param.raise_on_reassign
-      def success(value, raise_on_reassign = true)
-        promise.success(value, raise_on_reassign)
+      def succeed(value, raise_on_reassign = true)
+        promise.succeed(value, raise_on_reassign)
       end
 
       # Makes the future failed with `reason`,
@@ -1278,7 +1278,7 @@ def initialize(default_executor)
         super CompletableFuture.new(self, default_executor)
       end
 
-      def success(value, raise_on_reassign)
+      def succeed(value, raise_on_reassign)
         complete_with Success.new(value), raise_on_reassign
       end
 
@@ -1325,7 +1325,7 @@ def on_done(future)
       end
 
       def touch
-        # TODO (pitr-ch 13-Jun-2016): track if it has lazy parent if it's needed avoids CASes!
+        # TODO (pitr-ch 13-Jun-2016): on construction pass down references of delays to be touched, avoids extra casses
         blocked_by.each(&:touch)
       end
 
@@ -1964,7 +1964,7 @@ class Throttle < Synchronization::Object
     def initialize(max)
       super()
       self.can_run = max
-      # TODO (pitr-ch 10-Jun-2016): lockfree gueue is needed
+      # TODO (pitr-ch 10-Jun-2016): lock-free queue is needed
       @Queue       = Queue.new
     end
 

spec/concurrent/promises_spec.rb

@@ -18,7 +18,7 @@
     it 'future' do
       b = completable_future
       a = completable_future.chain_completable(b)
-      a.success :val
+      a.succeed :val
       expect(b).to be_completed
       expect(b.value).to eq :val
     end
@@ -29,15 +29,15 @@
       future = future { 1 + 1 }
       expect(future.value!).to eq 2
 
-      future = succeeded_future(1).then { |v| v + 1 }
+      future = successful_future(1).then { |v| v + 1 }
       expect(future.value!).to eq 2
     end
 
     it 'executes with args' do
       future = future(1, 2, &:+)
       expect(future.value!).to eq 3
 
-      future = succeeded_future(1).then(1) { |v, a| v + 1 }
+      future = successful_future(1).then(1) { |v, a| v + 1 }
       expect(future.value!).to eq 2
     end
   end
@@ -51,9 +51,9 @@ def behaves_as_delay(delay, value)
 
     specify do
       behaves_as_delay delay { 1 + 1 }, 2
-      behaves_as_delay succeeded_future(1).delay.then { |v| v + 1 }, 2
+      behaves_as_delay successful_future(1).delay.then { |v| v + 1 }, 2
       behaves_as_delay delay(1) { |a| a + 1 }, 2
-      behaves_as_delay succeeded_future(1).delay.then { |v| v + 1 }, 2
+      behaves_as_delay successful_future(1).delay.then { |v| v + 1 }, 2
     end
   end
 
@@ -118,7 +118,7 @@ def behaves_as_delay(delay, value)
       one                = completable_future.then(&:succ)
       join               = zip_futures(completable_future).then { |v| v }
       expect(one.completed?).to be false
-      completable_future.success 0
+      completable_future.succeed 0
       expect(one.value!).to eq 1
       expect(join.wait!.completed?).to be true
       expect(join.value!).to eq 0
@@ -134,7 +134,7 @@ def behaves_as_delay(delay, value)
       any1 = any_complete_future(f1, f2)
       any2 = f2 | f3
 
-      f1.success 1
+      f1.succeed 1
       f2.fail StandardError.new
 
       expect(any1.value!).to eq 1
@@ -150,7 +150,7 @@ def behaves_as_delay(delay, value)
       any = any_successful_future(f1, f2)
 
       f1.fail StandardError.new
-      f2.success :value
+      f2.succeed :value
 
       expect(any.value!).to eq :value
     end
@@ -229,15 +229,15 @@ def behaves_as_delay(delay, value)
 
   describe '.each' do
     specify do
-      expect(succeeded_future(nil).each.map(&:inspect)).to eq ['nil']
-      expect(succeeded_future(1).each.map(&:inspect)).to eq ['1']
-      expect(succeeded_future([1, 2]).each.map(&:inspect)).to eq ['1', '2']
+      expect(successful_future(nil).each.map(&:inspect)).to eq ['nil']
+      expect(successful_future(1).each.map(&:inspect)).to eq ['1']
+      expect(successful_future([1, 2]).each.map(&:inspect)).to eq ['1', '2']
     end
   end
 
   describe '.zip_events' do
     it 'waits for all and returns event' do
-      a = succeeded_future 1
+      a = successful_future 1
       b = failed_future :any
       c = completable_event.complete