forked from extern/nushell
3148acd3a4
<!-- 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! --> # 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. --> https://github.com/nushell/nushell/pull/9773 introduced constants to modules and allowed to export them, but only within one level. This PR: * allows recursive exporting of constants from all submodules * fixes submodule imports in a list import pattern * makes sure exported constants are actual constants Should unblock https://github.com/nushell/nushell/pull/9678 ### Example: ```nushell module spam { export module eggs { export module bacon { export const viking = 'eats' } } } use spam print $spam.eggs.bacon.viking # prints 'eats' use spam [eggs] print $eggs.bacon.viking # prints 'eats' use spam eggs bacon viking print $viking # prints 'eats' ``` ### Limitation 1: Considering the above `spam` module, attempting to get `eggs bacon` from `spam` module doesn't work directly: ```nushell use spam [ eggs bacon ] # attempts to load `eggs`, then `bacon` use spam [ "eggs bacon" ] # obviously wrong name for a constant, but doesn't work also for commands ``` Workaround (for example): ```nushell use spam eggs use eggs [ bacon ] print $bacon.viking # prints 'eats' ``` I'm thinking I'll just leave it in, as you can easily work around this. It is also a limitation of the import pattern in general, not just constants. ### Limitation 2: `overlay use` successfully imports the constants, but `overlay hide` does not hide them, even though it seems to hide normal variables successfully. This needs more investigation. # User-Facing Changes <!-- List of all changes that impact the user experience here. This helps us keep track of breaking changes. --> Allows recursive constant exports from submodules. # 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 -A clippy::needless_collect -A clippy::result_large_err` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass - `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. -->
770 lines
20 KiB
Rust
770 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 not_allowed_submodule_file() {
|
|
let inp = &["use samples/not_allowed"];
|
|
let actual = nu!(cwd: "tests/modules", &inp.join("; "));
|
|
assert!(actual.err.contains("invalid_module_file_name"));
|
|
}
|
|
|
|
#[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");
|
|
}
|