Merge pull request Real-Serious-Games#99 from alonsohki/master

Added Promise<T>.First() to find the first promise that returns a value.

Author: RoryDungan

Tests/PromiseProgressTests.cs

@@ -154,6 +154,33 @@ public void exception_is_thrown_for_progress_after_reject()
             Assert.Throws<PromiseStateException>(() => promise.ReportProgress(1f));
         }
 
+        [Fact]
+        public void first_progress_is_averaged()
+        {
+            var promiseA = new Promise<int>();
+            var promiseB = new Promise<int>();
+            var promiseC = new Promise<int>();
+            var promiseD = new Promise<int>();
+
+            int currentStep = 0;
+            var expectedProgress = new[] { 0.25f, 0.50f, 0.75f, 1f };
+
+            Promise<int>.First(() => promiseA, () => promiseB, () => promiseC, () => promiseD)
+                .Progress(progress =>
+                {
+                    Assert.InRange(currentStep, 0, expectedProgress.Length - 1);
+                    Assert.Equal(expectedProgress[currentStep], progress);
+                    ++currentStep;
+                });
+
+            promiseA.Reject(null);
+            promiseC.Reject(null);
+            promiseB.Reject(null);
+            promiseD.Reject(null);
+
+            Assert.Equal(expectedProgress.Length, currentStep);
+        }
+
         [Fact]
         public void all_progress_is_averaged()
         {
@@ -179,7 +206,6 @@ public void all_progress_is_averaged()
             promiseD.ReportProgress(1f);
 
             Assert.Equal(expectedProgress.Length, currentStep);
-            Assert.Equal(expectedProgress.Length, currentStep);
         }
 
         [Fact]

Tests/PromiseTests.cs

@@ -217,6 +217,54 @@ public void then_handler_is_not_invoked_for_rejected_promise()
             promise.Reject(new Exception("Rejection!"));
         }
 
+        [Fact]
+        public void chain_multiple_promises_using_first()
+        {
+            var promise = new Promise<int>();
+            var chainedPromise1 = Promise<int>.Rejected(null);
+            var chainedPromise2 = Promise<int>.Rejected(null);
+            var chainedPromise3 = Promise<int>.Resolved(9001);
+
+            bool completed = false;
+
+            Promise<int>
+                .First(() => chainedPromise1, () => chainedPromise2, () => chainedPromise3, () =>
+                {
+                    Assert.True(false, "Didn't stop on the first resolved promise");
+                    return Promise<int>.Rejected(null);
+                })
+                .Then(result =>
+                {
+                    Assert.Equal(9001, result);
+                    completed = true;
+                })
+            ;
+
+            Assert.Equal(true, completed);
+        }
+
+        [Fact]
+        public void chain_multiple_rejected_promises_using_first()
+        {
+            var promise = new Promise<int>();
+            var chainedPromise1 = Promise<int>.Rejected(new Exception("First chained promise"));
+            var chainedPromise2 = Promise<int>.Rejected(new Exception("Second chained promise"));
+            var chainedPromise3 = Promise<int>.Rejected(new Exception("Third chained promise"));
+
+            bool completed = false;
+
+            Promise<int>
+                .First(() => chainedPromise1, () => chainedPromise2, () => chainedPromise3)
+                .Catch(ex =>
+                {
+                    Assert.Equal("Third chained promise", ex.Message);
+                    completed = true;
+                })
+            ;
+
+            Assert.Equal(true, completed);
+        }
+
         [Fact]
         public void chain_multiple_promises_using_all()
         {

src/Promise.cs

@@ -295,6 +295,12 @@ public Promise(Action<Action<PromisedT>, Action<Exception>> resolver)
             }
         }
 
+        private Promise(PromiseState initialState)
+        {
+            CurState = initialState;
+            id = Promise.NextId();
+        }
+
         /// <summary>
         /// Add a rejection handler for this promise.
         /// </summary>
@@ -378,7 +384,8 @@ private void InvokeRejectHandlers(Exception ex)
 
             if (rejectHandlers != null)
             {
-                rejectHandlers.Each(handler => InvokeHandler(handler.callback, handler.rejectable, ex));
+                for (int i = 0, maxI = rejectHandlers.Count; i < maxI; ++i)
+                    InvokeHandler(rejectHandlers[i].callback, rejectHandlers[i].rejectable, ex);
             }
 
             ClearHandlers();
