Merge branch 'master' into refactor-binary-installation

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,12 +1,10 @@
 Make sure these boxes are checked! 📦✅
 
-- [ ] You have the latest version of `rustfmt` installed and have your 
+- [ ] You have the latest version of `rustfmt` installed
-      cloned directory set to nightly
 ```bash
-$ rustup override set nightly
 $ rustup component add rustfmt-preview --toolchain nightly
 ```
-- [ ] You ran `rustfmt` on the code base before submitting
+- [ ] You ran `cargo fmt` on the code base before submitting
 - [ ] You reference which issue is being closed in the PR text
 
 ✨✨ 😄 Thanks so much for contributing to wasm-pack! 😄 ✨✨

Cargo.toml

@@ -15,16 +15,19 @@ cargo_metadata = "0.6.0"
 console = "0.6.1"
 failure = "0.1.2"
 human-panic = "1.0.1"
+glob = "0.2"
 indicatif = "0.9.0"
 lazy_static = "1.1.0"
 openssl = { version = '0.10.11', optional = true }
 parking_lot = "0.6"
 serde = "1.0.74"
 serde_derive = "1.0.74"
+serde_ignored = "0.0.4"
 serde_json = "1.0.26"
 slog = "2.3"
 slog-term = "2.4"
 slog-async = "2.3"
+strsim = "0.8.0"
 structopt = "0.2"
 toml = "0.4"
 which = "2.0.0"

binary-install/Cargo.toml

@@ -10,4 +10,4 @@ flate2 = "1.0.2"
 hex = "0.3"
 siphasher = "0.2.3"
 tar = "0.4.16"
-zip = "0.4.2"
+zip = "0.5.0"

docs/src/tutorial/getting-started.md

@@ -25,4 +25,4 @@ further in this guide.
 ⚠️ If you'd rather not use a template, or are having trouble with the template, you can
 do a manual setup by following [these instructions].
 
-[these instructions]: ../project-setup/manual-setup/index.html
+[these instructions]: ../project-setup/manual-setup.html

src/command/build.rs

@@ -6,6 +6,7 @@ use command::utils::{create_pkg_dir, set_crate_path};
 use emoji;
 use failure::Error;
 use indicatif::HumanDuration;
+use license;
 use lockfile::Lockfile;
 use manifest;
 use progressbar::Step;
@@ -209,6 +210,7 @@ impl Build {
                 step_create_dir,
                 step_create_json,
                 step_copy_readme,
+                step_copy_license,
                 step_install_wasm_bindgen,
                 step_run_wasm_bindgen,
             ],
@@ -219,6 +221,7 @@ impl Build {
                 step_create_dir,
                 step_create_json,
                 step_copy_readme,
+                step_copy_license,
                 step_run_wasm_bindgen
             ],
             BuildMode::Force => steps![
@@ -226,6 +229,7 @@ impl Build {
                 step_create_dir,
                 step_create_json,
                 step_copy_readme,
+                step_copy_license,
                 step_run_wasm_bindgen
             ],
         }
@@ -300,7 +304,18 @@ impl Build {
         Ok(())
     }
 
