mirror of
https://github.com/nushell/nushell.git
synced 2024-11-25 09:53:43 +01:00
90d65bb987
<!-- if this PR closes one or more issues, you can automatically link the PR with them by using one of the [*linking keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword), e.g. - this PR should close #xxxx - fixes #xxxx you can also mention related issues, PRs or discussions! --> Closes #11561 # Description <!-- Thank you for improving Nushell. Please, check our [contributing guide](../CONTRIBUTING.md) and talk to the core team before making major changes. Description of your pull request goes here. **Provide examples and/or screenshots** if your changes affect the user experience. --> This PR will allow string interpolation at parse time. Since the actual config hasn't been loaded at parse time, this uses the `get_config()` method on `StateWorkingSet`. So file sizes and datetimes (I think those are the only things whose string representations depend on the config) may be formatted differently from how users have configured things, which may come as a surprise to some. It does seem unlikely that anyone would be formatting file sizes or date times at parse time. Still, something to think about if/before this PR merged. Also, I changed the `ModuleNotFound` error to include the name of the module. # User-Facing Changes <!-- List of all changes that impact the user experience here. This helps us keep track of breaking changes. --> Users will be able to do stuff like: ```nu const x = [1 2 3] const y = $"foo($x)" // foo[1, 2, 3] ``` The main use case is `use`-ing and `source`-ing files at parse time: ```nu const file = "foo.nu" use $"($file)" ``` If the module isn't found, you'll see an error like this: ``` Error: nu::parser::module_not_found × Module not found. ╭─[entry #3:1:1] 1 │ use $"($file)" · ─────┬──── · ╰── module foo.nu not found ╰──── help: module files and their paths must be available before your script is run as parsing occurs before anything is evaluated ``` # Tests + Formatting <!-- Don't forget to add tests that cover your changes. Make sure you've run and fixed any issues with these commands: - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass (on Windows make sure to [enable developer mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging)) - `cargo run -- -c "use std testing; testing run-tests --path crates/nu-std"` to run the tests for the standard library > **Note** > from `nushell` you can also use the `toolkit` as follows > ```bash > use toolkit.nu # or use an `env_change` hook to activate it automatically > toolkit check pr > ``` --> # After Submitting <!-- If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date. --> Although there's user-facing changes, there's probably no need to change the docs since people probably already expect string interpolation to work at parse time. Edit: @kubouch pointed out that we'd need to document the fact that stuff like file sizes and datetimes won't get formatted according to user's runtime configs, so I'll make a PR to nushell.github.io after this one
763 lines
20 KiB
Rust
763 lines
20 KiB
Rust
use nu_test_support::fs::Stub::FileWithContentToBeTrimmed;
|
|
use nu_test_support::playground::Playground;
|
|
use nu_test_support::{nu, nu_repl_code};
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[test]
|
|
fn module_private_import_decl() {
|
|
Playground::setup("module_private_import_decl", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
use spam.nu foo-helper
|
|
|
|
export def foo [] { foo-helper }
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def get-foo [] { "foo" }
|
|
export def foo-helper [] { get-foo }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["use main.nu foo", "foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_private_import_alias() {
|
|
Playground::setup("module_private_import_alias", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
use spam.nu foo-helper
|
|
|
|
export def foo [] { foo-helper }
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export alias foo-helper = echo "foo"
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["use main.nu foo", "foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_private_import_decl_not_public() {
|
|
Playground::setup("module_private_import_decl_not_public", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
use spam.nu foo-helper
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def get-foo [] { "foo" }
|
|
export def foo-helper [] { get-foo }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["use main.nu foo", "foo-helper"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert!(!actual.err.is_empty());
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_public_import_decl() {
|
|
Playground::setup("module_public_import_decl", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export use spam.nu foo
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def foo-helper [] { "foo" }
|
|
export def foo [] { foo-helper }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["use main.nu foo", "foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_public_import_alias() {
|
|
Playground::setup("module_public_import_alias", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export use spam.nu foo
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export alias foo = echo "foo"
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["use main.nu foo", "foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_nested_imports() {
|
|
Playground::setup("module_nested_imports", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export use spam.nu [ foo bar ]
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
"
|
|
export use spam2.nu [ foo bar ]
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam2.nu",
|
|
"
|
|
export use spam3.nu [ foo bar ]
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam3.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
export alias bar = echo "bar"
|
|
"#,
|
|
)]);
|
|
|
|
let inp1 = &["use main.nu foo", "foo"];
|
|
let inp2 = &["use main.nu bar", "bar"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp1.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp2.join("; "));
|
|
assert_eq!(actual.out, "bar");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_nested_imports_in_dirs() {
|
|
Playground::setup("module_nested_imports_in_dirs", |dirs, sandbox| {
|
|
sandbox
|
|
.mkdir("spam")
|
|
.mkdir("spam/spam2")
|
|
.mkdir("spam/spam3")
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export use spam/spam.nu [ foo bar ]
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam.nu",
|
|
"
|
|
export use spam2/spam2.nu [ foo bar ]
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam2/spam2.nu",
|
|
"
|
|
export use ../spam3/spam3.nu [ foo bar ]
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam3/spam3.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
export alias bar = echo "bar"
|
|
"#,
|
|
)]);
|
|
|
|
let inp1 = &["use main.nu foo", "foo"];
|
|
let inp2 = &["use main.nu bar", "bar"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp1.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp2.join("; "));
|
|
assert_eq!(actual.out, "bar");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_public_import_decl_prefixed() {
|
|
Playground::setup("module_public_import_decl", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export use spam.nu
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
def foo-helper [] { "foo" }
|
|
export def foo [] { foo-helper }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["use main.nu", "main spam foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_nested_imports_in_dirs_prefixed() {
|
|
Playground::setup("module_nested_imports_in_dirs", |dirs, sandbox| {
|
|
sandbox
|
|
.mkdir("spam")
|
|
.mkdir("spam/spam2")
|
|
.mkdir("spam/spam3")
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
r#"
|
|
export use spam/spam.nu [ "spam2 foo" "spam2 spam3 bar" ]
|
|
"#,
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam.nu",
|
|
"
|
|
export use spam2/spam2.nu
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam2/spam2.nu",
|
|
"
|
|
export use ../spam3/spam3.nu
|
|
export use ../spam3/spam3.nu foo
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam/spam3/spam3.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
export alias bar = echo "bar"
|
|
"#,
|
|
)]);
|
|
|
|
let inp1 = &["use main.nu", "main spam2 foo"];
|
|
let inp2 = &[r#"use main.nu "spam2 spam3 bar""#, "spam2 spam3 bar"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp1.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp2.join("; "));
|
|
assert_eq!(actual.out, "bar");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_env_1() {
|
|
Playground::setup("module_import_env_1", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export-env { source-env spam.nu }
|
|
|
|
export def foo [] { $env.FOO_HELPER }
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export-env { $env.FOO_HELPER = "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["source-env main.nu", "use main.nu foo", "foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_env_2() {
|
|
Playground::setup("module_import_env_2", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"main.nu",
|
|
"
|
|
export-env { source-env spam.nu }
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export-env { $env.FOO = "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["source-env main.nu", "$env.FOO"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_0() {
|
|
Playground::setup("module_cyclical_imports_0", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
"
|
|
use eggs.nu
|
|
",
|
|
)]);
|
|
|
|
let inp = &["module eggs { use spam.nu }"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert!(actual.err.contains("Module not found"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_1() {
|
|
Playground::setup("module_cyclical_imports_1", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
"
|
|
use spam.nu
|
|
",
|
|
)]);
|
|
|
|
let inp = &["use spam.nu"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert!(actual.err.contains("cyclical"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_2() {
|
|
Playground::setup("module_cyclical_imports_2", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
"
|
|
use eggs.nu
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"eggs.nu",
|
|
"
|
|
use spam.nu
|
|
",
|
|
)]);
|
|
|
|
let inp = &["use spam.nu"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert!(actual.err.contains("cyclical"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_cyclical_imports_3() {
|
|
Playground::setup("module_cyclical_imports_3", |dirs, sandbox| {
|
|
sandbox
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
"
|
|
use eggs.nu
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"eggs.nu",
|
|
"
|
|
use bacon.nu
|
|
",
|
|
)])
|
|
.with_files(vec![FileWithContentToBeTrimmed(
|
|
"bacon.nu",
|
|
"
|
|
use spam.nu
|
|
",
|
|
)]);
|
|
|
|
let inp = &["use spam.nu"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert!(actual.err.contains("cyclical"));
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_const_file() {
|
|
Playground::setup("module_import_const_file", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &["const file = 'spam.nu'", "use $file foo", "foo"];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_import_const_module_name() {
|
|
Playground::setup("module_import_const_file", |dirs, sandbox| {
|
|
sandbox.with_files(vec![FileWithContentToBeTrimmed(
|
|
"spam.nu",
|
|
r#"
|
|
export def foo [] { "foo" }
|
|
"#,
|
|
)]);
|
|
|
|
let inp = &[
|
|
r#"module spam { export def foo [] { "foo" } }"#,
|
|
"const mod = 'spam'",
|
|
"use $mod foo",
|
|
"foo",
|
|
];
|
|
|
|
let actual = nu!(cwd: dirs.test(), &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_def_name() {
|
|
let inp = &[r#"module spam { def spam [] { "spam" } }"#];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_invalid_def_name() {
|
|
let inp = &[r#"module spam { export def spam [] { "spam" } }"#];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_alias_name_1() {
|
|
let inp = &[r#"module spam { alias spam = echo "spam" }"#];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_alias_name_2() {
|
|
let inp = &[r#"module spam { alias main = echo "spam" }"#];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_invalid_alias_name() {
|
|
let inp = &[r#"module spam { export alias spam = echo "spam" }"#];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_main_alias_not_allowed() {
|
|
let inp = &["module spam { export alias main = echo 'spam' }"];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert!(actual.err.contains("export_main_alias_not_allowed"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_valid_known_external_name() {
|
|
let inp = &["module spam { extern spam [] }"];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "");
|
|
}
|
|
|
|
#[test]
|
|
fn module_invalid_known_external_name() {
|
|
let inp = &["module spam { export extern spam [] }"];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn main_inside_module_is_main() {
|
|
let inp = &[
|
|
"module spam {
|
|
export def main [] { 'foo' };
|
|
export def foo [] { main }
|
|
}",
|
|
"use spam foo",
|
|
"foo",
|
|
];
|
|
|
|
let actual = nu!(&inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn module_as_file() {
|
|
let inp = &["module samples/spam.nu", "use spam foo", "foo"];
|
|
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn export_module_as_file() {
|
|
let inp = &["export module samples/spam.nu", "use spam foo", "foo"];
|
|
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn deep_import_patterns() {
|
|
let module_decl = "
|
|
module spam {
|
|
export module eggs {
|
|
export module beans {
|
|
export def foo [] { 'foo' };
|
|
export def bar [] { 'bar' }
|
|
};
|
|
};
|
|
}
|
|
";
|
|
|
|
let inp = &[module_decl, "use spam", "spam eggs beans foo"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[module_decl, "use spam eggs", "eggs beans foo"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[module_decl, "use spam eggs beans", "beans foo"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[module_decl, "use spam eggs beans foo", "foo"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir() {
|
|
let import = "use samples/spam";
|
|
|
|
let inp = &[import, "spam"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual.out, "spam");
|
|
|
|
let inp = &[import, "spam foo"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual.out, "foo");
|
|
|
|
let inp = &[import, "spam bar"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual.out, "bar");
|
|
|
|
let inp = &[import, "spam foo baz"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual.out, "foobaz");
|
|
|
|
let inp = &[import, "spam bar baz"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual.out, "barbaz");
|
|
|
|
let inp = &[import, "spam baz"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual.out, "spambaz");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir_deep() {
|
|
let import = "use samples/spam";
|
|
|
|
let inp = &[import, "spam bacon"];
|
|
let actual_repl = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual_repl.out, "bacon");
|
|
|
|
let inp = &[import, "spam bacon foo"];
|
|
let actual_repl = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual_repl.out, "bacon foo");
|
|
|
|
let inp = &[import, "spam bacon beans"];
|
|
let actual_repl = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual_repl.out, "beans");
|
|
|
|
let inp = &[import, "spam bacon beans foo"];
|
|
let actual_repl = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert_eq!(actual_repl.out, "beans foo");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir_import_twice_no_panic() {
|
|
let import = "use samples/spam";
|
|
let inp = &[import, import, "spam"];
|
|
let actual_repl = nu!(cwd: "tests/modules", nu_repl_code(inp));
|
|
assert_eq!(actual_repl.out, "spam");
|
|
}
|
|
|
|
#[test]
|
|
fn module_dir_missing_mod_nu() {
|
|
let inp = &["use samples/missing_mod_nu"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert!(actual.err.contains("module_missing_mod_nu_file"));
|
|
}
|
|
|
|
#[test]
|
|
fn allowed_local_module() {
|
|
let inp = &["module spam { module spam {} }"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert!(actual.err.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn not_allowed_submodule() {
|
|
let inp = &["module spam { export module spam {} }"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert!(actual.err.contains("named_as_module"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_self_name() {
|
|
let inp = &[
|
|
"module spam { export module mod { export def main [] { 'spam' } } }",
|
|
"use spam",
|
|
"spam",
|
|
];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert_eq!(actual.out, "spam");
|
|
}
|
|
|
|
#[test]
|
|
fn module_self_name_main_not_allowed() {
|
|
let inp = &[
|
|
"module spam {
|
|
export def main [] { 'main spam' };
|
|
|
|
export module mod {
|
|
export def main [] { 'mod spam' }
|
|
}
|
|
}",
|
|
"use spam",
|
|
"spam",
|
|
];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert!(actual.err.contains("module_double_main"));
|
|
|
|
let inp = &[
|
|
"module spam {
|
|
export module mod {
|
|
export def main [] { 'mod spam' }
|
|
};
|
|
|
|
export def main [] { 'main spam' }
|
|
}",
|
|
"use spam",
|
|
"spam",
|
|
];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert!(actual.err.contains("module_double_main"));
|
|
}
|
|
|
|
#[test]
|
|
fn module_main_not_found() {
|
|
let inp = &["module spam {}", "use spam main"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert!(actual.err.contains("export_not_found"));
|
|
|
|
let inp = &["module spam {}", "use spam [ main ]"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert!(actual.err.contains("export_not_found"));
|
|
}
|
|
|
|
#[test]
|
|
fn nested_list_export_works() {
|
|
let module = r#"
|
|
module spam {
|
|
export module eggs {
|
|
export def bacon [] { 'bacon' }
|
|
}
|
|
|
|
export def sausage [] { 'sausage' }
|
|
}
|
|
"#;
|
|
|
|
let inp = &[module, "use spam [sausage eggs]", "eggs bacon"];
|
|
let actual = nu!(&inp.join("; "));
|
|
assert_eq!(actual.out, "bacon");
|
|
}
|