@@ -406,7 +413,8 @@ private void InvokeProgressHandlers(float progress)
         {
             if (progressHandlers != null)
             {
-                progressHandlers.Each(handler => InvokeHandler(handler.callback, handler.rejectable, progress));
+                for (int i = 0, maxI = progressHandlers.Count; i < maxI; ++i)
+                    InvokeHandler(progressHandlers[i].callback, progressHandlers[i].rejectable, progress);
             }
         }
 
@@ -510,6 +518,9 @@ public void Done(Action<PromisedT> onResolved)
         /// </summary>
         public void Done()
         {
+            if (CurState == PromiseState.Resolved)
+                return;
+
             Catch(ex =>
                 Promise.PropagateUnhandledException(this, ex)
             );
@@ -529,6 +540,11 @@ public IPromise<PromisedT> WithName(string name)
         /// </summary>
         public IPromise Catch(Action<Exception> onRejected)
         {
+            if (CurState == PromiseState.Resolved)
+            {
+                return Promise.Resolved();
+            }
+
             var resultPromise = new Promise();
             resultPromise.WithName(Name);
 
@@ -558,6 +574,11 @@ public IPromise Catch(Action<Exception> onRejected)
         /// </summary>
         public IPromise<PromisedT> Catch(Func<Exception, PromisedT> onRejected)
         {
+            if (CurState == PromiseState.Resolved)
+            {
+                return this;
+            }
+
             var resultPromise = new Promise<PromisedT>();
             resultPromise.WithName(Name);
 
@@ -645,9 +666,21 @@ public IPromise<ConvertedT> Then<ConvertedT>(
             Action<float> onProgress
         )
         {
+            if (CurState == PromiseState.Resolved)
+            {
+                try
+                {
+                    return onResolved(resolveValue);
+                }
+                catch (Exception ex)
+                {
+                    return Promise<ConvertedT>.Rejected(ex);
+                }
+            }
+
             // This version of the function must supply an onResolved.
             // Otherwise there is now way to get the converted value to pass to the resulting promise.
-//            Argument.NotNull(() => onResolved); 
+            //            Argument.NotNull(() => onResolved); 
 
             var resultPromise = new Promise<ConvertedT>();
             resultPromise.WithName(Name);
@@ -700,6 +733,18 @@ Action<float> onProgress
         /// </summary>
         public IPromise Then(Func<PromisedT, IPromise> onResolved, Action<Exception> onRejected, Action<float> onProgress)
         {
+            if (CurState == PromiseState.Resolved)
+            {
+                try
+                {
+                    return onResolved(resolveValue);
+                }
+                catch (Exception ex)
+                {
+                    return Promise.Rejected(ex);
+                }
+            }
+
             var resultPromise = new Promise();
             resultPromise.WithName(Name);
 
@@ -720,15 +765,19 @@ public IPromise Then(Func<PromisedT, IPromise> onResolved, Action<Exception> onR
                 }
             };
 
-            Action<Exception> rejectHandler = ex =>
+            Action<Exception> rejectHandler;
+            if (onRejected != null)
             {
-                if (onRejected != null)
+                rejectHandler = ex =>
                 {
                     onRejected(ex);
-                }
-
-                resultPromise.Reject(ex);
-            };
+                    resultPromise.Reject(ex);
+                };
+            }
+            else
+            {
+                rejectHandler = resultPromise.Reject;
+            }
 
             ActionHandlers(resultPromise, resolveHandler, rejectHandler);
             if (onProgress != null)
@@ -744,6 +793,19 @@ public IPromise Then(Func<PromisedT, IPromise> onResolved, Action<Exception> onR
         /// </summary>
         public IPromise Then(Action<PromisedT> onResolved, Action<Exception> onRejected, Action<float> onProgress)
         {
+            if (CurState == PromiseState.Resolved)
+            {
+                try
+                {
+                    onResolved(resolveValue);
+                    return Promise.Resolved();
+                }
+                catch (Exception ex)
+                {
+                    return Promise.Rejected(ex);
+                }
+            }
+
             var resultPromise = new Promise();
             resultPromise.WithName(Name);
 
@@ -757,15 +819,19 @@ public IPromise Then(Action<PromisedT> onResolved, Action<Exception> onRejected,
                 resultPromise.Resolve();
             };
 
-            Action<Exception> rejectHandler = ex =>
+            Action<Exception> rejectHandler;
+            if (onRejected != null)
             {
-                if (onRejected != null)
+                rejectHandler = ex =>
                 {
                     onRejected(ex);
-                }
-
-                resultPromise.Reject(ex);
-            };
+                    resultPromise.Reject(ex);
+                };
+            }
+            else
+            {
+                rejectHandler = resultPromise.Reject;
+            }
 
             ActionHandlers(resultPromise, resolveHandler, rejectHandler);
             if (onProgress != null)
@@ -817,6 +883,64 @@ private void ProgressHandlers(IRejectable resultPromise, Action<float> progressH
             }
         }
 
+        /// <summary>
+        /// Chain a number of operations using promises.
+        /// Returns the value of the first promise that resolves, or otherwise the exception thrown by the last operation.
+        /// </summary>
+        public static IPromise<T> First<T>(params Func<IPromise<T>>[] fns)
+        {
+            return First((IEnumerable<Func<IPromise<T>>>)fns);
+        }
+
+        /// <summary>
+        /// Chain a number of operations using promises.
+        /// Returns the value of the first promise that resolves, or otherwise the exception thrown by the last operation.
+        /// </summary>
+        public static IPromise<T> First<T>(IEnumerable<Func<IPromise<T>>> fns)
+        {
+            var promise = new Promise<T>();
+
+            int count = 0;
+
+            fns.Aggregate(
+                Promise<T>.Rejected(null),
+                (prevPromise, fn) =>
+                {
+                    int itemSequence = count;
+                    ++count;
+
+                    var newPromise = new Promise<T>();
+                    prevPromise
+                        .Progress(v =>
+                        {
+                            var sliceLength = 1f / count;
+                            promise.ReportProgress(sliceLength * (v + itemSequence));
+                        })
+                        .Then((Action<T>)newPromise.Resolve)
+                        .Catch(ex =>
+                        {
+                            var sliceLength = 1f / count;
+                            promise.ReportProgress(sliceLength * itemSequence);
+
+                            fn()
+                                .Then(value => newPromise.Resolve(value))
+                                .Catch(newPromise.Reject)
+                                .Done()
+                            ;
+                        })
+                    ;
+                    return newPromise;
+                })
+            .Then(value => promise.Resolve(value))
+            .Catch(ex =>
+            {
+                promise.ReportProgress(1f);
+                promise.Reject(ex);
+            });
+
+            return promise;
+        }
+
         /// <summary>
         /// Chain an enumerable of promises, all of which must resolve.
         /// Returns a promise for a collection of the resolved results.
@@ -989,8 +1113,8 @@ public static IPromise<PromisedT> Race(IEnumerable<IPromise<PromisedT>> promises
         /// </summary>
         public static IPromise<PromisedT> Resolved(PromisedT promisedValue)
         {
-            var promise = new Promise<PromisedT>();
-            promise.Resolve(promisedValue);
+            var promise = new Promise<PromisedT>(PromiseState.Resolved);
+            promise.resolveValue = promisedValue;
             return promise;
         }
 
@@ -1001,17 +1125,30 @@ public static IPromise<PromisedT> Rejected(Exception ex)
         {
 //            Argument.NotNull(() => ex);
 
-            var promise = new Promise<PromisedT>();
-            promise.Reject(ex);
+            var promise = new Promise<PromisedT>(PromiseState.Rejected);
+            promise.rejectionException = ex;
             return promise;
         }
 
         public IPromise<PromisedT> Finally(Action onComplete)
         {
+            if (CurState == PromiseState.Resolved)
+            {
+                try
+                {
+                    onComplete();
+                    return this;
+                }
+                catch (Exception ex)
+                {
+                    return Rejected(ex);
+                }
+            }
+
             var promise = new Promise<PromisedT>();
             promise.WithName(Name);
 
-            this.Then(x => promise.Resolve(x));
+            this.Then((Action<PromisedT>)promise.Resolve);
             this.Catch(e => {
                 try {
                     onComplete();
@@ -1052,7 +1189,7 @@ public IPromise<ConvertedT> ContinueWith<ConvertedT>(Func<IPromise<ConvertedT>>
 
         public IPromise<PromisedT> Progress(Action<float> onProgress)
         {
-            if (onProgress != null)
+            if (CurState == PromiseState.Pending && onProgress != null)
             {
                 ProgressHandlers(this, onProgress);
             }