Fix Promise#always

meh · meh · commit 24f6997faf4e · 2015-04-26T18:54:29.000+02:00
diff --git a/spec/opal/stdlib/promise/always_spec.rb b/spec/opal/stdlib/promise/always_spec.rb
@@ -0,0 +1,30 @@
+require 'promise'
+
+describe 'Promise#always' do
+  it 'calls the block when it was resolved' do
+    x = 42
+    Promise.value(23).then { |v| x = v }.always { |v| x = 2 }
+    x.should == 2
+  end
+
+  it 'calls the block when it was rejected' do
+    x = 42
+    Promise.error(23).rescue { |v| x = v }.always { |v| x = 2 }
+    x.should == 2
+  end
+
+  it 'acts as resolved' do
+    x = 42
+    Promise.error(23).rescue { |v| x = v }.always { x = 2 }.then { x = 3 }
+    x.should == 3
+  end
+
+  it 'raises an exception when the promise has already been chained' do
+    p = Promise.value(2)
+    p.then {}
+
+    proc {
+      p.always {}
+    }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/opal/stdlib/promise/trace_spec.rb b/spec/opal/stdlib/promise/trace_spec.rb
@@ -21,6 +21,14 @@
     x.should == 6
   end
 
+  it 'includes the first value' do
+    x = 42
+
+    Promise.value(1).trace { |a| x = a }
+
+    x.should == 1
+  end
+
   it 'works after a when' do
     x = 42
 
diff --git a/stdlib/promise.rb b/stdlib/promise.rb
@@ -110,13 +110,12 @@ def self.when(*promises)
     When.new(promises)
   end
 
-  attr_reader :value, :error, :prev, :next
+  attr_reader :error, :prev, :next
 
-  def initialize(success = nil, failure = nil)
-    @success = success
-    @failure = failure
+  def initialize(action = {})
+    @action = action
 
-    @realized  = nil
+    @realized  = false
     @exception = false
     @value     = nil
     @error     = nil
@@ -126,16 +125,28 @@ def initialize(success = nil, failure = nil)
     @next = nil
   end
 
+  def value
+    if Promise === @value
+      @value.value
+    else
+      @value
+    end
+  end
+
   def act?
-    @success != nil
+    @action.has_key?(:success) || @action.has_key?(:always)
+  end
+
+  def action
+    @action.keys
   end
 
   def exception?
     @exception
   end
 
   def realized?
-    @realized != nil
+    !!@realized
   end
 
   def resolved?
@@ -166,8 +177,12 @@ def >>(promise)
       promise.reject(@delayed[0])
     elsif resolved?
       promise.resolve(@delayed ? @delayed[0] : value)
-    elsif rejected? && (!@failure || Promise === (@delayed ? @delayed[0] : @error))
-      promise.reject(@delayed ? @delayed[0] : error)
+    elsif rejected?
+      if !@action.has_key?(:failure) || Promise === (@delayed ? @delayed[0] : @error)
+        promise.reject(@delayed ? @delayed[0] : error)
+      elsif promise.action.include?(:always)
+        promise.reject(@delayed ? @delayed[0] : error)
+      end
     end
 
     self
@@ -179,17 +194,12 @@ def resolve(value = nil)
     end
 
     if Promise === value
-      value << @prev
-
-      return value ^ self
+      return (value << @prev) ^ self
     end
 
-    @realized = :resolve
-    @value    = value
-
     begin
-      if @success
-        value = @success.call(value)
+      if block = @action[:success] || @action[:always]
+        value = block.call(value)
       end
 
       resolve!(value)
@@ -201,6 +211,9 @@ def resolve(value = nil)
   end
 
   def resolve!(value)
+    @realized = :resolve
+    @value    = value
+
     if @next
       @next.resolve(value)
     else
@@ -214,21 +227,16 @@ def reject(value = nil)
     end
 
     if Promise === value
-      value << @prev
-
-      return value ^ self
+      return (value << @prev) ^ self
     end
 
-    @realized = :reject
-    @error    = value
-
     begin
-      if @failure
-        value = @failure.call(value)
+      if block = @action[:failure] || @action[:always]
+        value = block.call(value)
+      end
 
-        if Promise === value
-          reject!(value)
-        end
+      if @action.has_key?(:always)
+        resolve!(value)
       else
         reject!(value)
       end
@@ -240,6 +248,9 @@ def reject(value = nil)
   end
 
   def reject!(value)
+    @realized = :reject
+    @error    = value
+
     if @next
       @next.reject(value)
     else
@@ -258,7 +269,7 @@ def then(&block)
       raise ArgumentError, 'a promise has already been chained'
     end
 
-    self ^ Promise.new(block)
+    self ^ Promise.new(success: block)
   end
 
   alias do then
@@ -268,7 +279,7 @@ def fail(&block)
       raise ArgumentError, 'a promise has already been chained'
     end
 
-    self ^ Promise.new(nil, block)
+    self ^ Promise.new(failure: block)
   end
 
   alias rescue fail
@@ -279,7 +290,7 @@ def always(&block)
       raise ArgumentError, 'a promise has already been chained'
     end
 
-    self ^ Promise.new(block, block)
+    self ^ Promise.new(always: block)
   end
 
   alias finally always
@@ -311,11 +322,11 @@ def inspect
 
   class Trace < self
     def self.it(promise)
-      unless promise.realized?
-        raise ArgumentError, "the promise hasn't been realized"
-      end
+      current = []
 
-      current = promise.act? ? [promise.value] : []
+      if promise.act? || promise.prev.nil?
+        current.push(promise.value)
+      end
 
       if prev = promise.prev
         current.concat(it(prev))
@@ -327,8 +338,9 @@ def self.it(promise)
     def initialize(depth, block)
       @depth = depth
 
-      super -> {
+      super success: -> {
         trace = Trace.it(self).reverse
+        trace.pop
 
         if depth && depth <= trace.length
           trace.shift(trace.length - depth)
