Fix dirs removal warning (#14029)

# Description

* Primary purpose is to fix an issue with a missing escaped opening
parenthesis in the warning message when running an old `dirs` alias.
This was creating an error condition from improper interpolation.

Also

* Incorporates #13842 feedback from @kubouch by renaming `std/lib` to
`std/util`
* Removes duplication of code in `export-env`
* Renames submodule exports to `std/<submodule>` rather than
`./<submodule>` - No user-facing change other than `view files` appears
"prettier".
* In #13842, I converted the test cases to use `use std/<module>`
syntax. Previously, the tests were (effectively) using `use std *` (due
to pre-existing bugs, now fixed).

So "before", we only had test coverage on `use std *`, and "after" we
only had test coverage on `use std/<module>`. I've started adding test
cases so that we have coverage on *both* scenarios going forward.

For now, `formats` and `util` have been updated with tests for both
scenarios. I'll continue adding the others in future PRs.

# User-Facing Changes

No user-facing changes - Bug fix, refactor, and test cases only

# Tests + Formatting

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

# After Submitting

Still working on updating the Doc. I ran into the `dirs` issue while
writing it and rabbit-trailed to fix it in this PR.

crates/nu-std/src/lib.rs

@@ -32,7 +32,7 @@ pub fn load_standard_library(
             ("iter", include_str!("../std/iter.nu")),
             ("log", include_str!("../std/log.nu")),
             ("math", include_str!("../std/math.nu")),
-            ("lib", include_str!("../std/lib.nu")),
+            ("util", include_str!("../std/util.nu")),
             ("xml", include_str!("../std/xml.nu")),
             // Remove in following release
             ("deprecated_dirs", include_str!("../std/deprecated_dirs.nu")),

crates/nu-std/std/deprecated_dirs.nu

@@ -26,7 +26,7 @@ print -e $"
 (ansi red)Warning:(ansi reset) The 'std dirs' module will no longer automatically
 be loaded in the next release. To continue using the Shells
 feature, and to remove this warning, please add the following
-to your startup configuration (typically env.nu or config.nu):
+to your startup configuration \(typically env.nu or config.nu\):
 
 use std/dirs shells-aliases *
 

crates/nu-std/std/mod.nu

@@ -1,24 +1,24 @@
 # std.nu, `used` to load all standard library components
 
 # Top-level commands: ellie, repeat, null-device, and "path add"
-export use lib *
+export use std/util *
 
 # std submodules
-export module ./assert
+export module std/assert
-export module ./bench
+export module std/bench
-export module ./dt
+export module std/dt
-export module ./formats
+export module std/formats
-export module ./help
+export module std/help
-export module ./input
+export module std/input
-export module ./iter
+export module std/iter
-export module ./log
+export module std/log
-export module ./math
+export module std/math
-export module ./xml
+export module std/xml
 
 # Load main dirs command and all subcommands
-export use ./dirs main
+export use std/dirs main
-export module ./dirs {
+export module dirs {
-  export use ./dirs [
+  export use std/dirs [
     add
     drop
     next
@@ -29,11 +29,6 @@ export module ./dirs {
 
 # Workaround for #13403 to load export-env blocks from submodules
 export-env {
-    # log
+    use std/log []
-    $env.NU_LOG_FORMAT = $env.NU_LOG_FORMAT? | default "%ANSI_START%%DATE%|%LEVEL%|%MSG%%ANSI_STOP%"
+    use std/dirs []
-    $env.NU_LOG_DATE_FORMAT = $env.NU_LOG_DATE_FORMAT? | default "%Y-%m-%dT%H:%M:%S%.3f"
-    
-    # dirs
-    $env.DIRS_POSITION = 0
-    $env.DIRS_LIST = [($env.PWD | path expand)]
 }

crates/nu-std/tests/test_formats.nu

@@ -1,4 +1,6 @@
+# Test std/formats when importing module-only
 use std/assert
+use std/formats *
 
 def test_data_multiline [] {
   let lines = [
@@ -19,7 +21,6 @@ def test_data_multiline [] {
 
 #[test]
 def from_ndjson_multiple_objects [] {
-  use std/formats *
   let result = test_data_multiline | from ndjson
   let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
   assert equal $result $expect "could not convert from NDJSON"
@@ -27,7 +28,6 @@ def from_ndjson_multiple_objects [] {
 
 #[test]
 def from_ndjson_single_object [] {
-  use std/formats *
   let result = '{"a": 1}' | from ndjson
   let expect = [{a:1}]
   assert equal $result $expect "could not convert from NDJSON"
@@ -35,13 +35,11 @@ def from_ndjson_single_object [] {
 
 #[test]
 def from_ndjson_invalid_object [] {
-  use std/formats *
   assert error { '{"a":1' | from ndjson }
 }
 
 #[test]
 def from_jsonl_multiple_objects [] {
-  use std/formats *
   let result = test_data_multiline | from jsonl
   let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
   assert equal $result $expect "could not convert from JSONL"
@@ -49,7 +47,6 @@ def from_jsonl_multiple_objects [] {
 
 #[test]
 def from_jsonl_single_object [] {
-  use std/formats *
   let result = '{"a": 1}' | from jsonl
   let expect = [{a:1}]
   assert equal $result $expect "could not convert from JSONL"
@@ -57,13 +54,11 @@ def from_jsonl_single_object [] {
 
 #[test]
 def from_jsonl_invalid_object [] {
-  use std/formats *
   assert error { '{"a":1' | from jsonl }
 }
 
 #[test]
 def to_ndjson_multiple_objects [] {
-  use std/formats *
   let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | to ndjson | str trim
   let expect = test_data_multiline
   assert equal $result $expect "could not convert to NDJSON"
@@ -71,7 +66,6 @@ def to_ndjson_multiple_objects [] {
 
 #[test]
 def to_ndjson_single_object [] {
-  use std/formats *
   let result = [{a:1}] | to ndjson | str trim
   let expect = "{\"a\":1}"
   assert equal $result $expect "could not convert to NDJSON"
@@ -79,7 +73,6 @@ def to_ndjson_single_object [] {
 
 #[test]
 def to_jsonl_multiple_objects [] {
-  use std/formats *
   let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | to jsonl | str trim
   let expect = test_data_multiline
   assert equal $result $expect "could not convert to JSONL"
@@ -87,7 +80,6 @@ def to_jsonl_multiple_objects [] {
 
 #[test]
 def to_jsonl_single_object [] {
-  use std/formats *
   let result = [{a:1}] | to jsonl | str trim
   let expect = "{\"a\":1}"
   assert equal $result $expect "could not convert to JSONL"

crates/nu-std/tests/test_std_formats.nu

@@ -0,0 +1,86 @@
+# Test std/formats when importing `use std *`
+use std *
+
+def test_data_multiline [] {
+  use std *
+  let lines = [
+    "{\"a\":1}",
+    "{\"a\":2}",
+    "{\"a\":3}",
+    "{\"a\":4}",
+    "{\"a\":5}",
+    "{\"a\":6}",
+  ]
+
+  if $nu.os-info.name == "windows" {
+    $lines | str join "\r\n"
+  } else {
+    $lines | str join "\n"
+  }
+}
+
+#[test]
+def from_ndjson_multiple_objects [] {
+  let result = test_data_multiline | formats from ndjson
+  let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
+  assert equal $result $expect "could not convert from NDJSON"
+}
+
+#[test]
+def from_ndjson_single_object [] {
+  let result = '{"a": 1}' | formats from ndjson
+  let expect = [{a:1}]
+  assert equal $result $expect "could not convert from NDJSON"
+}
+
+#[test]
+def from_ndjson_invalid_object [] {
+  assert error { '{"a":1' | formats from ndjson }
+}
+
+#[test]
+def from_jsonl_multiple_objects [] {
+  let result = test_data_multiline | formats from jsonl
+  let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
+  assert equal $result $expect "could not convert from JSONL"
+}
+
+#[test]
+def from_jsonl_single_object [] {
+  let result = '{"a": 1}' | formats from jsonl
+  let expect = [{a:1}]
+  assert equal $result $expect "could not convert from JSONL"
+}
+
+#[test]
+def from_jsonl_invalid_object [] {
+  assert error { '{"a":1' | formats from jsonl }
+}
+
+#[test]
+def to_ndjson_multiple_objects [] {
+  let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | formats to ndjson | str trim
+  let expect = test_data_multiline
+  assert equal $result $expect "could not convert to NDJSON"
+}
+
+#[test]
+def to_ndjson_single_object [] {
+  let result = [{a:1}] | formats to ndjson | str trim
+  let expect = "{\"a\":1}"
+  assert equal $result $expect "could not convert to NDJSON"
+}
+
+#[test]
+def to_jsonl_multiple_objects [] {
+  let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | formats to jsonl | str trim
+  let expect = test_data_multiline
+  assert equal $result $expect "could not convert to JSONL"
+}
+
+#[test]
+def to_jsonl_single_object [] {
+  let result = [{a:1}] | formats to jsonl | str trim
+  let expect = "{\"a\":1}"
+  assert equal $result $expect "could not convert to JSONL"
+}

crates/nu-std/tests/test_std_util.nu

@@ -1,4 +1,4 @@
-use std/lib
+use std *
 
 #[test]
 def path_add [] {
@@ -11,19 +11,19 @@ def path_add [] {
 
         assert equal (get_path) []
 
-        lib path add "/foo/"
+        path add "/foo/"
         assert equal (get_path) (["/foo/"] | path expand)
 
-        lib path add "/bar/" "/baz/"
+        path add "/bar/" "/baz/"
         assert equal (get_path) (["/bar/", "/baz/", "/foo/"] | path expand)
 
         load-env {$path_name: []}
 
-        lib path add "foo"
+        path add "foo"
-        lib path add "bar" "baz" --append
+        path add "bar" "baz" --append
         assert equal (get_path) (["foo", "bar", "baz"] | path expand)
 
-        assert equal (lib path add "fooooo" --ret) (["fooooo", "foo", "bar", "baz"] | path expand)
+        assert equal (path add "fooooo" --ret) (["fooooo", "foo", "bar", "baz"] | path expand)
         assert equal (get_path) (["fooooo", "foo", "bar", "baz"] | path expand)
 
         load-env {$path_name: []}
@@ -35,11 +35,11 @@ def path_add [] {
             android: "quux",
         }
 
-        lib path add $target_paths
+        path add $target_paths
         assert equal (get_path) ([($target_paths | get $nu.os-info.name)] | path expand)
 
         load-env {$path_name: [$"(["/foo", "/bar"] | path expand | str join (char esep))"]}
-        lib path add "~/foo"
+        path add "~/foo"
         assert equal (get_path) (["~/foo", "/foo", "/bar"] | path expand)
     }
 }
@@ -63,7 +63,7 @@ def path_add_expand [] {
     with-env {$path_name: []} {
         def get_path [] { $env | get $path_name }
 
-        lib path add $link_dir
+        path add $link_dir
         assert equal (get_path) ([$link_dir])
     }
 
@@ -73,11 +73,11 @@ def path_add_expand [] {
 #[test]
 def repeat_things [] {
     use std/assert
-    assert error { "foo" | lib repeat -1 }
+    assert error { "foo" | repeat -1 }
 
     for x in ["foo", [1 2], {a: 1}] {
-        assert equal ($x | lib repeat 0) []
+        assert equal ($x | repeat 0) []
-        assert equal ($x | lib repeat 1) [$x]
+        assert equal ($x | repeat 1) [$x]
-        assert equal ($x | lib repeat 2) [$x $x]
+        assert equal ($x | repeat 2) [$x $x]
     }
 }

crates/nu-std/tests/test_util.nu

@@ -0,0 +1,83 @@
+use std/util *
+
+#[test]
+def path_add [] {
+    use std/assert
+
+    let path_name = if "PATH" in $env { "PATH" } else { "Path" }
+
+    with-env {$path_name: []} {
+        def get_path [] { $env | get $path_name }
+
+        assert equal (get_path) []
+
+        path add "/foo/"
+        assert equal (get_path) (["/foo/"] | path expand)
+
+        path add "/bar/" "/baz/"
+        assert equal (get_path) (["/bar/", "/baz/", "/foo/"] | path expand)
+
+        load-env {$path_name: []}
+
+        path add "foo"
+        path add "bar" "baz" --append
+        assert equal (get_path) (["foo", "bar", "baz"] | path expand)
+
+        assert equal (path add "fooooo" --ret) (["fooooo", "foo", "bar", "baz"] | path expand)
+        assert equal (get_path) (["fooooo", "foo", "bar", "baz"] | path expand)
+
+        load-env {$path_name: []}
+
+        let target_paths = {
+            linux: "foo",
+            windows: "bar",
+            macos: "baz",
+            android: "quux",
+        }
+
+        path add $target_paths
+        assert equal (get_path) ([($target_paths | get $nu.os-info.name)] | path expand)
+
+        load-env {$path_name: [$"(["/foo", "/bar"] | path expand | str join (char esep))"]}
+        path add "~/foo"
+        assert equal (get_path) (["~/foo", "/foo", "/bar"] | path expand)
+    }
+}
+
+#[test]
+def path_add_expand [] {
+    use std/assert
+
+    # random paths to avoid collision, especially if left dangling on failure
+    let real_dir = $nu.temp-path | path join $"real-dir-(random chars)"
+    let link_dir = $nu.temp-path | path join $"link-dir-(random chars)"
+    mkdir $real_dir
+    let path_name = if $nu.os-info.family == 'windows' {
+        mklink /D $link_dir $real_dir
+        "Path"
+    } else {
+        ln -s $real_dir $link_dir | ignore
+        "PATH"
+    }
+
+    with-env {$path_name: []} {
+        def get_path [] { $env | get $path_name }
+
+        path add $link_dir
+        assert equal (get_path) ([$link_dir])
+    }
+
+    rm $real_dir $link_dir
+}
+
+#[test]
+def repeat_things [] {
+    use std/assert
+    assert error { "foo" | repeat -1 }
+
+    for x in ["foo", [1 2], {a: 1}] {
+        assert equal ($x | repeat 0) []
+        assert equal ($x | repeat 1) [$x]
+        assert equal ($x | repeat 2) [$x $x]
+    }
+}