Merge branch 'master' into package-json-files-field

docs/src/commands/build.md

@@ -59,7 +59,7 @@ wasm-pack build --target nodejs
 | Option    | Description                                                                                                     |
 |-----------|-----------------------------------------------------------------------------------------------------------------|
 | `nodejs`  | Outputs JS that uses CommonJS modules, for use with a `require` statement. `main` key in `package.json`. |
-| `nomodules`  | Outputs JS that use no modules. `browser` key in `package.json`. |
+| `no-modules`  | Outputs JS that use no modules. `browser` key in `package.json`. |
 | `browser` | Outputs JS that uses ES6 modules, primarily for use with `import` statements and/or bundlers such as `webpack`. `module` key in `package.json`. `sideEffects: false` by default. |
 
 ## Scope

docs/src/commands/test.md

@@ -0,0 +1,56 @@
+# wasm-pack test
+
+The `wasm-pack test` command wraps the [wasm-bindgen-test-runner](https://rustwasm.github.io/wasm-bindgen/wasm-bindgen-test/index.html)
+CLI allowing you to run wasm tests in different browsers without needing to install the different
+webdrivers yourself.
+
+```
+wasm-pack test --help
+```
+
+## Path
+
+The `wasm-pack test` command can be given an optional path argument.
+
+This path should point to a directory that contains a `Cargo.toml` file. If no
+path is given, the `test` command will run in the current directory.
+
+```
+# Run tests for the current directory's crate
+wasm-pack test
+
+# Run tests for a specified crate
+wasm-pack test crates/crate-in-my-workspace
+```
+
+## Profile
+
+The `test` command accepts an optional profile argument: `--release`.
+
+If none is supplied, then a debug test build will be used.
+
+## Test environment
+
+Choose where to run your tests by passing in any combination of testing environment flags.
+
+`--headless` is useful for running browser tests in a headless browser as part of a CI process.
+
+```
+wasm-pack test --node --firefox --chrome --safari --headless
+```
+
+## Extra options
+
+The `test` command can pass extra options straight to `cargo test` even if they are not
+supported in wasm-pack.
+
+To use them you should add standalone `--` argument at the very
+end of your command, and all the arguments you want to pass to cargo should go after.
+
+Here's an example of running only tests that contain the world "apple".
+
+```
+wasm-pack test --firefox --headless -- --manifest-path=crates/my-workspace-crate/Cargo.toml apple
+```
+
+`cargo test -h` for a list of all options that you can pass through.

src/build.rs

@@ -25,7 +25,7 @@ pub fn check_rustc_version(step: &Step) -> Result<String, Error> {
             } else {
                 Ok(mv.to_string())
             }
-        },
+        }
         None => bail!("We can't figure out what your Rust version is- which means you might not have Rust installed. Please install Rust version 1.30.0 or higher."),
     }
 }
@@ -95,6 +95,9 @@ pub fn cargo_build_wasm(
 }
 
 /// Run `cargo build --tests` targetting `wasm32-unknown-unknown`.
+///
+/// This generates the `Cargo.lock` file that we use in order to know which version of
+/// wasm-bindgen-cli to use when running tests.
 pub fn cargo_build_wasm_tests(path: &Path, debug: bool) -> Result<(), Error> {
     let mut cmd = Command::new("cargo");
     cmd.current_dir(path).arg("build").arg("--tests");

src/command/build.rs

@@ -19,7 +19,7 @@ use std::str::FromStr;
 use std::time::Instant;
 use PBAR;
 
-/// Everything required to configure and run the `wasm-pack init` command.
+/// Everything required to configure and run the `wasm-pack build` command.
 #[allow(missing_docs)]
 pub struct Build {
     pub crate_path: PathBuf,

src/command/test.rs

@@ -78,6 +78,10 @@ pub struct TestOptions {
     #[structopt(long = "release", short = "r")]
     /// Build with the release profile.
     pub release: bool,
+
+    #[structopt(last = true)]
+    /// List of extra options to pass to `cargo test`
+    pub extra_options: Vec<String>,
 }
 
 /// A configured `wasm-pack test` command.
@@ -96,6 +100,7 @@ pub struct Test {
     headless: bool,
     release: bool,
     test_runner_path: Option<PathBuf>,
+    extra_options: Vec<String>,
 }
 
 type TestStep = fn(&mut Test, &Step) -> Result<(), Error>;
@@ -115,6 +120,7 @@ impl Test {
             geckodriver,
             safari,
             safaridriver,
+            extra_options,
         } = test_opts;
 
         let crate_path = set_crate_path(path)?;
@@ -147,6 +153,7 @@ impl Test {
             headless,
             release,
             test_runner_path: None,
+            extra_options,
         })
     }
 