-    fn step_install_wasm_bindgen(&mut self, step: &Step, log: &Logger) -> Result<(), Error> {
+    fn step_copy_license(&mut self, step: &Step, log: &Logger) -> Result<(), failure::Error> {
+        info!(&log, "Copying license from crate...");
+        license::copy_from_crate(&self.crate_data, &self.crate_path, &self.out_dir, step)?;
+        info!(&log, "Copied license from crate to {:#?}.", &self.out_dir);
+        Ok(())
+    }
+
+    fn step_install_wasm_bindgen(
+        &mut self,
+        step: &Step,
+        log: &Logger,
+    ) -> Result<(), failure::Error> {
         info!(&log, "Identifying wasm-bindgen dependency...");
         let lockfile = Lockfile::new(&self.crate_data)?;
         let bindgen_version = lockfile.require_wasm_bindgen()?;

src/command/utils.rs

@@ -18,6 +18,7 @@ pub fn create_pkg_dir(out_dir: &Path, step: &Step) -> Result<(), failure::Error>
     let msg = format!("{}Creating a pkg directory...", emoji::FOLDER);
     PBAR.step(step, &msg);
     fs::create_dir_all(&out_dir)?;
+    fs::write(out_dir.join(".gitignore"), "*")?;
     Ok(())
 }
 

src/lib.rs

@@ -4,8 +4,10 @@
 
 extern crate cargo_metadata;
 extern crate console;
+extern crate strsim;
 #[macro_use]
 extern crate failure;
+extern crate glob;
 extern crate indicatif;
 extern crate which;
 #[macro_use]
@@ -14,6 +16,7 @@ extern crate parking_lot;
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;
+extern crate serde_ignored;
 extern crate serde_json;
 #[macro_use]
 extern crate structopt;
@@ -29,6 +32,7 @@ pub mod build;
 pub mod child;
 pub mod command;
 pub mod emoji;
+pub mod license;
 pub mod lockfile;
 pub mod logger;
 pub mod manifest;

src/license.rs

@@ -0,0 +1,74 @@
+//! Copy `LICENSE` file(s) for the packaged wasm.
+
+use failure;
+use std::fs;
+use std::path::Path;
+
+use emoji;
+use glob::glob;
+use manifest::CrateData;
+use progressbar::Step;
+use PBAR;
+
+fn glob_license_files(path: &Path) -> Result<Vec<String>, failure::Error> {
+    let mut license_files: Vec<String> = Vec::new();
+    for entry in glob(path.join("LICENSE*").to_str().unwrap())? {
+        match entry {
+            Ok(globed_path) => {
+                license_files.push(String::from(
+                    globed_path.file_name().unwrap().to_str().unwrap(),
+                ));
+            }
+            Err(e) => println!("{:?}", e),
+        }
+    }
+    Ok(license_files)
+}
+
+/// Copy the crate's license into the `pkg` directory.
+pub fn copy_from_crate(
+    crate_data: &CrateData,
+    path: &Path,
+    out_dir: &Path,
+    step: &Step,
+) -> Result<(), failure::Error> {
+    assert!(
+        fs::metadata(path).ok().map_or(false, |m| m.is_dir()),
+        "crate directory should exist"
+    );
+
+    assert!(
+        fs::metadata(&out_dir).ok().map_or(false, |m| m.is_dir()),
+        "crate's pkg directory should exist"
+    );
+
+    match crate_data.crate_license() {
+        Some(_) => {
+            let msg = format!("{}Copying over your LICENSE...", emoji::DANCERS);
+            PBAR.step(step, &msg);
+            let license_files = glob_license_files(path);
+
+            match license_files {
+                Ok(files) => {
+                    if files.len() == 0 {
+                        PBAR.info("License key is set in Cargo.toml but no LICENSE file(s) were found; Please add the LICENSE file(s) to your project directory");
+                        return Ok(());
+                    }
+                    for license_file in files {
+                        let crate_license_path = path.join(&license_file);
+                        let new_license_path = out_dir.join(&license_file);
+                        if let Err(_) = fs::copy(&crate_license_path, &new_license_path) {
+                            PBAR.info("origin crate has no LICENSE");
+                        }
+                    }
+                }
+                Err(_) => PBAR.info("origin crate has no LICENSE"),
+            }
+        }
+        None => {
+            PBAR.step(step, "No LICENSE found in Cargo.toml, skipping...");
+        }
+    };
+
+    Ok(())
+}

src/manifest/mod.rs

@@ -15,9 +15,13 @@ use failure::{Error, ResultExt};
 use progressbar::Step;
 use serde::{self, Deserialize};
 use serde_json;
+use std::collections::BTreeSet;
+use strsim::levenshtein;
 use toml;
 use PBAR;
 
+const WASM_PACK_METADATA_KEY: &'static str = "package.metadata.wasm-pack";
+
 /// Store for metadata learned about a crate
 pub struct CrateData {
     data: Metadata,
@@ -25,8 +29,9 @@ pub struct CrateData {
     manifest: CargoManifest,
 }
 
+#[doc(hidden)]
 #[derive(Deserialize)]
-struct CargoManifest {
+pub struct CargoManifest {
     package: CargoPackage,
 }
 
@@ -196,6 +201,12 @@ struct NpmData {
     main: String,
 }
 
+#[doc(hidden)]
+pub struct ManifestAndUnsedKeys {
+    pub manifest: CargoManifest,
+    pub unused_keys: BTreeSet<String>,
+}
+
 impl CrateData {
     /// Reads all metadata for the crate whose manifest is inside the directory
     /// specified by `path`.
@@ -208,14 +219,14 @@ impl CrateData {
                 crate_path.display()
             )
         }
-        let manifest = fs::read_to_string(&manifest_path)
-            .with_context(|_| format!("failed to read: {}", manifest_path.display()))?;
-        let manifest: CargoManifest = toml::from_str(&manifest)
-            .with_context(|_| format!("failed to parse manifest: {}", manifest_path.display()))?;
 
         let data =
             cargo_metadata::metadata(Some(&manifest_path)).map_err(error_chain_to_failure)?;
 
+        let manifest_and_keys = CrateData::parse_crate_data(&manifest_path)?;
+        CrateData::warn_for_unused_keys(&manifest_and_keys);
+
+        let manifest = manifest_and_keys.manifest;
         let current_idx = data
             .packages
             .iter()
@@ -241,6 +252,50 @@ impl CrateData {
         }
     }
 
+    /// Read the `manifest_path` file and deserializes it using the toml Deserializer.
+    /// Returns a Result containing `ManifestAndUnsedKeys` which contains `CargoManifest`
+    /// and a `BTreeSet<String>` containing the unused keys from the parsed file.
+    ///
+    /// # Errors
+    /// Will return Err if the file (manifest_path) couldn't be read or
+    /// if deserialize to `CargoManifest` fails.
+    pub fn parse_crate_data(manifest_path: &Path) -> Result<ManifestAndUnsedKeys, Error> {
+        let manifest = fs::read_to_string(&manifest_path)
+            .with_context(|_| format!("failed to read: {}", manifest_path.display()))?;
+        let manifest = &mut toml::Deserializer::new(&manifest);
+
+        let mut unused_keys = BTreeSet::new();
+        let levenshtein_threshold = 1;
+
+        let manifest: CargoManifest = serde_ignored::deserialize(manifest, |path| {
+            let path_string = path.to_string();
+
+            if path_string.starts_with("package.metadata")
+                && (path_string.contains("wasm-pack")
+                    || levenshtein(WASM_PACK_METADATA_KEY, &path_string) <= levenshtein_threshold)
+            {
+                unused_keys.insert(path_string);
+            }
+        })
+        .with_context(|_| format!("failed to parse manifest: {}", manifest_path.display()))?;
+
+        Ok(ManifestAndUnsedKeys {
+            manifest,
+            unused_keys,
+        })
+    }
+
+    /// Iterating through all the passed `unused_keys` and output
+    /// a warning for each unknown key.
+    pub fn warn_for_unused_keys(manifest_and_keys: &ManifestAndUnsedKeys) {
+        manifest_and_keys.unused_keys.iter().for_each(|path| {
+            PBAR.warn(&format!(
+                "\"{}\" is a unknown key and will be ignored. Please check your Cargo.toml.",
+                path
+            ));
+        });
+    }
+
     /// Get the configured profile.
     pub fn configured_profile(&self, profile: BuildProfile) -> &CargoWasmPackProfile {
         match profile {
@@ -289,6 +344,11 @@ impl CrateData {
         }
     }
 
+    /// Get the license for the crate at the given path.
+    pub fn crate_license(&self) -> &Option<String> {
+        &self.manifest.package.license
+    }
+
     /// Returns the path to this project's target directory where artifacts are
     /// located after a cargo build.
     pub fn target_directory(&self) -> &Path {

tests/all/license.rs

@@ -0,0 +1,130 @@
+extern crate failure;
+extern crate wasm_pack;
+
+use std::fs;
+
+use utils::{self, fixture};
+use wasm_pack::license;
+use wasm_pack::manifest::CrateData;
+
+#[test]
+fn it_copies_a_license_default_path() {
+    let fixture = fixture::single_license();
+    let out_dir = fixture.path.join("pkg");
+    fs::create_dir(&out_dir).expect("should create pkg directory OK");
+    let crate_data = CrateData::new(&fixture.path);
+
+    let step = wasm_pack::progressbar::Step::new(1);
+    assert!(license::copy_from_crate(&crate_data.unwrap(), &fixture.path, &out_dir, &step).is_ok());
+
+    let crate_license_path = fixture.path.join("LICENSE-WTFPL");
+    let pkg_license_path = out_dir.join("LICENSE-WTFPL");
+    println!(
+        "wasm-pack: should have copied LICENSE from '{}' to '{}'",
+        crate_license_path.display(),
+        pkg_license_path.display()
+    );
+    assert!(fs::metadata(&crate_license_path).is_ok());
+
+    assert!(fs::metadata(&pkg_license_path).is_ok());
+
+    let crate_license = utils::file::read_file(&crate_license_path).unwrap();
+    let pkg_license = utils::file::read_file(&pkg_license_path).unwrap();
+    assert_eq!(crate_license, pkg_license);
+}
+
+#[test]
+fn it_copies_a_license_provied_path() {
+    let fixture = fixture::single_license();
+    let out_dir = fixture.path.join("pkg");
+    fs::create_dir(&out_dir).expect("should create pkg directory OK");
+    let crate_data = CrateData::new(&fixture.path);
+
+    let step = wasm_pack::progressbar::Step::new(1);
+    assert!(license::copy_from_crate(&crate_data.unwrap(), &fixture.path, &out_dir, &step).is_ok());
+    let crate_license_path = fixture.path.join("LICENSE-WTFPL");
+    let pkg_license_path = out_dir.join("LICENSE-WTFPL");
+    println!(
+        "wasm-pack: should have copied LICENSE-WTFPL from '{}' to '{}'",
+        crate_license_path.display(),
+        pkg_license_path.display()
+    );
+    assert!(fs::metadata(&crate_license_path).is_ok());
+    assert!(fs::metadata(&pkg_license_path).is_ok());
+
+    let crate_license = utils::file::read_file(&crate_license_path).unwrap();
+    let pkg_license = utils::file::read_file(&pkg_license_path).unwrap();
+    assert_eq!(crate_license, pkg_license);
+}
+
+#[test]
+fn it_copies_all_licenses_default_path() {
+    let fixture = fixture::dual_license();
+    let out_dir = fixture.path.join("pkg");
+    fs::create_dir(&out_dir).expect("should create pkg directory OK");
+    let crate_data = CrateData::new(&fixture.path);
+
+    let step = wasm_pack::progressbar::Step::new(1);
+    assert!(license::copy_from_crate(&crate_data.unwrap(), &fixture.path, &out_dir, &step).is_ok());
+
+    let crate_license_path = fixture.path.join("LICENSE-WTFPL");
+    let pkg_license_path = out_dir.join("LICENSE-WTFPL");
+
+    let crate_license_path_2 = fixture.path.join("LICENSE-MIT");
+    let pkg_license_path_2 = out_dir.join("LICENSE-MIT");
+
+    println!(
+        "wasm-pack: should have copied LICENSE from '{}' to '{}'",
+        crate_license_path.display(),
+        pkg_license_path.display()
+    );
+    assert!(fs::metadata(&crate_license_path).is_ok());
+    assert!(fs::metadata(&pkg_license_path).is_ok());
+
+    assert!(fs::metadata(&crate_license_path_2).is_ok());
+    assert!(fs::metadata(&pkg_license_path_2).is_ok());
+
+    let crate_license = utils::file::read_file(&crate_license_path).unwrap();
+    let pkg_license = utils::file::read_file(&pkg_license_path).unwrap();
+    assert_eq!(crate_license, pkg_license);
+
+    let crate_license_2 = utils::file::read_file(&crate_license_path_2).unwrap();
+    let pkg_license_2 = utils::file::read_file(&pkg_license_path_2).unwrap();
+    assert_eq!(crate_license_2, pkg_license_2);
+}
+
+#[test]
+fn it_copies_all_licenses_provided_path() {
+    let fixture = fixture::dual_license();
+    let out_dir = fixture.path.join("pkg");
+    fs::create_dir(&out_dir).expect("should create pkg directory OK");
+    let crate_data = CrateData::new(&fixture.path);
+
+    let step = wasm_pack::progressbar::Step::new(1);
+    assert!(license::copy_from_crate(&crate_data.unwrap(), &fixture.path, &out_dir, &step).is_ok());
+
+    let crate_license_path = fixture.path.join("LICENSE-WTFPL");
+    let pkg_license_path = out_dir.join("LICENSE-WTFPL");
+
+    let crate_license_path_2 = fixture.path.join("LICENSE-MIT");
+    let pkg_license_path_2 = out_dir.join("LICENSE-MIT");
+
+    println!(
+        "wasm-pack: should have copied LICENSE from '{}' to '{}'",
+        crate_license_path.display(),
+        pkg_license_path.display()
+    );
+    assert!(fs::metadata(&crate_license_path).is_ok());
+    assert!(fs::metadata(&pkg_license_path).is_ok());
+
+    assert!(fs::metadata(&crate_license_path_2).is_ok());
+    assert!(fs::metadata(&pkg_license_path_2).is_ok());
+
+    let crate_license = utils::file::read_file(&crate_license_path).unwrap();
+    let pkg_license = utils::file::read_file(&pkg_license_path).unwrap();
+    assert_eq!(crate_license, pkg_license);
+
+    let crate_license_2 = utils::file::read_file(&crate_license_path_2).unwrap();
+    let pkg_license_2 = utils::file::read_file(&pkg_license_path_2).unwrap();
+    assert_eq!(crate_license_2, pkg_license_2);
+}

tests/all/main.rs

@@ -13,6 +13,7 @@ extern crate wasm_pack_binary_install;
 
 mod bindgen;
 mod build;
+mod license;
 mod lockfile;
 mod manifest;
 mod readme;

tests/all/manifest.rs

@@ -292,11 +292,9 @@ fn it_does_not_error_when_wasm_bindgen_is_declared() {
 #[test]
 fn configure_wasm_bindgen_debug_incorrectly_is_error() {
     let fixture = utils::fixture::Fixture::new();
-    fixture
+    fixture.readme().hello_world_src_lib().file(
-        .readme()
+        "Cargo.toml",
-        .file(
+        r#"
-            "Cargo.toml",
-            r#"
             [package]
             authors = ["The wasm-pack developers"]
             description = "so awesome rust+wasm package"
@@ -314,8 +312,7 @@ fn configure_wasm_bindgen_debug_incorrectly_is_error() {
             [package.metadata.wasm-pack.profile.dev.wasm-bindgen]
             debug-js-glue = "not a boolean"
             "#,
-        )
+    );
-        .hello_world_src_lib();
 
     let cli = Cli::from_iter_safe(vec![
         "wasm-pack",
@@ -333,3 +330,41 @@ fn configure_wasm_bindgen_debug_incorrectly_is_error() {
         .to_string()
         .contains("package.metadata.wasm-pack.profile.dev.wasm-bindgen.debug")));
 }
+
+#[test]
+fn parse_crate_data_returns_unused_keys_in_cargo_toml() {
+    let fixture = utils::fixture::Fixture::new();
+    fixture
+        .readme()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            authors = ["The wasm-pack developers"]
+            description = "so awesome rust+wasm package"
+            license = "WTFPL"
+            name = "whatever"
+            repository = "https://github.com/rustwasm/wasm-pack.git"
+            version = "0.1.0"
+
+            [lib]
+            crate-type = ["cdylib"]
+
+            [dependencies]
+            wasm-bindgen = "0.2"
+
+            # Note: production is not valid.
+            [package.metadata.wasm-pack.profile.production.wasm-bindgen]
+            debug-js-glue = true
+            "#,
+        )
+        .hello_world_src_lib();
+
+    let result = manifest::CrateData::parse_crate_data(&fixture.path.join("Cargo.toml"));
+
+    assert!(result.is_ok());
+
+    let manifest::ManifestAndUnsedKeys { unused_keys, .. } = result.unwrap();
+
+    assert!(unused_keys.contains("package.metadata.wasm-pack.profile.production"));
+}

tests/all/utils/fixture.rs

@@ -68,6 +68,44 @@ impl Fixture {
         )
     }
 
+    /// Add `WTFPL LICENSE` file to the fixture.
+    pub fn wtfpl_license(&self) -> &Self {
+        self.file(
+            "LICENSE-WTFPL",
+            r#"
+                DO WHATEVER YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+                Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+                Everyone is permitted to copy and distribute verbatim or modified
+                copies of this license document, and changing it is allowed as long
+                as the name is changed.
+
+                DO WHATEVER YOU WANT TO PUBLIC LICENSE
+                TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+                0. You just DO WHATEVER YOU WANT TO.
+            "#,
+        )
+    }
+
+    /// Add `MIT LICENSE` file to the fixture.
+    pub fn mit_license(&self) -> &Self {
+        self.file(
+            "LICENSE-MIT",
+            r#"
+                Copyright <YEAR> <COPYRIGHT HOLDER>
+
+                Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+                The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+                THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+            "#,
+        )
+    }
+
     /// Add a `Cargo.toml` with a correctly configured `wasm-bindgen`
     /// dependency, `wasm-bindgen-test` dev-dependency, and `crate-type =
     /// ["cdylib"]`.
@@ -590,3 +628,24 @@ pub fn transitive_dependencies() -> Fixture {
     project_main_fixture(&mut fixture);
     fixture
 }
+
+pub fn single_license() -> Fixture {
+    let fixture = Fixture::new();
+    fixture
+        .readme()
+        .cargo_toml("single_license")
+        .wtfpl_license()
+        .hello_world_src_lib();
+    fixture
+}
+
+pub fn dual_license() -> Fixture {
+    let fixture = Fixture::new();
+    fixture
+        .readme()
+        .cargo_toml("dual_license")
+        .wtfpl_license()
+        .mit_license()
+        .hello_world_src_lib();
+    fixture
+}