Initial commit! 🎉

Author: fitzgen

.gitattributes

@@ -0,0 +1 @@
+README.md -diff

.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

.travis.yml

@@ -0,0 +1,10 @@
+language: rust
+cache: cargo
+
+rust:
+  - nightly
+
+script:
+  - cargo test
+  - rustup target add wasm32-unknown-unknown --toolchain nightly
+  - cargo build --target wasm32-unknown-unknown

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+authors = ["Nick Fitzgerald <fitzgen@gmail.com>"]
+categories = ["wasm"]
+description = "A panic hook for `wasm32-unknown-unknown` that logs panics to `console.error`"
+license = "Apache-2.0/MIT"
+name = "console_error_panic_hook"
+readme = "./README.md"
+repository = "https://github.com/rustwasm/console_error_panic_hook"
+version = "0.1.0"
+
+[badges]
+travis-ci = { repository = "rustwasm/console_error_panic_hook" }
+
+[dependencies]
+cfg-if = "0.1.3"
+wasm-bindgen = "0.2.10"

README.md

@@ -0,0 +1,51 @@
+# console_error_panic_hook
+
+## `console_error_panic_hook`
+
+[![Build Status](https://travis-ci.org/rustwasm/console_error_panic_hook.svg?branch=master)](https://travis-ci.org/rustwasm/console_error_panic_hook)
+
+This crate lets you debug panics on `wasm32-unknown-unknown` by providing a
+panic hook that forwards panic messages to
+[`console.error`](https://developer.mozilla.org/en-US/docs/Web/API/Console/error).
+
+When an error is reported with `console.error`, browser devtools and node.js
+will typically capture a stack trace and display it with the logged error
+message.
+
+### Usage
+
+There are two ways to install this panic hook.
+
+First, you can set the hook yourself by calling `std::panic::set_hook` in
+some initialization function:
+
+```rust
+extern crate console_error_panic_hook;
+use std::panic;
+
+fn my_init_function() {
+    panic::set_hook(Box::new(console_error_panic_hook::hook));
+
+    // ...
+}
+```
+
+Alternatively, use `set_once` on some common code path to ensure that
+`set_hook` is called, but only the one time. Under the hood, this uses
+`std::sync::Once`.
+
+```rust
+extern crate console_error_panic_hook;
+
+struct MyBigThing;
+
+impl MyBigThing {
+    pub fn new() -> MyBigThing {
+        console_error_panic_hook::set_once();
+
+        MyBigThing
+    }
+}
+```
+
+License: Apache-2.0/MIT

src/lib.rs

@@ -0,0 +1,97 @@
+//! # `console_error_panic_hook`
+//!
+//! [![Build Status](https://travis-ci.org/rustwasm/console_error_panic_hook.svg?branch=master)](https://travis-ci.org/rustwasm/console_error_panic_hook)
+//!
+//! This crate lets you debug panics on `wasm32-unknown-unknown` by providing a
+//! panic hook that forwards panic messages to
+//! [`console.error`](https://developer.mozilla.org/en-US/docs/Web/API/Console/error).
+//!
+//! When an error is reported with `console.error`, browser devtools and node.js
+//! will typically capture a stack trace and display it with the logged error
+//! message.
+//!
+//! ## Usage
+//!
+//! There are two ways to install this panic hook.
+//!
+//! First, you can set the hook yourself by calling `std::panic::set_hook` in
+//! some initialization function:
+//!
+//! ```
+//! extern crate console_error_panic_hook;
+//! use std::panic;
+//!
+//! fn my_init_function() {
+//!     panic::set_hook(Box::new(console_error_panic_hook::hook));
+//!
+//!     // ...
+//! }
+//! ```
+//!
+//! Alternatively, use `set_once` on some common code path to ensure that
+//! `set_hook` is called, but only the one time. Under the hood, this uses
+//! `std::sync::Once`.
+//!
+//! ```
+//! extern crate console_error_panic_hook;
+//!
+//! struct MyBigThing;
+//!
+//! impl MyBigThing {
+//!     pub fn new() -> MyBigThing {
+//!         console_error_panic_hook::set_once();
+//!
+//!         MyBigThing
+//!     }
+//! }
+//! ```
+
+#![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+
+#[macro_use]
+extern crate cfg_if;
+
+use std::panic;
+
+cfg_if! {
+    if #[cfg(target_arch = "wasm32")] {
+        extern crate wasm_bindgen;
+        use wasm_bindgen::prelude::*;
+
+        #[wasm_bindgen]
+        extern {
+            #[wasm_bindgen(js_namespace = console)]
+            fn error(msg: String);
+        }
+
+        fn hook_impl(info: &panic::PanicInfo) {
+            error(info.to_string());
+        }
+    } else {
+        use std::io::{self, Write};
+
+        fn hook_impl(info: &panic::PanicInfo) {
+            let _ = writeln!(io::stderr(), "{}", info);
+        }
+    }
+}
+
+/// A panic hook for use with
+/// [`std::panic::set_hook`](https://doc.rust-lang.org/nightly/std/panic/fn.set_hook.html)
+/// that logs panics into
+/// [`console.error`](https://developer.mozilla.org/en-US/docs/Web/API/Console/error).
+///
+/// On non-wasm targets, prints the panic to `stderr`.
+pub fn hook(info: &panic::PanicInfo) {
+    hook_impl(info);
+}
+
+/// Set the `console.error` panic hook the first time this is called. Subsequent
+/// invocations do nothing.
+pub fn set_once() {
+    use std::sync::{ONCE_INIT, Once};
+    static SET_HOOK: Once = ONCE_INIT;
+    SET_HOOK.call_once(|| {
+        panic::set_hook(Box::new(hook));
+    });
+}

tests/tests.rs

@@ -0,0 +1,48 @@
+extern crate console_error_panic_hook;
+
+use std::fs::File;
+use std::io::Read;
+use std::panic;
+use std::process::Command;
+
+#[test]
+fn cargo_readme_up_to_date() {
+    println!("Checking that `cargo readme > README.md` is up to date...");
+
+    let output = Command::new("cargo")
+        .arg("readme")
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .output()
+        .expect("should run `cargo readme` OK");
+
+    assert!(
+        output.status.success(),
+        "Check if you have `cargo-readme` in $PATH"
+    );
+    let expected = String::from_utf8_lossy(&output.stdout);
+
+    let actual = {
+        let mut file = File::open(concat!(env!("CARGO_MANIFEST_DIR"), "/README.md"))
+            .expect("should open README.md file");
+        let mut s = String::new();
+        file.read_to_string(&mut s)
+            .expect("should read contents of file to string");
+        s
+    };
+
+    if actual != expected {
+        panic!("Run `cargo readme > README.md` to update README.md");
+    }
+}
+
+#[test]
+fn can_set_as_hook() {
+    panic::set_hook(Box::new(console_error_panic_hook::hook));
+}
+
+#[test]
+fn can_set_once() {
+    for _ in 0..10 {
+        console_error_panic_hook::set_once();
+    }
+}