@@ -306,6 +313,7 @@ impl Test {
                 "CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER",
                 &self.test_runner_path.as_ref().unwrap(),
             )),
+            &self.extra_options,
         )?;
         info!("Finished running tests in node.");
         Ok(())
@@ -349,7 +357,7 @@ impl Test {
             envs.push(("NO_HEADLESS", "1"));
         }
 
-        test::cargo_test_wasm(&self.crate_path, self.release, envs)?;
+        test::cargo_test_wasm(&self.crate_path, self.release, envs, &self.extra_options)?;
         Ok(())
     }
 
@@ -391,7 +399,7 @@ impl Test {
             envs.push(("NO_HEADLESS", "1"));
         }
 
-        test::cargo_test_wasm(&self.crate_path, self.release, envs)?;
+        test::cargo_test_wasm(&self.crate_path, self.release, envs, &self.extra_options)?;
         Ok(())
     }
 
@@ -430,7 +438,7 @@ impl Test {
             envs.push(("NO_HEADLESS", "1"));
         }
 
-        test::cargo_test_wasm(&self.crate_path, self.release, envs)?;
+        test::cargo_test_wasm(&self.crate_path, self.release, envs, &self.extra_options)?;
         Ok(())
     }
 }

src/license.rs

@@ -57,8 +57,8 @@ pub fn copy_from_crate(
         "crate's pkg directory should exist"
     );
 
-    match crate_data.crate_license() {
+    match (crate_data.crate_license(), crate_data.crate_license_file()) {
-        Some(_) => {
+        (Some(_), _) => {
             let msg = format!("{}Copying over your LICENSE...", emoji::DANCERS);
             PBAR.step(step, &msg);
             let license_files = glob_license_files(path);
@@ -80,7 +80,14 @@ pub fn copy_from_crate(
                 Err(_) => PBAR.info("origin crate has no LICENSE"),
             }
         }
-        None => {
+        (None, Some(license_file)) => {
+            let crate_license_path = path.join(&license_file);
+            let new_license_path = out_dir.join(&license_file);
+            if fs::copy(&crate_license_path, &new_license_path).is_err() {
+                PBAR.info("origin crate has no LICENSE");
+            }
+        }
+        (None, None) => {
             PBAR.step(step, "No LICENSE found in Cargo.toml, skipping...");
         }
     };

src/manifest/mod.rs

@@ -40,7 +40,10 @@ struct CargoPackage {
     name: String,
     description: Option<String>,
     license: Option<String>,
+    #[serde(rename = "license-file")]
+    license_file: Option<String>,
     repository: Option<String>,
+    homepage: Option<String>,
 
     #[serde(default)]
     metadata: CargoMetadata,
@@ -199,6 +202,7 @@ struct NpmData {
     files: Vec<String>,
     dts_file: Option<String>,
     main: String,
+    homepage: Option<String>, // https://docs.npmjs.com/files/package.json#homepage
 }
 
 #[doc(hidden)]
@@ -349,6 +353,11 @@ impl CrateData {
         &self.manifest.package.license
     }
 
+    /// Get the license file path for the crate at the given path.
+    pub fn crate_license_file(&self) -> &Option<String> {
+        &self.manifest.package.license_file
+    }
+
     /// Returns the path to this project's target directory where artifacts are
     /// located after a cargo build.
     pub fn target_directory(&self) -> &Path {
@@ -440,9 +449,19 @@ impl CrateData {
             dts_file,
             files,
             main: js_file,
+            homepage: self.manifest.package.homepage.clone(),
         }
     }
 
+    fn license(&self) -> Option<String> {
+        self.manifest.package.license.clone().or_else(|| {
+            self.manifest.package.license_file.clone().map(|file| {
+                // When license is written in file: https://docs.npmjs.com/files/package.json#license
+                format!("SEE LICENSE IN {}", file)
+            })
+        })
+    }
+
     fn to_commonjs(&self, scope: &Option<String>, disable_dts: bool, out_dir: &Path) -> NpmPackage {
         let data = self.npm_data(scope, true, disable_dts, out_dir);
         let pkg = &self.data.packages[self.current_idx];
@@ -454,7 +473,7 @@ impl CrateData {
             collaborators: pkg.authors.clone(),
             description: self.manifest.package.description.clone(),
             version: pkg.version.clone(),
-            license: self.manifest.package.license.clone(),
+            license: self.license(),
             repository: self
                 .manifest
                 .package
@@ -466,6 +485,7 @@ impl CrateData {
                 }),
             files: data.files,
             main: data.main,
+            homepage: data.homepage,
             types: data.dts_file,
         })
     }
@@ -486,7 +506,7 @@ impl CrateData {
             collaborators: pkg.authors.clone(),
             description: self.manifest.package.description.clone(),
             version: pkg.version.clone(),
-            license: self.manifest.package.license.clone(),
+            license: self.license(),
             repository: self
                 .manifest
                 .package
@@ -498,6 +518,7 @@ impl CrateData {
                 }),
             files: data.files,
             module: data.main,
+            homepage: data.homepage,
             types: data.dts_file,
             side_effects: "false".to_string(),
         })
