Adding in Promises

Cargo.toml

@@ -18,14 +18,15 @@ serde = { version = "1", optional = true }
 serde_json = { version = "1", optional = true }
 clippy = { version = "0.0", optional = true }
 stdweb-derive = { path = "stdweb-derive" }
+futures = { version = "0.1.18", optional = true }
 
 [dev-dependencies]
 serde_json = "1"
 serde_derive = "1"
 
 [features]
-default = ["serde", "serde_json"]
-dev = ["serde", "serde_json", "clippy"]
+default = ["serde", "serde_json", "futures"]
+dev = ["serde", "serde_json", "futures", "clippy"]
 serde-support = ["serde", "serde_json"]
 nightly = []
 web_test = []

examples/promise/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "promise"
+version = "0.1.0"
+authors = ["Pauan <pcxunlimited@gmail.com>"]
+
+[dependencies]
+stdweb = { path = "../.." }
+futures = "0.1.18"

examples/promise/src/main.rs

@@ -0,0 +1,244 @@
+#[macro_use]
+extern crate stdweb;
+extern crate futures;
+
+use futures::Future;
+use stdweb::unstable::{TryInto};
+use stdweb::web::error::Error;
+use stdweb::{Null, Promise, PromiseFuture};
+use std::rc::Rc;
+use std::cell::RefCell;
+use futures::{Poll, Async};
+use futures::task::{current, Task};
+
+
+fn log( a: &str ) {
+    js! { @(no_return)
+        console.log( @{a} );
+    }
+}
+
+
+fn test_error_conversion() {
+    let a: PromiseFuture< Null, String > = js!( return Promise.reject( "hi!" ); ).try_into().unwrap();
+
+    PromiseFuture::spawn(
+        a.map( |_| () ).map_err( |x| {
+            log( &format!( "String error: {:#?}", x ) );
+        } )
+    );
+
+    let _a: PromiseFuture< Null, Error > = js!( return Promise.resolve( null ); ).try_into().unwrap();
+    log( "Null works" );
+
+    let _a: PromiseFuture< Null, Error > = js!( return Promise.reject( new Error( "hi!" ) ); ).try_into().unwrap();
+    log( "Error works" );
+
+    //let _a: PromiseFuture< Null, SyntaxError > = js!( return Promise.reject( new Error( "hi!" ) ); ).try_into().unwrap();
+    //log( "Error conversion fails" );
+}
+
+
+fn test_refcell() {
+    struct TaskA {
+        shared_state: Rc<RefCell<u32>>,
+        task_b: Task,
+    }
+
+    impl Future for TaskA {
+        type Item = ();
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+            js! { console.log("Poll TaskA"); }
+
+            let foo = self.shared_state.borrow_mut();
+
+            js! { console.log(@{format!("TaskA 1: {:#?}", foo)}); }
+
+            self.task_b.notify();
+
+            js! { console.log(@{format!("TaskA 2: {:#?}", foo)}); }
+
+            Ok(Async::NotReady)
+        }
+    }
+
+    struct TaskB {
+        shared_state: Rc<RefCell<u32>>,
+        initialized: bool,
+    }
+
+    impl Future for TaskB {
+        type Item = ();
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+            js! { console.log("Poll TaskB"); }
+
+            if !self.initialized {
+                self.initialized = true;
+
+                let task_b = current();
+
+                let foo = self.shared_state.borrow();
+
+                js! { console.log(@{format!("TaskB 1: {:#?}", foo)}); }
+
+                PromiseFuture::spawn(TaskA {
+                    shared_state: self.shared_state.clone(),
+                    task_b: task_b,
+                });
+            }
+
+            let foo = self.shared_state.borrow();
+
+            js! { console.log(@{format!("TaskB 1: {:#?}", foo)}); }
+
+            Ok(Async::NotReady)
+        }
+    }
+
+    PromiseFuture::spawn(TaskB {
+        shared_state: Rc::new(RefCell::new(0)),
+        initialized: false
+    });
+}
+
+
+fn test_panic() {
+    let promise: Promise = js!( return Promise.resolve(null); ).try_into().unwrap();
+
+    promise.done( |result: Result< Null, Error >| {
+        log( &format!( "Promise result: {:#?}", result ) );
+        panic!( "Testing panic!" );
+    } );
+}
+
+
+fn test_notify() {
+    struct MyFuture {
+        polls: u32,
+        count: u32,
+        done: bool,
+        receiver: futures::unsync::oneshot::Receiver< () >,
+    }
+
+    impl MyFuture {
+        fn new( count: u32 ) -> Self {
+            let ( sender, receiver ) = futures::unsync::oneshot::channel();
+
+            let callback = || {
+                log( "setTimeout done" );
+
+                log( &format!("Sending {:#?}", sender.send( () ) ) );
+            };
+
+            log( "setTimeout started" );
+
+            js! { @(no_return)
+                setTimeout( function () {
+                    @{stdweb::Once( callback )}();
+                }, 1000 );
+            }
+
+            Self {
+                polls: 0,
+                count: count,
+                done: false,
+                receiver,
+            }
+        }
+    }
+
+    impl Future for MyFuture {
+        type Item = u32;
+        type Error = ();
+
+        fn poll( &mut self ) -> futures::Poll< Self::Item, Self::Error > {
+            self.polls += 1;
+
+            if !self.done {
+                match self.receiver.poll() {
+                    Ok( futures::Async::Ready( () ) ) => self.done = true,
+
+                    Ok( futures::Async::NotReady ) => {},
+
+                    Err( _ ) => self.done = true,
+                }
+            }
+
+            if self.done {
+                if self.count == 0 {
+                    Ok( futures::Async::Ready( self.polls ) )
+
+                } else {
+                    self.count -= 1;
+
+                    let task = futures::task::current();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+                    task.notify();
+
+                    Ok( futures::Async::NotReady )
+                }
+
+            } else {
+                Ok( futures::Async::NotReady )
+            }
+        }
+    }
+
+    PromiseFuture::spawn(
+        MyFuture::new( 5 ).map( |x| {
+            log( &format!( "MyFuture count: {}", x ) );
+            assert_eq!( x, 7 );
+        } )
+    );
+}
+
+
+fn test_timeout() {
+    fn sleep( ms: u32 ) -> PromiseFuture< Null, Error > {
+        js!( return new Promise( function ( success, failure ) {
+            setTimeout( function () {
+                success( null );
+            }, @{ms} );
+        } ); ).try_into().unwrap()
+    }
+
+    PromiseFuture::spawn(
+        sleep( 2000 ).inspect( |_| log( "Timeout 1 done!") ).join(
+        sleep( 2000 ).inspect( |_| log( "Timeout 2 done!" ) ) )
+            .and_then( |_|
+                sleep( 1000 ).inspect( |_| log( "Timeout 3 done!") ) )
+            .and_then( |_|
+                futures::future::err( Error::new( "Testing error!" ) ) )
+            .map_err( |e| e.print() )
+    );
+}
+
+
+fn main() {
+    stdweb::initialize();
+
+    test_refcell();
+    test_panic();
+    test_notify();
+    test_timeout();
+    test_error_conversion();
+
+    stdweb::event_loop();
+}
+

