Removed Promise.one? and Promise.none?

The original request was for .any? and .all? methods. We added .none?
and .one? methods for synergy with arrays, but didn't like that these
methods supressed exceptions. So we decided to add only the requested
methods and consider other methods in the future.

Author: jdantonio

lib/concurrent/promise.rb

@@ -363,28 +363,6 @@ def self.any?(*promises)
       aggregate(:any?, *promises)
     end
 
-    # Aggregates a collection of promises and executes the `then` condition
-    # if all aggregated promises fail. Executes the `rescue` handler with
-    # a `Concurrent::PromiseExecutionError` if any of the aggregated promises
-    # succeed. Upon execution will execute any of the aggregate promises that
-    # were not already executed.
-    #
-    # @!macro promise_self_aggregate
-    def self.none?(*promises)
-      aggregate(:none?, *promises)
-    end
-
-    # Aggregates a collection of promises and executes the `then` condition
-    # if one and only one of the  aggregated promises succeeds. Executes the
-    # `rescue` handler with a `Concurrent::PromiseExecutionError` more than one
-    # of the aggregated promises succeed. Upon execution will execute any of
-    # the aggregate promises that were not already executed.
-    #
-    # @!macro promise_self_aggregate
-    def self.one?(*promises)
-      aggregate(:one?, *promises)
-    end
-
     protected
 
     # Aggregate a collection of zero or more promises under a composite promise,

spec/concurrent/promise_spec.rb

@@ -448,116 +448,6 @@ module Concurrent
           expect(counter.value).to eq -1
         end
       end
-  
-      describe '.none?' do
-  
-        it 'returns a new Promise' do
-          composite = Promise.none?(promise1, promise2, promise3).execute
-          expect(composite).to be_a Concurrent::Promise
-        end
-  
-        it 'does not execute the returned Promise' do
-          composite = Promise.none?(promise1, promise2, promise3)
-          expect(composite).to be_unscheduled
-        end
-  
-        it 'executes the #then condition when all components fail' do
-          counter = Concurrent::AtomicFixnum.new(0)
-          latch = Concurrent::CountDownLatch.new(1)
-  
-          composite = Promise.none?(rejected_subject, rejected_subject, rejected_subject, rejected_subject).
-            then { counter.up; latch.count_down }.
-            rescue { counter.down; latch.count_down }.
-            execute
-  
-          latch.wait(1)
-  
-          expect(counter.value).to eq 1
-        end
-  
-        it 'executes the #then condition when no promises are given' do
-          counter = Concurrent::AtomicFixnum.new(0)
-          latch = Concurrent::CountDownLatch.new(1)
-  
-          composite = Promise.none?.
-            then { counter.up; latch.count_down }.
-            rescue { counter.down; latch.count_down }.
-            execute
-  
-          latch.wait(1)
-  
-          expect(counter.value).to eq 1
-        end
-  
-        it 'executes the #rescue handler if even one component succeeds' do
-          counter = Concurrent::AtomicFixnum.new(0)
-          latch = Concurrent::CountDownLatch.new(1)
-  
-          composite = Promise.none?(promise1, promise2, rejected_subject, promise3).
-            then { counter.up; latch.count_down }.
-            rescue { counter.down; latch.count_down }.
-            execute
-  
-          latch.wait(1)
-  
-          expect(counter.value).to eq -1
-        end
-      end
-  
-      describe '.one?' do
-  
-        it 'returns a new Promise' do
-          composite = Promise.one?(promise1, promise2, promise3).execute
-          expect(composite).to be_a Concurrent::Promise
-        end
-  
-        it 'does not execute the returned Promise' do
-          composite = Promise.one?(promise1, promise2, promise3)
-          expect(composite).to be_unscheduled
-        end
-  
-        it 'executes the #then condition when only one component succeeds' do
-          counter = Concurrent::AtomicFixnum.new(0)
-          latch = Concurrent::CountDownLatch.new(1)
-  
-          composite = Promise.one?(promise1, rejected_subject, rejected_subject, rejected_subject).
-            then { counter.up; latch.count_down }.
-            rescue { counter.down; latch.count_down }.
-            execute
-  
-          latch.wait(1)
-  
-          expect(counter.value).to eq 1
-        end
-  
-        it 'executes the #then condition when no promises are given' do
-          counter = Concurrent::AtomicFixnum.new(0)
-          latch = Concurrent::CountDownLatch.new(1)
-  
-          composite = Promise.one?.
-            then { counter.up; latch.count_down }.
-            rescue { counter.down; latch.count_down }.
-            execute
-  
-          latch.wait(1)
-  
-          expect(counter.value).to eq 1
-        end
-  
-        it 'executes the #rescue handler if two or more components succeed' do
-          counter = Concurrent::AtomicFixnum.new(0)
-          latch = Concurrent::CountDownLatch.new(1)
-  
-          composite = Promise.one?(promise1, promise2, rejected_subject, promise3).
-            then { counter.up; latch.count_down }.
-            rescue { counter.down; latch.count_down }.
-            execute
-  
-          latch.wait(1)
-  
-          expect(counter.value).to eq -1
-        end
-      end
     end
 
     context 'fulfillment' do