lgierth · arthurschreiber · Jun 27, 2017 · Aug 31, 2017 · Aug 31, 2017 · Aug 31, 2017
diff --git a/config/reek.yml b/config/reek.yml
@@ -45,7 +45,7 @@ NestedIterators:
   enabled: true
   exclude: []
   max_allowed_nesting: 1
-  ignore_iterators: []
+  ignore_iterators: [lambda]
 NilCheck:
   enabled: true
   exclude: []

diff --git a/lib/promise.rb b/lib/promise.rb
@@ -70,7 +70,18 @@ def then(on_fulfill = nil, on_reject = nil, &block)
     next_promise
   end
 
-  def rescue(&block)
+  def rescue(*args)
+    raise ArgumentError, 'no block given' unless block_given?
+
+    if args.empty?
+      block = Proc.new
+    else
+      block = lambda do |error|
+        raise error unless args.any? { |error_class| error.is_a?(error_class) }
+        yield error
+      end
+    end
+
     self.then(nil, block)
   end
   alias_method :catch, :rescue

diff --git a/spec/unit/promise_spec.rb b/spec/unit/promise_spec.rb
@@ -736,6 +736,85 @@
         expect(result).to eq(reason)
         expect(subject.reason).to eq(reason)
       end
+
+      it 'allows specifying a list of error types' do
+        result = nil
+        p = subject.rescue(StandardError) do |reason|
+          result = reason
+        end
+
+        subject.reject(reason)
+        expect(result).to eq(reason)
+        expect(subject.reason).to eq(reason)
+        expect(p).to be_fulfilled
+
+        result = nil
+        p = subject.rescue(RuntimeError) do |reason|
+          result = reason
+        end
+
+        subject.reject(reason)
+        expect(result).to be_nil
+        expect(subject.reason).to eq(reason)
+        expect(p).to be_rejected
+
+        result = nil
+        p = subject.rescue(RuntimeError, StandardError) do |reason|
+          result = reason
+        end
+
+        subject.reject(reason)
+        expect(result).to eq(reason)
+        expect(subject.reason).to eq(reason)
+        expect(p).to be_fulfilled
+      end
+
+      it 'can not be called without a block' do
+        p1 = Promise.new
+
+        expect {
+          p1.rescue
+        }.to raise_error(ArgumentError, 'no block given')
+      end
+
+      it 'can be called with with a block not taking an error argument' do
+        p1 = Promise.new
+        p2 = p1.rescue { :foo }
+
+        p1.reject(RuntimeError.new('fail'))
+
+        expect(p2).to be_fulfilled
+        expect(p2.value).to equal(:foo)
+      end
+
+      it 'correctly handles error type subclasses' do
+        rescued = []
+
+        promise = Promise.new
+        promise.rescue(StandardError) do
+          rescued << StandardError
+        end
+        promise.rescue(RuntimeError) do
+          rescued << RuntimeError
+        end
+
+        promise.reject(RuntimeError.new('fail'))
+
+        expect(rescued).to eq([StandardError, RuntimeError])
+      end
+
+      it 'does not handle unspecified error types' do
+        p1 = Promise.new
+        p2 = p1.rescue(RuntimeError) { raise 'fail' }
+        p3 = p2.rescue do |error|
+          expect(error).to be_an_instance_of(StandardError)
+          expect(error.message).to eq('testing')
+        end
+
+        p1.reject(StandardError.new('testing'))
+        expect(p2).to be_rejected
+        expect(p3).to be_fulfilled
+      end
     end
 
     describe '#catch' do
@@ -747,6 +826,32 @@
         expect(result).to eq(reason)
         expect(subject.reason).to eq(reason)
       end
+
+      it 'allows specifying a list of error types' do
+        result = nil
+        p = subject.catch(StandardError) { |reas| result = reas }
+
+        subject.reject(reason)
+        expect(result).to eq(reason)
+        expect(subject.reason).to eq(reason)
+        expect(p).to be_fulfilled
+
+        result = nil
+        p = subject.catch(RuntimeError) { |reas| result = reas }
+
+        subject.reject(reason)
+        expect(result).to be_nil
+        expect(subject.reason).to eq(reason)
+        expect(p).to be_rejected
+
+        result = nil
+        p = subject.catch(RuntimeError, StandardError) { |reas| result = reas }
+
+        subject.reject(reason)
+        expect(result).to eq(reason)
+        expect(subject.reason).to eq(reason)
+        expect(p).to be_fulfilled
+      end
     end
 
     describe '#progress' do