Merge pull request #32 from cbrevik/console-timer

Add gloo-console-timer

Author: fitzgen

Cargo.toml

@@ -9,5 +9,6 @@ version = "0.1.0"
 
 [dependencies]
 gloo-timers = { version = "0.1.0", path = "crates/timers" }
+gloo-console-timer = { version = "0.1.0", path = "crates/console-timer" }
 
 [workspace]

crates/console-timer/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "gloo-console-timer"
+version = "0.1.0"
+authors = ["Rust and WebAssembly Working Group"]
+edition = "2018"
+
+[dependencies.web-sys]
+version = "0.3.14"
+features = [
+    "console",
+]
+
+[dev-dependencies]
+wasm-bindgen-test = "0.2.37"
+gloo-timers = { version = "0.1.0", path = "../timers" }

crates/console-timer/src/lib.rs

@@ -0,0 +1,100 @@
+/*!
+
+The `console.time` and `console.timeEnd` functions allow you to log the
+timing of named operations to the browser's developer tools console. You
+call `console.time("foo")` when the operation begins, and call
+`console.timeEnd("foo")` when it finishes.
+
+Additionally, these measurements will show up in your browser's profiler's
+"timeline" or "waterfall" view.
+
+[See MDN for more info](https://developer.mozilla.org/en-US/docs/Web/API/console#Timers).
+
+This API wraps both the `time` and `timeEnd` calls into a single type
+named `ConsoleTimer`, ensuring both are called.
+
+## Scoped measurement
+
+Wrap code to be measured in a closure with `ConsoleTimer::scope`.
+
+```no_run
+use gloo_console_timer::ConsoleTimer;
+
+let value = ConsoleTimer::scope("foo", || {
+    // Place code to be measured here
+    // Optionally return a value.
+});
+```
+
+## RAII-style measurement
+
+For scenarios where `ConsoleTimer::scope` can't be used, like with
+asynchronous operations, you can use `ConsoleTimer::new` to create a timer.
+The measurement ends when the timer object goes out of scope / is dropped.
+
+```no_run
+use gloo_console_timer::ConsoleTimer;
+use gloo_timers::Timeout;
+
+let timeout = Timeout::new(1_000, move || {
+    let _timer = ConsoleTimer::new("foo");
+    // Do some work which will be measured
+});
+```
+
+ */
+
+#![deny(missing_docs, missing_debug_implementations)]
+
+use web_sys::console;
+
+/// A console time measurement.
+///
+/// See `ConsoleTimer::scope` for starting a labeled time measurement
+/// of code wrapped in a closure.
+#[derive(Debug)]
+pub struct ConsoleTimer<'a> {
+    label: &'a str,
+}
+
+impl<'a> ConsoleTimer<'a> {
+    /// Starts a console time measurement. The measurement
+    /// ends when the constructed `ConsoleTimer` object is dropped.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use gloo_console_timer::ConsoleTimer;
+    ///
+    /// let _timer = ConsoleTimer::new("foo");
+    /// ```
+    pub fn new(label: &'a str) -> ConsoleTimer<'a> {
+        console::time_with_label(label);
+        ConsoleTimer { label }
+    }
+
+    /// Starts a scoped console time measurement
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use gloo_console_timer::ConsoleTimer;
+    ///
+    /// let value = ConsoleTimer::scope("foo", || {
+    ///     // Code to measure here
+    /// });
+    /// ```
+    pub fn scope<F, T>(label: &str, f: F) -> T
+    where
+        F: FnOnce() -> T,
+    {
+        let _timer = ConsoleTimer::new(label);
+        f()
+    }
+}
+
+impl<'a> Drop for ConsoleTimer<'a> {
+    fn drop(&mut self) {
+        console::time_end_with_label(self.label);
+    }
+}

crates/console-timer/tests/web.rs

@@ -0,0 +1,15 @@
+//! Test suite for the Web and headless browsers.
+
+#![cfg(target_arch = "wasm32")]
+
+use gloo_console_timer::ConsoleTimer;
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+#[wasm_bindgen_test]
+fn scoped_timer_returns_value() {
+    let value = ConsoleTimer::scope("foo", || true);
+
+    assert!(value);
+}

src/lib.rs

@@ -4,4 +4,5 @@
 #![deny(missing_docs, missing_debug_implementations)]
 
 // Re-exports of toolkit crates.
+pub use gloo_console_timer as console_timer;
 pub use gloo_timers as timers;