@@ -519,7 +540,7 @@ impl CrateData {
             collaborators: pkg.authors.clone(),
             description: self.manifest.package.description.clone(),
             version: pkg.version.clone(),
-            license: self.manifest.package.license.clone(),
+            license: self.license(),
             repository: self
                 .manifest
                 .package
@@ -531,6 +552,7 @@ impl CrateData {
                 }),
             files: data.files,
             browser: data.main,
+            homepage: data.homepage,
             types: data.dts_file,
         })
     }

src/manifest/npm/commonjs.rs

@@ -16,5 +16,7 @@ pub struct CommonJSPackage {
     pub files: Vec<String>,
     pub main: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub homepage: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub types: Option<String>,
 }

src/manifest/npm/esmodules.rs

@@ -16,6 +16,8 @@ pub struct ESModulesPackage {
     pub files: Vec<String>,
     pub module: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub homepage: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub types: Option<String>,
     #[serde(rename = "sideEffects")]
     pub side_effects: String,

src/manifest/npm/nomodules.rs

@@ -16,5 +16,7 @@ pub struct NoModulesPackage {
     pub files: Vec<String>,
     pub browser: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub homepage: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub types: Option<String>,
 }

src/test/mod.rs

@@ -10,7 +10,12 @@ use std::process::Command;
 
 /// Run `cargo test` with the `nightly` toolchain and targeting
 /// `wasm32-unknown-unknown`.
-pub fn cargo_test_wasm<I, K, V>(path: &Path, release: bool, envs: I) -> Result<(), failure::Error>
+pub fn cargo_test_wasm<I, K, V>(
+    path: &Path,
+    release: bool,
+    envs: I,
+    extra_options: &[String],
+) -> Result<(), failure::Error>
 where
     I: IntoIterator<Item = (K, V)>,
     K: AsRef<OsStr>,
@@ -23,6 +28,7 @@ where
         cmd.arg("--release");
     }
     cmd.arg("--target").arg("wasm32-unknown-unknown");
+    cmd.args(extra_options);
     child::run(cmd, "cargo test").context("Running Wasm tests with wasm-bindgen-test failed")?;
 
     // NB: `child::run` took care of ensuring that test output gets printed.

tests/all/license.rs

@@ -34,7 +34,7 @@ fn it_copies_a_license_default_path() {
 }
 
 #[test]
