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/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"
-        lib path add "bar" "baz" --append
+        path add "foo"
+        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 | lib repeat 1) [$x]
-        assert equal ($x | lib repeat 2) [$x $x]
+        assert equal ($x | repeat 0) []
+        assert equal ($x | repeat 1) [$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]
+    }
+}