src/lib.rs

@@ -94,6 +94,9 @@ extern crate stdweb_internal_macros;
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 pub use stdweb_internal_macros::js_export;
 
+#[cfg(feature = "futures")]
+extern crate futures;
+
 #[macro_use]
 extern crate stdweb_derive;
 
@@ -128,6 +131,11 @@ pub use webcore::instance_of::InstanceOf;
 pub use webcore::reference_type::ReferenceType;
 pub use webcore::serialization::JsSerialize;
 
+pub use webcore::promise::Promise;
+
+#[cfg(feature = "futures")]
+pub use webcore::promise_future::PromiseFuture;
+
 #[cfg(feature = "serde")]
 /// A module with serde-related APIs.
 pub mod serde {

src/webapi/error.rs

@@ -36,6 +36,26 @@ pub trait IError: ReferenceType {
 #[reference(instance_of = "Error")]
 pub struct Error( Reference );
 
+impl Error {
+    /// Creates a new `Error` with the specified `description`.
+    ///
+    /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+    #[inline]
+    pub fn new( description: &str ) -> Self {
+        js!( return new Error( @{description} ); ).try_into().unwrap()
+    }
+
+    /// Prints the `Error` to the console (this prints the error's description and also its stack trace).
+    ///
+    /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/API/Console/error)
+    #[inline]
+    pub fn print( &self ) {
+        js! { @(no_return)
+            console.error( @{self} );
+        }
+    }
+}
+
 // Error specification:
 // https://www.ecma-international.org/ecma-262/6.0/#sec-error-objects
 

src/webcore/mod.rs

@@ -15,6 +15,13 @@ pub mod unsafe_typed_array;
 pub mod once;
 pub mod instance_of;
 pub mod reference_type;
+pub mod promise;
+
+#[cfg(feature = "futures")]
+pub mod promise_future;
+
+#[cfg(feature = "futures")]
+pub mod promise_executor;
 
 #[cfg(feature = "nightly")]
 pub mod void {