-fn it_copies_a_license_provied_path() {
+fn it_copies_a_license_provided_path() {
     let fixture = fixture::single_license();
     let out_dir = fixture.path.join("pkg");
     fs::create_dir(&out_dir).expect("should create pkg directory OK");
@@ -128,3 +128,30 @@ fn it_copies_all_licenses_provided_path() {
     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_a_non_standard_license_provided_path() {
+    let license_file = "NON-STANDARD-LICENSE";
+    let fixture = fixture::non_standard_license(license_file);
+    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_file);
+    let pkg_license_path = out_dir.join(license_file);
+    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);
+}

tests/all/manifest.rs

@@ -279,6 +279,63 @@ fn it_errors_when_wasm_bindgen_is_not_declared() {
     assert!(crate_data.check_crate_config(&step).is_err());
 }
 
+#[test]
+fn it_sets_homepage_field_if_available_in_cargo_toml() {
+    // When 'homepage' is available
+    let fixture = utils::fixture::Fixture::new();
+    fixture.hello_world_src_lib().file(
+        "Cargo.toml",
+        r#"
+            [package]
+            authors = ["The wasm-pack developers"]
+            description = "so awesome rust+wasm package"
+            license = "WTFPL"
+            name = "homepage-field-test"
+            repository = "https://github.com/rustwasm/wasm-pack.git"
+            version = "0.1.0"
+            homepage = "https://rustwasm.github.io/wasm-pack/"
+
+            [lib]
+            crate-type = ["cdylib"]
+
+            [dependencies]
+            wasm-bindgen = "=0.2"
+
+            [dev-dependencies]
+            wasm-bindgen-test = "=0.2"
+        "#,
+    );
+
+    let out_dir = fixture.path.join("pkg");
+    let crate_data = manifest::CrateData::new(&fixture.path).unwrap();
+
+    let step = wasm_pack::progressbar::Step::new(2);
+    wasm_pack::command::utils::create_pkg_dir(&out_dir, &step).unwrap();
+    crate_data
+        .write_package_json(&out_dir, &None, true, "", &step)
+        .unwrap();
+
+    let pkg = utils::manifest::read_package_json(&fixture.path, &out_dir).unwrap();
+    assert_eq!(
+        pkg.homepage,
+        Some("https://rustwasm.github.io/wasm-pack/".to_string()),
+    );
+
+    // When 'homepage' is unavailable
+    let fixture = fixture::js_hello_world();
+    let out_dir = fixture.path.join("pkg");
+    let crate_data = manifest::CrateData::new(&fixture.path).unwrap();
+
+    let step = wasm_pack::progressbar::Step::new(2);
+    wasm_pack::command::utils::create_pkg_dir(&out_dir, &step).unwrap();
+    crate_data
+        .write_package_json(&out_dir, &None, true, "", &step)
+        .unwrap();
+
+    let pkg = utils::manifest::read_package_json(&fixture.path, &out_dir).unwrap();
+    assert_eq!(pkg.homepage, None);
+}
+
 #[test]
 fn it_does_not_error_when_wasm_bindgen_is_declared() {
     let fixture = fixture::js_hello_world();

tests/all/utils/fixture.rs

@@ -137,6 +137,39 @@ impl Fixture {
         )
     }
 
+    /// Add a `Cargo.toml` with a correctly configured `wasm-bindgen`
+    /// dependency, `wasm-bindgen-test` dev-dependency, and `crate-type =
+    /// ["cdylib"]`.
+    ///
+    /// `name` is the crate's name.
+    /// `license_file` is license file path
+    pub fn cargo_toml_with_license_file(&self, name: &str, license_file: &str) -> &Self {
+        self.file(
+            "Cargo.toml",
+            &format!(
+                r#"
+                    [package]
+                    authors = ["The wasm-pack developers"]
+                    description = "so awesome rust+wasm package"
+                    name = "{}"
+                    license-file = "{}"
+                    repository = "https://github.com/rustwasm/wasm-pack.git"
+                    version = "0.1.0"
+
+                    [lib]
+                    crate-type = ["cdylib"]
+
+                    [dependencies]
+                    wasm-bindgen = "=0.2.21"
+
+                    [dev-dependencies]
+                    wasm-bindgen-test = "=0.2.21"
+                "#,
+                name, license_file
+            ),
+        )
+    }
+
     /// Add a `src/lib.rs` file that contains a "hello world" program.
     pub fn hello_world_src_lib(&self) -> &Self {
         self.file(
@@ -661,3 +694,13 @@ pub fn dual_license() -> Fixture {
         .hello_world_src_lib();
     fixture
 }
+
+pub fn non_standard_license(license_file: &str) -> Fixture {
+    let fixture = Fixture::new();
+    fixture
+        .readme()
+        .cargo_toml_with_license_file("dual_license", license_file)
+        .file(license_file, "license file for test")
+        .hello_world_src_lib();
+    fixture
+}

tests/all/utils/manifest.rs

@@ -23,6 +23,7 @@ pub struct NpmPackage {
     pub types: String,
     #[serde(default = "default_none", rename = "sideEffects")]
     pub side_effects: String,
+    pub homepage: Option<String>,
 }
 
 fn default_none() -> String {