Add syn to the lock file (#2871)

* Pin the syn version to avoid breaking change

* pin syn in wasm also

.azure/azure-pipelines.yml

@@ -9,6 +9,12 @@ strategy:
     linux-minimal:
       image: ubuntu-18.04
       style: 'minimal'
+    linux-extra:
+      image: ubuntu-18.04
+      style: 'extra'
+    linux-wasm:
+      image: ubuntu-18.04
+      style: 'wasm'
     macos-stable:
       image: macos-10.14
       style: 'unflagged'
@@ -37,6 +43,7 @@ steps:
       if [ -e /etc/debian_version ]
       then
         sudo apt-get -y install libxcb-composite0-dev libx11-dev
+        sudo npm install -g wasm-pack
       fi
       if [ "$(uname)" == "Darwin" ]; then
         curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
@@ -49,21 +56,27 @@ steps:
   #     echo "##vso[task.prependpath]$HOME/.cargo/bin"
   #     rustup component add rustfmt
     displayName: Install Rust
-  - bash: RUSTFLAGS="-D warnings" cargo test --all --features stable
+  - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'unflagged')
     displayName: Run tests
-  - bash: RUSTFLAGS="-D warnings" cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
     condition: eq(variables['style'], 'unflagged')
     displayName: Check clippy lints
-  - bash: NUSHELL_ENABLE_ALL_FLAGS=1 RUSTFLAGS="-D warnings" cargo test --all --features stable
+  - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'canary')
     displayName: Run tests
-  - bash: NUSHELL_ENABLE_ALL_FLAGS=1 RUSTFLAGS="-D warnings" cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
+  - bash: cd samples/wasm && wasm-pack build
+    condition: eq(variables['style'], 'wasm')
+    displayName: Wasm build
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
     condition: eq(variables['style'], 'canary')
     displayName: Check clippy lints
-  - bash: RUSTFLAGS="-D warnings" cargo test --all --no-default-features
+  - bash: RUSTFLAGS="-D warnings" cargo test --all --no-default-features --features=rustyline-support
     condition: eq(variables['style'], 'minimal')
     displayName: Run tests
+  - bash: RUSTFLAGS="-D warnings" cargo test --all --features=extra
+    condition: eq(variables['style'], 'extra')
+    displayName: Run tests
   - bash: cargo fmt --all -- --check
     condition: eq(variables['style'], 'fmt')
     displayName: Lint

.cargo/config

@@ -1 +0,0 @@
-[build]

.cargo/config.toml

@@ -0,0 +1,6 @@
+# use LLD as linker on Windows because it could be faster
+# for full and incremental builds compared to default
+
+[target.x86_64-pc-windows-msvc]
+#linker = "lld-link.exe"
+rustflags = ["-C", "link-args=-stack:10000000"]

.circleci/config.yml

@@ -73,7 +73,7 @@ workflows:
             branches:
               ignore: /.*/
             tags:
-              only: /^v.*/
+              only: /^\d+\.\d+\.\d+$/
           before_build:
             - run: docker pull quay.io/nushell/nu:latest
             - run: docker pull quay.io/nushell/nu-base:latest

.github/ISSUE_TEMPLATE/bug_report.md

@@ -12,9 +12,9 @@ A clear and concise description of what the bug is.
 
 **To Reproduce**
 Steps to reproduce the behavior:
-1. 
-2. 
-3. 
+1.
+2.
+3.
 
 **Expected behavior**
 A clear and concise description of what you expected to happen.
@@ -23,8 +23,25 @@ A clear and concise description of what you expected to happen.
 If applicable, add screenshots to help explain your problem.
 
 **Configuration (please complete the following information):**
- - OS (e.g. Windows):
- - Nu version (you can use the `version` command to find out): 
- - Optional features (if any):
 
-Add any other context about the problem here.
+Run `version | pivot` and paste the output to show OS, features, etc.
+
+```
+> version | pivot
+╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
+│ # │ Column0            │ Column1                                                               │
+├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
+│ 0 │ version            │ 0.24.1                                                                │
+│ 1 │ build_os           │ macos-x86_64                                                          │
+│ 2 │ rust_version       │ rustc 1.48.0                                                          │
+│ 3 │ cargo_version      │ cargo 1.48.0                                                          │
+│ 4 │ pkg_version        │ 0.24.1                                                                │
+│ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
+│ 6 │ build_rust_channel │ release                                                               │
+│ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, ptree, rich-benchmark, │
+│   │                    │ rustyline, term, uuid, which, zip                                     │
+╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
+```
+
+
+**Add any other context about the problem here.**

.github/workflows/release.yml

@@ -26,7 +26,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --release --all --features=stable
+          args: --release --all --features=extra
 
       - name: Create output directory
         run: mkdir output
@@ -38,7 +38,7 @@ jobs:
           cp LICENSE output/LICENSE
           rm output/*.d
           rm output/nu_plugin_core_*
-          rm output/nu_plugin_stable_*
+          rm output/nu_plugin_extra_*
 
       # Note: If OpenSSL changes, this path will need to be updated
       - name: Copy OpenSSL to output
@@ -68,7 +68,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --release --all --features=stable
+          args: --release --all --features=extra
 
       - name: Create output directory
         run: mkdir output
@@ -80,7 +80,7 @@ jobs:
           cp LICENSE output/LICENSE
           rm output/*.d
           rm output/nu_plugin_core_*
-          rm output/nu_plugin_stable_*
+          rm output/nu_plugin_extra_*
 
       - name: Upload artifact
         uses: actions/upload-artifact@v2
@@ -112,7 +112,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --release --all --features=stable
+          args: --release --all --features=extra
 
       - name: Create output directory
         run: mkdir output
@@ -129,7 +129,7 @@ jobs:
           cp LICENSE output\
           cp target\release\LICENSE-for-less.txt output\
           rm target\release\nu_plugin_core_*.exe
-          rm target\release\nu_plugin_stable_*.exe
+          rm target\release\nu_plugin_extra_*.exe
           cp target\release\nu_plugin_*.exe output\
           cp README.build.txt output\README.txt
           cp target\release\less.exe output\

.gitpod.Dockerfile

@@ -1,5 +1,9 @@
 FROM gitpod/workspace-full
 
+# Gitpod will not rebuild Nushell's dev image unless *some* change is made to this Dockerfile.
+# To force a rebuild, simply increase this counter:
+ENV TRIGGER_REBUILD 1
+
 USER gitpod
 
 RUN sudo apt-get update && \
@@ -11,4 +15,4 @@ RUN sudo apt-get update && \
         rust-lldb \
     && sudo rm -rf /var/lib/apt/lists/*
 
-ENV RUST_LLDB=/usr/bin/lldb-8
+ENV RUST_LLDB=/usr/bin/lldb-11

CONTRIBUTING.md

@@ -25,38 +25,51 @@ cargo build
 
 ### Useful Commands
 
-Build and run Nushell:
+- Build and run Nushell:
 
-```shell
-cargo build --release && cargo run --release
-```
+  ```shell
+  cargo build --release && cargo run --release
+  ```
 
-Run Clippy on Nushell:
+- Build and run with extra features:
+  ```shell
+  cargo build --release --features=extra && cargo run --release --features=extra
+  ```
 
-```shell
-cargo clippy --all --features=stable
-```
+- Run Clippy on Nushell:
 
-Run all tests:
+  ```shell
+  cargo clippy --all --features=stable
+  ```
 
-```shell
-cargo test --all --features=stable
-```
+- Run all tests:
 
-Run all tests for a specific command
+  ```shell
+  cargo test --all --features=stable
+  ```
 
-```shell
-cargo test --package nu-cli --test main -- commands::<command_name_here>
-```
+- Run all tests for a specific command
 
-Check to see if there are code formatting issues
+  ```shell
+  cargo test --package nu-cli --test main -- commands::<command_name_here>
+  ```
 
-```shell
-cargo fmt --all -- --check
-```
+- Check to see if there are code formatting issues
 
-Format the code in the project
+  ```shell
+  cargo fmt --all -- --check
+  ```
 
-```shell
-cargo fmt --all
-```
+- Format the code in the project
+
+  ```shell
+  cargo fmt --all
+  ```
+
+### Debugging Tips
+
+- To view verbose logs when developing, enable the `trace` log level.
+
+  ```shell
+  cargo build --release --features=extra && cargo run --release --features=extra -- --loglevel trace
+  ```

Cargo.toml

@@ -10,7 +10,7 @@ license = "MIT"
 name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.17.0"
+version = "0.25.1"
 
 [workspace]
 members = ["crates/*/"]
@@ -18,50 +18,60 @@ members = ["crates/*/"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-cli = {version = "0.17.0", path = "./crates/nu-cli"}
-nu-errors = {version = "0.17.0", path = "./crates/nu-errors"}
-nu-parser = {version = "0.17.0", path = "./crates/nu-parser"}
-nu-plugin = {version = "0.17.0", path = "./crates/nu-plugin"}
-nu-protocol = {version = "0.17.0", path = "./crates/nu-protocol"}
-nu-source = {version = "0.17.0", path = "./crates/nu-source"}
-nu-value-ext = {version = "0.17.0", path = "./crates/nu-value-ext"}
-nu_plugin_binaryview = {version = "0.17.0", path = "./crates/nu_plugin_binaryview", optional = true}
-nu_plugin_fetch = {version = "0.17.0", path = "./crates/nu_plugin_fetch", optional = true}
-nu_plugin_from_bson = {version = "0.17.0", path = "./crates/nu_plugin_from_bson", optional = true}
-nu_plugin_from_sqlite = {version = "0.17.0", path = "./crates/nu_plugin_from_sqlite", optional = true}
-nu_plugin_inc = {version = "0.17.0", path = "./crates/nu_plugin_inc", optional = true}
-nu_plugin_match = {version = "0.17.0", path = "./crates/nu_plugin_match", optional = true}
-nu_plugin_post = {version = "0.17.0", path = "./crates/nu_plugin_post", optional = true}
-nu_plugin_ps = {version = "0.17.0", path = "./crates/nu_plugin_ps", optional = true}
-nu_plugin_start = {version = "0.17.0", path = "./crates/nu_plugin_start", optional = true}
-nu_plugin_sys = {version = "0.17.0", path = "./crates/nu_plugin_sys", optional = true}
-nu_plugin_textview = {version = "0.17.0", path = "./crates/nu_plugin_textview", optional = true}
-nu_plugin_to_bson = {version = "0.17.0", path = "./crates/nu_plugin_to_bson", optional = true}
-nu_plugin_to_sqlite = {version = "0.17.0", path = "./crates/nu_plugin_to_sqlite", optional = true}
-nu_plugin_tree = {version = "0.17.0", path = "./crates/nu_plugin_tree", optional = true}
+nu-cli = {version = "0.25.1", path = "./crates/nu-cli"}
+nu-data = {version = "0.25.1", path = "./crates/nu-data"}
+nu-errors = {version = "0.25.1", path = "./crates/nu-errors"}
+nu-parser = {version = "0.25.1", path = "./crates/nu-parser"}
+nu-plugin = {version = "0.25.1", path = "./crates/nu-plugin"}
+nu-protocol = {version = "0.25.1", path = "./crates/nu-protocol"}
+nu-source = {version = "0.25.1", path = "./crates/nu-source"}
+nu-value-ext = {version = "0.25.1", path = "./crates/nu-value-ext"}
 
-crossterm = {version = "0.17.5", optional = true}
-semver = {version = "0.10.0", optional = true}
-syntect = {version = "4.2", default-features = false, features = ["default-fancy"], optional = true}
-url = {version = "2.1.1", optional = true}
+nu_plugin_binaryview = {version = "0.25.1", path = "./crates/nu_plugin_binaryview", optional = true}
+nu_plugin_chart = {version = "0.25.1", path = "./crates/nu_plugin_chart", optional = true}
+nu_plugin_fetch = {version = "0.25.1", path = "./crates/nu_plugin_fetch", optional = true}
+nu_plugin_from_bson = {version = "0.25.1", path = "./crates/nu_plugin_from_bson", optional = true}
+nu_plugin_from_sqlite = {version = "0.25.1", path = "./crates/nu_plugin_from_sqlite", optional = true}
+nu_plugin_inc = {version = "0.25.1", path = "./crates/nu_plugin_inc", optional = true}
+nu_plugin_match = {version = "0.25.1", path = "./crates/nu_plugin_match", optional = true}
+nu_plugin_post = {version = "0.25.1", path = "./crates/nu_plugin_post", optional = true}
+nu_plugin_ps = {version = "0.25.1", path = "./crates/nu_plugin_ps", optional = true}
+nu_plugin_s3 = {version = "0.25.1", path = "./crates/nu_plugin_s3", optional = true}
+nu_plugin_selector = {version = "0.25.1", path = "./crates/nu_plugin_selector", optional = true}
+nu_plugin_start = {version = "0.25.1", path = "./crates/nu_plugin_start", optional = true}
+nu_plugin_sys = {version = "0.25.1", path = "./crates/nu_plugin_sys", optional = true}
+nu_plugin_textview = {version = "0.25.1", path = "./crates/nu_plugin_textview", optional = true}
+nu_plugin_to_bson = {version = "0.25.1", path = "./crates/nu_plugin_to_bson", optional = true}
+nu_plugin_to_sqlite = {version = "0.25.1", path = "./crates/nu_plugin_to_sqlite", optional = true}
+nu_plugin_tree = {version = "0.25.1", path = "./crates/nu_plugin_tree", optional = true}
+nu_plugin_xpath = {version = "0.25.1", path = "./crates/nu_plugin_xpath", optional = true}
 
-clap = "2.33.1"
-ctrlc = "3.1.4"
-dunce = "1.0.1"
-futures = {version = "0.3", features = ["compat", "io-compat"]}
-log = "0.4.8"
+# Required to bootstrap the main binary
+clap = "2.33.3"
+ctrlc = {version = "3.1.6", optional = true}
+futures = {version = "0.3.5", features = ["compat", "io-compat"]}
+itertools = "0.9.0"
+log = "0.4.11"
 pretty_env_logger = "0.4.0"
-starship = "0.43.0"
+syn = "=1.0.57"
 
 [dev-dependencies]
-nu-test-support = {version = "0.17.0", path = "./crates/nu-test-support"}
+dunce = "1.0.1"
+nu-test-support = {version = "0.25.1", path = "./crates/nu-test-support"}
 
 [build-dependencies]
-nu-build = {version = "0.17.0", path = "./crates/nu-build"}
-serde = {version = "1.0.110", features = ["derive"]}
-toml = "0.5.6"
 
 [features]
+ctrlc-support = ["nu-cli/ctrlc"]
+directories-support = ["nu-cli/directories", "nu-cli/dirs", "nu-data/directories", "nu-data/dirs"]
+git-support = ["nu-cli/git2"]
+ptree-support = ["nu-cli/ptree"]
+rich-benchmark = ["nu-cli/rich-benchmark"]
+rustyline-support = ["nu-cli/rustyline-support"]
+term-support = ["nu-cli/term"]
+uuid-support = ["nu-cli/uuid_crate"]
+which-support = ["nu-cli/ichwh", "nu-cli/which"]
+
 default = [
   "sys",
   "ps",
@@ -74,36 +84,48 @@ default = [
   "ptree-support",
   "term-support",
   "uuid-support",
+  "rustyline-support",
+  "match",
+  "post",
+  "fetch",
+  "rich-benchmark",
+  "zip-support",
 ]
-stable = ["default", "binaryview", "match", "tree", "post", "fetch", "clipboard-cli", "trash-support", "start", "starship-prompt", "bson", "sqlite"]
+extra = ["default", "binaryview", "tree", "clipboard-cli", "trash-support", "start", "bson", "sqlite", "s3", "chart", "xpath", "selector"]
+stable = ["default"]
 
-# Default
-inc = ["semver", "nu_plugin_inc"]
-ps = ["nu_plugin_ps"]
-sys = ["nu_plugin_sys"]
-textview = ["crossterm", "syntect", "url", "nu_plugin_textview"]
+wasi = ["inc", "match", "directories-support", "ptree-support", "match", "tree", "rustyline-support"]
 
-# Stable
-binaryview = ["nu_plugin_binaryview"]
-bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+trace = ["nu-parser/trace"]
+
+# Stable (Default)
 fetch = ["nu_plugin_fetch"]
+inc = ["nu_plugin_inc"]
 match = ["nu_plugin_match"]
 post = ["nu_plugin_post"]
+ps = ["nu_plugin_ps"]
+sys = ["nu_plugin_sys"]
+textview = ["nu_plugin_textview"]
+zip-support = ["nu-cli/zip"]
+
+# Extra
+binaryview = ["nu_plugin_binaryview"]
+bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+chart = ["nu_plugin_chart"]
+clipboard-cli = ["nu-cli/clipboard-cli"]
+s3 = ["nu_plugin_s3"]
+selector = ["nu_plugin_selector"]
 sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
 start = ["nu_plugin_start"]
-trace = ["nu-parser/trace"]
-tree = ["nu_plugin_tree"]
-
-clipboard-cli = ["nu-cli/clipboard-cli"]
-ctrlc-support = ["nu-cli/ctrlc"]
-directories-support = ["nu-cli/directories", "nu-cli/dirs"]
-git-support = ["nu-cli/git2"]
-ptree-support = ["nu-cli/ptree"]
-starship-prompt = ["nu-cli/starship-prompt"]
-term-support = ["nu-cli/term"]
 trash-support = ["nu-cli/trash-support"]
-uuid-support = ["nu-cli/uuid_crate"]
-which-support = ["nu-cli/ichwh", "nu-cli/which"]
+tree = ["nu_plugin_tree"]
+xpath = ["nu_plugin_xpath"]
+
+[profile.release]
+#strip = "symbols" #Couldn't get working +nightly
+codegen-units = 1 #Reduce parallel codegen units
+lto = true #Link Time Optimization
+opt-level = 'z' #Optimize for size
 
 # Core plugins that ship with `cargo install nu` by default
 # Currently, Cargo limits us to installing only one binary
@@ -128,37 +150,83 @@ name = "nu_plugin_core_sys"
 path = "src/plugins/nu_plugin_core_sys.rs"
 required-features = ["sys"]
 
-# Stable plugins
 [[bin]]
-name = "nu_plugin_stable_fetch"
-path = "src/plugins/nu_plugin_stable_fetch.rs"
+name = "nu_plugin_core_fetch"
+path = "src/plugins/nu_plugin_core_fetch.rs"
 required-features = ["fetch"]
 
 [[bin]]
-name = "nu_plugin_stable_binaryview"
-path = "src/plugins/nu_plugin_stable_binaryview.rs"
-required-features = ["binaryview"]
-
-[[bin]]
-name = "nu_plugin_stable_match"
-path = "src/plugins/nu_plugin_stable_match.rs"
+name = "nu_plugin_core_match"
+path = "src/plugins/nu_plugin_core_match.rs"
 required-features = ["match"]
 
 [[bin]]
-name = "nu_plugin_stable_post"
-path = "src/plugins/nu_plugin_stable_post.rs"
+name = "nu_plugin_core_post"
+path = "src/plugins/nu_plugin_core_post.rs"
 required-features = ["post"]
 
+# Extra plugins
+
 [[bin]]
-name = "nu_plugin_stable_tree"
-path = "src/plugins/nu_plugin_stable_tree.rs"
+name = "nu_plugin_extra_binaryview"
+path = "src/plugins/nu_plugin_extra_binaryview.rs"
+required-features = ["binaryview"]
+
+[[bin]]
+name = "nu_plugin_extra_tree"
+path = "src/plugins/nu_plugin_extra_tree.rs"
 required-features = ["tree"]
 
 [[bin]]
-name = "nu_plugin_stable_start"
-path = "src/plugins/nu_plugin_stable_start.rs"
+name = "nu_plugin_extra_start"
+path = "src/plugins/nu_plugin_extra_start.rs"
 required-features = ["start"]
 
+[[bin]]
+name = "nu_plugin_extra_s3"
+path = "src/plugins/nu_plugin_extra_s3.rs"
+required-features = ["s3"]
+
+[[bin]]
+name = "nu_plugin_extra_chart_bar"
+path = "src/plugins/nu_plugin_extra_chart_bar.rs"
+required-features = ["chart"]
+
+[[bin]]
+name = "nu_plugin_extra_chart_line"
+path = "src/plugins/nu_plugin_extra_chart_line.rs"
+required-features = ["chart"]
+
+[[bin]]
+name = "nu_plugin_extra_xpath"
+path = "src/plugins/nu_plugin_extra_xpath.rs"
+required-features = ["xpath"]
+
+[[bin]]
+name = "nu_plugin_extra_selector"
+path = "src/plugins/nu_plugin_extra_selector.rs"
+required-features = ["selector"]
+
+[[bin]]
+name = "nu_plugin_extra_from_bson"
+path = "src/plugins/nu_plugin_extra_from_bson.rs"
+required-features = ["bson"]
+
+[[bin]]
+name = "nu_plugin_extra_to_bson"
+path = "src/plugins/nu_plugin_extra_to_bson.rs"
+required-features = ["bson"]
+
+[[bin]]
+name = "nu_plugin_extra_from_sqlite"
+path = "src/plugins/nu_plugin_extra_from_sqlite.rs"
+required-features = ["sqlite"]
+
+[[bin]]
+name = "nu_plugin_extra_to_sqlite"
+path = "src/plugins/nu_plugin_extra_to_sqlite.rs"
+required-features = ["sqlite"]
+
 # Main nu binary
 [[bin]]
 name = "nu"

README.md

@@ -7,7 +7,7 @@
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
 [![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
 
-## Nu Shell
+## Nushell
 
 A new type of shell.
 
@@ -34,7 +34,7 @@ There are also [good first issues](https://github.com/nushell/nushell/issues?q=i
 
 We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.
 
-You can also find more learning resources in our [documentation](https://www.nushell.sh/documentation.html) site.
+You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).
 
 Try it in Gitpod.
 
@@ -44,19 +44,19 @@ Try it in Gitpod.
 
 ### Local
 
-Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/en/installation.html).  **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
+Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html).  **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
 
-To build Nu, you will need to use the **latest stable (1.41 or later)** version of the compiler.
+To build Nu, you will need to use the **latest stable (1.47 or later)** version of the compiler.
 
 Required dependencies:
 
 * pkg-config and libssl (only needed on Linux)
-  * on Debian/Ubuntu: `apt install pkg-config libssl-dev`
+  * On Debian/Ubuntu: `apt install pkg-config libssl-dev`
 
 Optional dependencies:
 
 * To use Nu with all possible optional features enabled, you'll also need the following:
-  * on Linux (on Debian/Ubuntu): `apt install libxcb-composite0-dev libx11-dev`
+  * On Linux (on Debian/Ubuntu): `apt install libxcb-composite0-dev libx11-dev`
 
 To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs/) and the latest stable compiler via `rustup install stable`):
 
@@ -64,10 +64,10 @@ To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs
 cargo install nu
 ```
 
-You can also build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/en/installation.html#dependencies) for your platform), once you have checked out this repo with git:
+You can also build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/installation.html#dependencies) for your platform), once you have checked out this repo with git:
 
 ```bash
-cargo build --workspace --features=stable
+cargo build --workspace --features=extra
 ```
 
 ### Docker
@@ -194,7 +194,7 @@ For example, you can load a .toml file as structured data and explore it:
 > open Cargo.toml
 ────────────────────┬───────────────────────────
  bin                │ [table 18 rows]
- build-dependencies │ [row nu-build serde toml]
+ build-dependencies │ [row serde toml]
  dependencies       │ [row 29 columns]
  dev-dependencies   │ [row nu-test-support]
  features           │ [row 19 columns]
@@ -219,28 +219,28 @@ We can pipeline this into a command that gets the contents of one of the columns
  name          │ nu
  readme        │ README.md
  repository    │ https://github.com/nushell/nushell
- version       │ 0.15.1
+ version       │ 0.21.0
 ───────────────┴────────────────────────────────────
 ```
 
 Finally, we can use commands outside of Nu once we have the data we want:
 
 ```shell
-> open Cargo.toml | get package.version | echo $it
-0.15.1
+> open Cargo.toml | get package.version
+0.21.0
 ```
 
 Here we use the variable `$it` to refer to the value being piped to the external command.
 
 ### Configuration
 
-Nu has early support for configuring the shell. You can refer to the book for a list of [all supported variables](https://www.nushell.sh/book/en/configuration.html).
+Nu has early support for configuring the shell. You can refer to the book for a list of [all supported variables](https://www.nushell.sh/book/configuration.html).
 
-To set one of these variables, you can use `config --set`. For example:
+To set one of these variables, you can use `config set`. For example:
 
 ```shell
-> config --set [edit_mode "vi"]
-> config --set [path $nu.path]
+> config set edit_mode "vi"
+> config set path $nu.path
 ```
 
 ### Shells
@@ -307,7 +307,7 @@ Nu is in heavy development, and will naturally change as it matures and people u
 
 ## Current Roadmap
 
-We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release as well as capture some important issues we'd like to see in NuShell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
+We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release as well as capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
 
 ## Contributing
 

build.rs

@@ -1,3 +0,0 @@
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    nu_build::build()
-}

crates/nu-build/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-authors = ["The Nu Project Contributors"]
-description = "Core build system for nushell"
-edition = "2018"
-license = "MIT"
-name = "nu-build"
-version = "0.17.0"
-
-[lib]
-doctest = false
-
-[dependencies]
-lazy_static = "1.4.0"
-serde = {version = "1.0.114", features = ["derive"]}
-serde_json = "1.0.55"
-toml = "0.5.6"

crates/nu-build/src/lib.rs

@@ -1,80 +0,0 @@
-use lazy_static::lazy_static;
-use serde::Deserialize;
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::env;
-use std::path::{Path, PathBuf};
-use std::sync::Mutex;
-
-lazy_static! {
-    static ref WORKSPACES: Mutex<BTreeMap<String, &'static Path>> = Mutex::new(BTreeMap::new());
-}
-
-// got from https://github.com/mitsuhiko/insta/blob/b113499249584cb650150d2d01ed96ee66db6b30/src/runtime.rs#L67-L88
-
-fn get_cargo_workspace(manifest_dir: &str) -> Result<Option<&Path>, Box<dyn std::error::Error>> {
-    let mut workspaces = WORKSPACES.lock()?;
-    if let Some(rv) = workspaces.get(manifest_dir) {
-        Ok(Some(rv))
-    } else {
-        #[derive(Deserialize)]
-        struct Manifest {
-            workspace_root: String,
-        }
-        let output = std::process::Command::new(env!("CARGO"))
-            .arg("metadata")
-            .arg("--format-version=1")
-            .current_dir(manifest_dir)
-            .output()?;
-        let manifest: Manifest = serde_json::from_slice(&output.stdout)?;
-        let path = Box::leak(Box::new(PathBuf::from(manifest.workspace_root)));
-        workspaces.insert(manifest_dir.to_string(), path.as_path());
-        Ok(workspaces.get(manifest_dir).cloned())
-    }
-}
-
-#[derive(Deserialize)]
-struct Feature {
-    #[allow(unused)]
-    description: String,
-    enabled: bool,
-}
-
-pub fn build() -> Result<(), Box<dyn std::error::Error>> {
-    let input = env::var("CARGO_MANIFEST_DIR")?;
-
-    let all_on = env::var("NUSHELL_ENABLE_ALL_FLAGS").is_ok();
-    let flags: HashSet<String> = env::var("NUSHELL_ENABLE_FLAGS")
-        .map(|s| s.split(',').map(|s| s.to_string()).collect())
-        .unwrap_or_else(|_| HashSet::new());
-
-    if all_on && !flags.is_empty() {
-        println!(
-            "cargo:warning=Both NUSHELL_ENABLE_ALL_FLAGS and NUSHELL_ENABLE_FLAGS were set. You don't need both."
-        );
-    }
-
-    let workspace = match get_cargo_workspace(&input)? {
-        // If the crate is being downloaded from crates.io, it won't have a workspace root, and that's ok
-        None => return Ok(()),
-        Some(workspace) => workspace,
-    };
-
-    let path = Path::new(&workspace).join("features.toml");
-
-    // If the crate is being downloaded from crates.io, it won't have a features.toml, and that's ok
-    if !path.exists() {
-        return Ok(());
-    }
-
-    let toml: HashMap<String, Feature> = toml::from_str(&std::fs::read_to_string(path)?)?;
-
-    for (key, value) in toml.iter() {
-        if value.enabled || all_on || flags.contains(key) {
-            println!("cargo:rustc-cfg={}", key);
-        }
-    }
-
-    Ok(())
-}

crates/nu-cli/Cargo.toml

@@ -1,100 +1,110 @@
 [package]
 authors = ["The Nu Project Contributors"]
+build = "build.rs"
 description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-cli"
-version = "0.17.0"
+version = "0.25.1"
 
 [lib]
 doctest = false
 
 [dependencies]
-nu-errors = {version = "0.17.0", path = "../nu-errors"}
-nu-parser = {version = "0.17.0", path = "../nu-parser"}
-nu-plugin = {version = "0.17.0", path = "../nu-plugin"}
-nu-protocol = {version = "0.17.0", path = "../nu-protocol"}
-nu-source = {version = "0.17.0", path = "../nu-source"}
-nu-table = {version = "0.17.0", path = "../nu-table"}
-nu-test-support = {version = "0.17.0", path = "../nu-test-support"}
-nu-value-ext = {version = "0.17.0", path = "../nu-value-ext"}
+nu-data = {version = "0.25.1", path = "../nu-data"}
+nu-errors = {version = "0.25.1", path = "../nu-errors"}
+nu-json = {version = "0.25.1", path = "../nu-json"}
+nu-parser = {version = "0.25.1", path = "../nu-parser"}
+nu-plugin = {version = "0.25.1", path = "../nu-plugin"}
+nu-protocol = {version = "0.25.1", path = "../nu-protocol"}
+nu-source = {version = "0.25.1", path = "../nu-source"}
+nu-stream = {version = "0.25.1", path = "../nu-stream"}
+nu-table = {version = "0.25.1", path = "../nu-table"}
+nu-test-support = {version = "0.25.1", path = "../nu-test-support"}
+nu-value-ext = {version = "0.25.1", path = "../nu-value-ext"}
 
+Inflector = "0.11"
 ansi_term = "0.12.1"
-app_dirs = "1.2.1"
+arboard = {version = "1.1.0", optional = true}
 async-recursion = "0.3.1"
-async-trait = "0.1.36"
-base64 = "0.12.3"
-bigdecimal = {version = "0.1.2", features = ["serde"]}
-byte-unit = "3.1.3"
-bytes = "0.5.5"
-calamine = "0.16"
-chrono = {version = "0.4.11", features = ["serde"]}
-clap = "2.33.1"
+async-trait = "0.1.40"
+base64 = "0.13.0"
+bigdecimal = {version = "0.2.0", features = ["serde"]}
+byte-unit = "4.0.9"
+bytes = "0.5.6"
+calamine = "0.16.1"
+chrono = {version = "0.4.15", features = ["serde"]}
+chrono-tz = "0.5.3"
+clap = "2.33.3"
 codespan-reporting = "0.9.5"
-csv = "1.1"
-ctrlc = {version = "3.1.4", optional = true}
+csv = "1.1.3"
+ctrlc = {version = "3.1.6", optional = true}
 derive-new = "0.5.8"
-directories = {version = "2.0.2", optional = true}
-dirs = {version = "2.0.2", optional = true}
+directories = {version = "3.0.1", optional = true}
+dirs = {version = "3.0.1", optional = true}
+dtparse = "1.2.0"
 dunce = "1.0.1"
 eml-parser = "0.1.0"
+encoding_rs = "0.8.24"
 filesize = "0.2.0"
-futures = {version = "0.3", features = ["compat", "io-compat"]}
+fs_extra = "1.2.0"
+futures = {version = "0.3.5", features = ["compat", "io-compat"]}
 futures-util = "0.3.5"
-futures_codec = "0.4"
+futures_codec = "0.4.1"
 getset = "0.1.1"
-git2 = {version = "0.13.6", default_features = false, optional = true}
+git2 = {version = "0.13.11", default_features = false, optional = true}
 glob = "0.3.0"
-hex = "0.4"
+heim = {version = "0.1.0-rc.1", optional = true}
 htmlescape = "0.3.1"
-ical = "0.6.*"
+ical = "0.6.0"
 ichwh = {version = "0.3.4", optional = true}
-indexmap = {version = "1.4.0", features = ["serde-1"]}
+indexmap = {version = "1.6.0", features = ["serde-1"]}
 itertools = "0.9.0"
-log = "0.4.8"
-meval = "0.2"
-natural = "0.5.0"
-num-bigint = {version = "0.2.6", features = ["serde"]}
-num-format = {version = "0.4", features = ["with-num-bigint"]}
-num-traits = "0.2.11"
+lazy_static = "1.*"
+log = "0.4.11"
+meval = "0.2.0"
+num-bigint = {version = "0.3.0", features = ["serde"]}
+num-format = {version = "0.4.0", features = ["with-num-bigint"]}
+num-traits = "0.2.12"
 parking_lot = "0.11.0"
 pin-utils = "0.1.0"
-pretty-hex = "0.1.1"
-pretty_env_logger = "0.4.0"
-ptree = {version = "0.2", optional = true}
+pretty-hex = "0.2.0"
+ptree = {version = "0.3.0", optional = true}
 query_interface = "0.3.5"
-rand = "0.7"
-regex = "1"
+quick-xml = "0.18.1"
+rand = "0.7.3"
+rayon = "1.4.0"
+regex = "1.3.9"
 roxmltree = "0.13.0"
-rustyline = "6.2.0"
-serde = {version = "1.0.114", features = ["derive"]}
-serde-hjson = "0.9.1"
+rust-embed = "5.6.0"
+rustyline = {version = "6.3.0", optional = true}
+serde = {version = "1.0.115", features = ["derive"]}
 serde_bytes = "0.11.5"
 serde_ini = "0.2.0"
-serde_json = "1.0.55"
-serde_urlencoded = "0.6.1"
-serde_yaml = "0.8"
+serde_json = "1.0.57"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.13"
 sha2 = "0.9.1"
 shellexpand = "2.0.0"
 strip-ansi-escapes = "0.1.0"
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
 tempfile = "3.1.0"
-term = {version = "0.5.2", optional = true}
+term = {version = "0.6.1", optional = true}
 term_size = "0.3.2"
 termcolor = "1.1.0"
+titlecase = "1.0"
 toml = "0.5.6"
-typetag = "0.1.5"
-umask = "1.0.0"
-unicode-xid = "0.2.1"
+trash = {version = "1.2.0", optional = true}
+unicode-segmentation = "1.6.0"
+uom = {version = "0.30.0", features = ["f64", "try-from"]}
+url = "2.1.1"
 uuid_crate = {package = "uuid", version = "0.8.1", features = ["v4"], optional = true}
-which = {version = "4.0.1", optional = true}
-
-clipboard = {version = "0.5", optional = true}
-encoding_rs = "0.8.23"
-rayon = "1.3.1"
-starship = {version = "0.43.0", optional = true}
-trash = {version = "1.0.1", optional = true}
+which = {version = "4.0.2", optional = true}
+zip = {version = "0.5.7", optional = true}
 
 [target.'cfg(unix)'.dependencies]
+umask = "1.0.0"
 users = "0.10.0"
 
 # TODO this will be possible with new dependency resolver
@@ -106,17 +116,18 @@ users = "0.10.0"
 [dependencies.rusqlite]
 features = ["bundled", "blob"]
 optional = true
-version = "0.23.1"
+version = "0.24.2"
 
 [build-dependencies]
-nu-build = {version = "0.17.0", path = "../nu-build"}
+shadow-rs = "0.5"
 
 [dev-dependencies]
-quickcheck = "0.9"
-quickcheck_macros = "0.9"
+quickcheck = "0.9.2"
+quickcheck_macros = "0.9.1"
 
 [features]
-clipboard-cli = ["clipboard"]
+clipboard-cli = ["arboard"]
+rich-benchmark = ["heim"]
+rustyline-support = ["rustyline"]
 stable = []
-starship-prompt = ["starship"]
 trash-support = ["trash"]

crates/nu-cli/build.rs

@@ -0,0 +1,3 @@
+fn main() -> shadow_rs::SdResult<()> {
+    shadow_rs::new()
+}

crates/nu-cli/src/commands.rs

@@ -4,7 +4,6 @@ pub(crate) mod macros;
 mod from_delimited_data;
 mod to_delimited_data;
 
-pub(crate) mod alias;
 pub(crate) mod ansi;
 pub(crate) mod append;
 pub(crate) mod args;
@@ -17,8 +16,9 @@ pub(crate) mod build_string;
 pub(crate) mod cal;
 pub(crate) mod cd;
 pub(crate) mod char_;
+pub(crate) mod chart;
 pub(crate) mod classified;
-#[cfg(feature = "clipboard")]
+#[cfg(feature = "clipboard-cli")]
 pub(crate) mod clip;
 pub(crate) mod command;
 pub(crate) mod compact;
@@ -28,16 +28,22 @@ pub(crate) mod count;
 pub(crate) mod cp;
 pub(crate) mod date;
 pub(crate) mod debug;
+pub(crate) mod def;
 pub(crate) mod default;
+pub(crate) mod default_context;
+pub(crate) mod describe;
 pub(crate) mod do_;
 pub(crate) mod drop;
 pub(crate) mod du;
 pub(crate) mod each;
 pub(crate) mod echo;
+pub(crate) mod empty;
 pub(crate) mod enter;
 pub(crate) mod every;
+pub(crate) mod exec;
 pub(crate) mod exit;
 pub(crate) mod first;
+pub(crate) mod flatten;
 pub(crate) mod format;
 pub(crate) mod from;
 pub(crate) mod from_csv;
@@ -57,15 +63,18 @@ pub(crate) mod from_yaml;
 pub(crate) mod get;
 pub(crate) mod group_by;
 pub(crate) mod group_by_date;
+pub(crate) mod hash_;
 pub(crate) mod headers;
 pub(crate) mod help;
 pub(crate) mod histogram;
 pub(crate) mod history;
 pub(crate) mod if_;
 pub(crate) mod insert;
-pub(crate) mod is_empty;
+pub(crate) mod into_int;
 pub(crate) mod keep;
 pub(crate) mod last;
+pub(crate) mod let_;
+pub(crate) mod let_env;
 pub(crate) mod lines;
 pub(crate) mod ls;
 pub(crate) mod math;
@@ -74,28 +83,33 @@ pub(crate) mod mkdir;
 pub(crate) mod move_;
 pub(crate) mod next;
 pub(crate) mod nth;
+pub(crate) mod nu;
 pub(crate) mod open;
 pub(crate) mod parse;
+pub(crate) mod path;
 pub(crate) mod pivot;
-pub(crate) mod plugin;
 pub(crate) mod prepend;
 pub(crate) mod prev;
 pub(crate) mod pwd;
 pub(crate) mod random;
 pub(crate) mod range;
+pub(crate) mod reduce;
 pub(crate) mod reject;
 pub(crate) mod rename;
 pub(crate) mod reverse;
 pub(crate) mod rm;
-pub(crate) mod run_alias;
 pub(crate) mod run_external;
 pub(crate) mod save;
 pub(crate) mod select;
+pub(crate) mod seq;
+pub(crate) mod seq_dates;
 pub(crate) mod shells;
 pub(crate) mod shuffle;
 pub(crate) mod size;
 pub(crate) mod skip;
+pub(crate) mod sleep;
 pub(crate) mod sort_by;
+pub(crate) mod source;
 pub(crate) mod split;
 pub(crate) mod split_by;
 pub(crate) mod str_;
@@ -109,12 +123,12 @@ pub(crate) mod to_md;
 pub(crate) mod to_toml;
 pub(crate) mod to_tsv;
 pub(crate) mod to_url;
+pub(crate) mod to_xml;
 pub(crate) mod to_yaml;
-pub(crate) mod trim;
 pub(crate) mod uniq;
 pub(crate) mod update;
+pub(crate) mod url_;
 pub(crate) mod version;
-pub(crate) mod what;
 pub(crate) mod where_;
 pub(crate) mod which_;
 pub(crate) mod with_env;
@@ -126,9 +140,8 @@ pub(crate) use command::{
     whole_stream_command, Command, Example, UnevaluatedCallInfo, WholeStreamCommand,
 };
 
-pub(crate) use alias::Alias;
 pub(crate) use ansi::Ansi;
-pub(crate) use append::Append;
+pub(crate) use append::Command as Append;
 pub(crate) use autoenv::Autoenv;
 pub(crate) use autoenv_trust::AutoenvTrust;
 pub(crate) use autoenv_untrust::AutoenvUnTrust;
@@ -136,23 +149,29 @@ pub(crate) use benchmark::Benchmark;
 pub(crate) use build_string::BuildString;
 pub(crate) use cal::Cal;
 pub(crate) use char_::Char;
+pub(crate) use chart::Chart;
 pub(crate) use compact::Compact;
 pub(crate) use config::{
     Config, ConfigClear, ConfigGet, ConfigLoad, ConfigPath, ConfigRemove, ConfigSet, ConfigSetInto,
 };
 pub(crate) use count::Count;
 pub(crate) use cp::Cpy;
-pub(crate) use date::Date;
+pub(crate) use date::{Date, DateFormat, DateListTimeZone, DateNow, DateToTable, DateToTimeZone};
 pub(crate) use debug::Debug;
+pub(crate) use def::Def;
 pub(crate) use default::Default;
+pub(crate) use describe::Describe;
 pub(crate) use do_::Do;
 pub(crate) use drop::Drop;
 pub(crate) use du::Du;
 pub(crate) use each::Each;
+pub(crate) use each::EachGroup;
+pub(crate) use each::EachWindow;
 pub(crate) use echo::Echo;
+pub(crate) use empty::Command as Empty;
 pub(crate) use if_::If;
-pub(crate) use is_empty::IsEmpty;
-pub(crate) use update::Update;
+pub(crate) use nu::NuPlugin;
+pub(crate) use update::Command as Update;
 pub(crate) mod kill;
 pub(crate) use kill::Kill;
 pub(crate) mod clear;
@@ -160,9 +179,11 @@ pub(crate) use clear::Clear;
 pub(crate) mod touch;
 pub(crate) use enter::Enter;
 pub(crate) use every::Every;
+pub(crate) use exec::Exec;
 pub(crate) use exit::Exit;
 pub(crate) use first::First;
-pub(crate) use format::Format;
+pub(crate) use flatten::Command as Flatten;
+pub(crate) use format::{FileSize, Format};
 pub(crate) use from::From;
 pub(crate) use from_csv::FromCSV;
 pub(crate) use from_eml::FromEML;
@@ -180,36 +201,47 @@ pub(crate) use from_xml::FromXML;
 pub(crate) use from_yaml::FromYAML;
 pub(crate) use from_yaml::FromYML;
 pub(crate) use get::Get;
-pub(crate) use group_by::GroupBy;
+pub(crate) use group_by::Command as GroupBy;
 pub(crate) use group_by_date::GroupByDate;
+pub(crate) use hash_::{Hash, HashBase64};
 pub(crate) use headers::Headers;
 pub(crate) use help::Help;
 pub(crate) use histogram::Histogram;
 pub(crate) use history::History;
-pub(crate) use insert::Insert;
+pub(crate) use insert::Command as Insert;
+pub(crate) use into_int::IntoInt;
 pub(crate) use keep::{Keep, KeepUntil, KeepWhile};
 pub(crate) use last::Last;
+pub(crate) use let_::Let;
+pub(crate) use let_env::LetEnv;
 pub(crate) use lines::Lines;
 pub(crate) use ls::Ls;
 pub(crate) use math::{
-    Math, MathAverage, MathEval, MathMaximum, MathMedian, MathMinimum, MathMode, MathStddev,
-    MathSummation, MathVariance,
+    Math, MathAbs, MathAverage, MathCeil, MathEval, MathFloor, MathMaximum, MathMedian,
+    MathMinimum, MathMode, MathProduct, MathRound, MathStddev, MathSummation, MathVariance,
 };
 pub(crate) use merge::Merge;
 pub(crate) use mkdir::Mkdir;
-pub(crate) use move_::{Move, MoveColumn, Mv};
+pub(crate) use move_::{Move, Mv};
 pub(crate) use next::Next;
 pub(crate) use nth::Nth;
 pub(crate) use open::Open;
 pub(crate) use parse::Parse;
+pub(crate) use path::{
+    PathBasename, PathCommand, PathDirname, PathExists, PathExpand, PathExtension, PathFilestem,
+    PathType,
+};
 pub(crate) use pivot::Pivot;
 pub(crate) use prepend::Prepend;
 pub(crate) use prev::Previous;
 pub(crate) use pwd::Pwd;
 #[cfg(feature = "uuid_crate")]
 pub(crate) use random::RandomUUID;
-pub(crate) use random::{Random, RandomBool, RandomDice};
+pub(crate) use random::{
+    Random, RandomBool, RandomChars, RandomDecimal, RandomDice, RandomInteger,
+};
 pub(crate) use range::Range;
+pub(crate) use reduce::Reduce;
 pub(crate) use reject::Reject;
 pub(crate) use rename::Rename;
 pub(crate) use reverse::Reverse;
@@ -217,16 +249,22 @@ pub(crate) use rm::Remove;
 pub(crate) use run_external::RunExternalCommand;
 pub(crate) use save::Save;
 pub(crate) use select::Select;
+pub(crate) use seq::Seq;
+pub(crate) use seq_dates::SeqDates;
 pub(crate) use shells::Shells;
 pub(crate) use shuffle::Shuffle;
 pub(crate) use size::Size;
 pub(crate) use skip::{Skip, SkipUntil, SkipWhile};
+pub(crate) use sleep::Sleep;
 pub(crate) use sort_by::SortBy;
+pub(crate) use source::Source;
 pub(crate) use split::{Split, SplitChars, SplitColumn, SplitRow};
 pub(crate) use split_by::SplitBy;
 pub(crate) use str_::{
-    Str, StrCapitalize, StrCollect, StrDowncase, StrFindReplace, StrFrom, StrLength, StrReverse,
-    StrSet, StrSubstring, StrToDatetime, StrToDecimal, StrToInteger, StrTrim, StrUpcase,
+    Str, StrCamelCase, StrCapitalize, StrCollect, StrContains, StrDowncase, StrEndsWith,
+    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLPad, StrLength, StrPascalCase, StrRPad,
+    StrReverse, StrScreamingSnakeCase, StrSet, StrSnakeCase, StrStartsWith, StrSubstring,
+    StrToDatetime, StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
 };
 pub(crate) use table::Table;
 pub(crate) use tags::Tags;
@@ -238,13 +276,56 @@ pub(crate) use to_md::ToMarkdown;
 pub(crate) use to_toml::ToTOML;
 pub(crate) use to_tsv::ToTSV;
 pub(crate) use to_url::ToURL;
+pub(crate) use to_xml::ToXML;
 pub(crate) use to_yaml::ToYAML;
 pub(crate) use touch::Touch;
-pub(crate) use trim::Trim;
 pub(crate) use uniq::Uniq;
+pub(crate) use url_::{UrlCommand, UrlHost, UrlPath, UrlQuery, UrlScheme};
 pub(crate) use version::Version;
-pub(crate) use what::What;
 pub(crate) use where_::Where;
 pub(crate) use which_::Which;
 pub(crate) use with_env::WithEnv;
 pub(crate) use wrap::Wrap;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::commands::whole_stream_command;
+    use crate::examples::{test_anchors, test_examples};
+    use nu_errors::ShellError;
+
+    fn full_tests() -> Vec<Command> {
+        vec![
+            whole_stream_command(Append),
+            whole_stream_command(GroupBy),
+            whole_stream_command(Insert),
+            whole_stream_command(Move),
+            whole_stream_command(Update),
+            whole_stream_command(Empty),
+        ]
+    }
+
+    fn only_examples() -> Vec<Command> {
+        let mut commands = full_tests();
+        commands.extend(vec![whole_stream_command(Flatten)]);
+        commands
+    }
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        for cmd in only_examples() {
+            test_examples(cmd)?;
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn tracks_metadata() -> Result<(), ShellError> {
+        for cmd in full_tests() {
+            test_anchors(cmd)?;
+        }
+
+        Ok(())
+    }
+}

crates/nu-cli/src/commands/alias.rs

@@ -1,151 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::data::config;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{
-    hir::Block, CommandAction, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
-use nu_source::Tagged;
-
-pub struct Alias;
-
-#[derive(Deserialize)]
-pub struct AliasArgs {
-    pub name: Tagged<String>,
-    pub args: Vec<Value>,
-    pub block: Block,
-    pub save: Option<bool>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Alias {
-    fn name(&self) -> &str {
-        "alias"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("alias")
-            .required("name", SyntaxShape::String, "the name of the alias")
-            .required("args", SyntaxShape::Table, "the arguments to the alias")
-            .required(
-                "block",
-                SyntaxShape::Block,
-                "the block to run as the body of the alias",
-            )
-            .switch("save", "save the alias to your config", Some('s'))
-    }
-
-    fn usage(&self) -> &str {
-        "Define a shortcut for another command."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        alias(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "An alias without parameters",
-                example: "alias say-hi [] { echo 'Hello!' }",
-                result: None,
-            },
-            Example {
-                description: "An alias with a single parameter",
-                example: "alias l [x] { ls $x }",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub async fn alias(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let mut raw_input = args.raw_input.clone();
-    let (
-        AliasArgs {
-            name,
-            args: list,
-            block,
-            save,
-        },
-        _ctx,
-    ) = args.process(&registry).await?;
-    let mut processed_args: Vec<String> = vec![];
-
-    if let Some(true) = save {
-        let mut result = crate::data::config::read(name.clone().tag, &None)?;
-
-        // process the alias to remove the --save flag
-        let left_brace = raw_input.find('{').unwrap_or(0);
-        let right_brace = raw_input.rfind('}').unwrap_or_else(|| raw_input.len());
-        let left = raw_input[..left_brace]
-            .replace("--save", "")
-            .replace("-s", "");
-        let right = raw_input[right_brace..]
-            .replace("--save", "")
-            .replace("-s", "");
-        raw_input = format!("{}{}{}", left, &raw_input[left_brace..right_brace], right);
-
-        // create a value from raw_input alias
-        let alias: Value = raw_input.trim().to_string().into();
-        let alias_start = raw_input.find('[').unwrap_or(0); // used to check if the same alias already exists
-
-        // add to startup if alias doesn't exist and replce if it does
-        match result.get_mut("startup") {
-            Some(startup) => {
-                if let UntaggedValue::Table(ref mut commands) = startup.value {
-                    if let Some(command) = commands.iter_mut().find(|command| {
-                        let cmd_str = command.as_string().unwrap_or_default();
-                        cmd_str.starts_with(&raw_input[..alias_start])
-                    }) {
-                        *command = alias;
-                    } else {
-                        commands.push(alias);
-                    }
-                }
-            }
-            None => {
-                let table = UntaggedValue::table(&[alias]);
-                result.insert("startup".to_string(), table.into_value(Tag::default()));
-            }
-        }
-        config::write(&result, &None)?;
-    }
-
-    for item in list.iter() {
-        if let Ok(string) = item.as_string() {
-            processed_args.push(format!("${}", string));
-        } else {
-            return Err(ShellError::labeled_error(
-                "Expected a string",
-                "expected a string",
-                item.tag(),
-            ));
-        }
-    }
-
-    Ok(OutputStream::one(ReturnSuccess::action(
-        CommandAction::AddAlias(name.to_string(), processed_args, block),
-    )))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Alias;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Alias {})
-    }
-}

crates/nu-cli/src/commands/ansi.rs

@@ -1,13 +1,17 @@
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
+use ansi_term::Color;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
 
 pub struct Ansi;
 
 #[derive(Deserialize)]
 struct AnsiArgs {
     color: Value,
+    escape: Option<Tagged<String>>,
+    osc: Option<Tagged<String>>,
 }
 
 #[async_trait]
@@ -17,15 +21,70 @@ impl WholeStreamCommand for Ansi {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("ansi").required(
-            "color",
-            SyntaxShape::Any,
-            "the name of the color to use or 'reset' to reset the color",
-        )
+        Signature::build("ansi")
+            .optional(
+                "color",
+                SyntaxShape::Any,
+                "the name of the color to use or 'reset' to reset the color",
+            )
+            .named(
+                "escape", // \x1b
+                SyntaxShape::Any,
+                "escape sequence without the escape character(s)",
+                Some('e'),
+            )
+            .named(
+                "osc",
+                SyntaxShape::Any,
+                "operating system command (ocs) escape sequence without the escape character(s)",
+                Some('o'),
+            )
     }
 
     fn usage(&self) -> &str {
-        "Output ANSI codes to change color"
+        r#"Output ANSI codes to change color
+
+For escape sequences:
+Escape: '\x1b[' is not required for --escape parameter
+Format: #(;#)m
+Example: 1;31m for bold red or 2;37;41m for dimmed white fg with red bg
+There can be multiple text formatting sequence numbers
+separated by a ; and ending with an m where the # is of the
+following values:
+    attributes
+    0    reset / normal display
+    1    bold or increased intensity
+    2    faint or decreased intensity
+    3    italic on (non-mono font)
+    4    underline on
+    5    slow blink on
+    6    fast blink on
+    7    reverse video on
+    8    nondisplayed (invisible) on
+    9    strike-through on
+
+    foreground/bright colors    background/bright colors
+    30/90    black              40/100    black
+    31/91    red                41/101    red
+    32/92    green              42/102    green
+    33/93    yellow             43/103    yellow
+    34/94    blue               44/104    blue
+    35/95    magenta            45/105    magenta
+    36/96    cyan               46/106    cyan
+    37/97    white              47/107    white
+    https://en.wikipedia.org/wiki/ANSI_escape_code
+
+OSC: '\x1b]' is not required for --osc parameter
+Example: echo [$(ansi -o '0') 'some title' $(char bel)] | str collect
+Format: #
+    0 Set window title and icon name
+    1 Set icon name
+    2 Set window title
+    4 Set/read color palette
+    9 iTerm2 Grown notifications
+    10 Set foreground color (x11 color spec)
+    11 Set background color (x11 color spec)
+    ... others"#
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -48,18 +107,53 @@ impl WholeStreamCommand for Ansi {
                     "\u{1b}[1;31mHello \u{1b}[1;32mNu \u{1b}[1;35mWorld",
                 )]),
             },
+            Example {
+                description:
+                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
+                example: r#"echo [$(ansi -e '3;93;41m') Hello $(ansi reset) " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
+                result: Some(vec![Value::from(
+                    "\u{1b}[3;93;41mHello\u{1b}[0m \u{1b}[1;32mNu \u{1b}[1;35mWorld",
+                )]),
+            },
         ]
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let (AnsiArgs { color }, _) = args.process(&registry).await?;
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (AnsiArgs { color, escape, osc }, _) = args.process().await?;
+
+        if let Some(e) = escape {
+            let esc_vec: Vec<char> = e.item.chars().collect();
+            if esc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    e.tag(),
+                ));
+            }
+            let output = format!("\x1b[{}", e.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(e.tag()),
+            )));
+        }
+
+        if let Some(o) = osc {
+            let osc_vec: Vec<char> = o.item.chars().collect();
+            if osc_vec[0] == '\\' {
+                return Err(ShellError::labeled_error(
+                    "no need for escape characters",
+                    "no need for escape characters",
+                    o.tag(),
+                ));
+            }
+            //Operating system command aka osc  ESC ] <- note the right brace, not left brace for osc
+            // OCS's need to end with a bell '\x07' char
+            let output = format!("\x1b]{};", o.item);
+            return Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::string(output).into_value(o.tag()),
+            )));
+        }
 
         let color_string = color.as_string()?;
-
         let ansi_code = str_to_ansi_color(color_string);
 
         if let Some(output) = ansi_code {
@@ -73,63 +167,60 @@ impl WholeStreamCommand for Ansi {
                 color.tag(),
             ))
         }
+        // }
     }
 }
 
-fn str_to_ansi_color(s: String) -> Option<String> {
+pub fn str_to_ansi_color(s: String) -> Option<String> {
     match s.as_str() {
-        "g" | "green" => Some(ansi_term::Color::Green.prefix().to_string()),
-        "gb" | "green_bold" => Some(ansi_term::Color::Green.bold().prefix().to_string()),
-        "gu" | "green_underline" => Some(ansi_term::Color::Green.underline().prefix().to_string()),
-        "gi" | "green_italic" => Some(ansi_term::Color::Green.italic().prefix().to_string()),
-        "gd" | "green_dimmed" => Some(ansi_term::Color::Green.dimmed().prefix().to_string()),
-        "gr" | "green_reverse" => Some(ansi_term::Color::Green.reverse().prefix().to_string()),
-        "r" | "red" => Some(ansi_term::Color::Red.prefix().to_string()),
-        "rb" | "red_bold" => Some(ansi_term::Color::Red.bold().prefix().to_string()),
-        "ru" | "red_underline" => Some(ansi_term::Color::Red.underline().prefix().to_string()),
-        "ri" | "red_italic" => Some(ansi_term::Color::Red.italic().prefix().to_string()),
-        "rd" | "red_dimmed" => Some(ansi_term::Color::Red.dimmed().prefix().to_string()),
-        "rr" | "red_reverse" => Some(ansi_term::Color::Red.reverse().prefix().to_string()),
-        "u" | "blue" => Some(ansi_term::Color::Blue.prefix().to_string()),
-        "ub" | "blue_bold" => Some(ansi_term::Color::Blue.bold().prefix().to_string()),
-        "uu" | "blue_underline" => Some(ansi_term::Color::Blue.underline().prefix().to_string()),
-        "ui" | "blue_italic" => Some(ansi_term::Color::Blue.italic().prefix().to_string()),
-        "ud" | "blue_dimmed" => Some(ansi_term::Color::Blue.dimmed().prefix().to_string()),
-        "ur" | "blue_reverse" => Some(ansi_term::Color::Blue.reverse().prefix().to_string()),
-        "b" | "black" => Some(ansi_term::Color::Black.prefix().to_string()),
-        "bb" | "black_bold" => Some(ansi_term::Color::Black.bold().prefix().to_string()),
-        "bu" | "black_underline" => Some(ansi_term::Color::Black.underline().prefix().to_string()),
-        "bi" | "black_italic" => Some(ansi_term::Color::Black.italic().prefix().to_string()),
-        "bd" | "black_dimmed" => Some(ansi_term::Color::Black.dimmed().prefix().to_string()),
-        "br" | "black_reverse" => Some(ansi_term::Color::Black.reverse().prefix().to_string()),
-        "y" | "yellow" => Some(ansi_term::Color::Yellow.prefix().to_string()),
-        "yb" | "yellow_bold" => Some(ansi_term::Color::Yellow.bold().prefix().to_string()),
-        "yu" | "yellow_underline" => {
-            Some(ansi_term::Color::Yellow.underline().prefix().to_string())
-        }
-        "yi" | "yellow_italic" => Some(ansi_term::Color::Yellow.italic().prefix().to_string()),
-        "yd" | "yellow_dimmed" => Some(ansi_term::Color::Yellow.dimmed().prefix().to_string()),
-        "yr" | "yellow_reverse" => Some(ansi_term::Color::Yellow.reverse().prefix().to_string()),
-        "p" | "purple" => Some(ansi_term::Color::Purple.prefix().to_string()),
-        "pb" | "purple_bold" => Some(ansi_term::Color::Purple.bold().prefix().to_string()),
-        "pu" | "purple_underline" => {
-            Some(ansi_term::Color::Purple.underline().prefix().to_string())
-        }
-        "pi" | "purple_italic" => Some(ansi_term::Color::Purple.italic().prefix().to_string()),
-        "pd" | "purple_dimmed" => Some(ansi_term::Color::Purple.dimmed().prefix().to_string()),
-        "pr" | "purple_reverse" => Some(ansi_term::Color::Purple.reverse().prefix().to_string()),
-        "c" | "cyan" => Some(ansi_term::Color::Cyan.prefix().to_string()),
-        "cb" | "cyan_bold" => Some(ansi_term::Color::Cyan.bold().prefix().to_string()),
-        "cu" | "cyan_underline" => Some(ansi_term::Color::Cyan.underline().prefix().to_string()),
-        "ci" | "cyan_italic" => Some(ansi_term::Color::Cyan.italic().prefix().to_string()),
-        "cd" | "cyan_dimmed" => Some(ansi_term::Color::Cyan.dimmed().prefix().to_string()),
-        "cr" | "cyan_reverse" => Some(ansi_term::Color::Cyan.reverse().prefix().to_string()),
-        "w" | "white" => Some(ansi_term::Color::White.prefix().to_string()),
-        "wb" | "white_bold" => Some(ansi_term::Color::White.bold().prefix().to_string()),
-        "wu" | "white_underline" => Some(ansi_term::Color::White.underline().prefix().to_string()),
-        "wi" | "white_italic" => Some(ansi_term::Color::White.italic().prefix().to_string()),
-        "wd" | "white_dimmed" => Some(ansi_term::Color::White.dimmed().prefix().to_string()),
-        "wr" | "white_reverse" => Some(ansi_term::Color::White.reverse().prefix().to_string()),
+        "g" | "green" => Some(Color::Green.prefix().to_string()),
+        "gb" | "green_bold" => Some(Color::Green.bold().prefix().to_string()),
+        "gu" | "green_underline" => Some(Color::Green.underline().prefix().to_string()),
+        "gi" | "green_italic" => Some(Color::Green.italic().prefix().to_string()),
+        "gd" | "green_dimmed" => Some(Color::Green.dimmed().prefix().to_string()),
+        "gr" | "green_reverse" => Some(Color::Green.reverse().prefix().to_string()),
+        "r" | "red" => Some(Color::Red.prefix().to_string()),
+        "rb" | "red_bold" => Some(Color::Red.bold().prefix().to_string()),
+        "ru" | "red_underline" => Some(Color::Red.underline().prefix().to_string()),
+        "ri" | "red_italic" => Some(Color::Red.italic().prefix().to_string()),
+        "rd" | "red_dimmed" => Some(Color::Red.dimmed().prefix().to_string()),
+        "rr" | "red_reverse" => Some(Color::Red.reverse().prefix().to_string()),
+        "u" | "blue" => Some(Color::Blue.prefix().to_string()),
+        "ub" | "blue_bold" => Some(Color::Blue.bold().prefix().to_string()),
+        "uu" | "blue_underline" => Some(Color::Blue.underline().prefix().to_string()),
+        "ui" | "blue_italic" => Some(Color::Blue.italic().prefix().to_string()),
+        "ud" | "blue_dimmed" => Some(Color::Blue.dimmed().prefix().to_string()),
+        "ur" | "blue_reverse" => Some(Color::Blue.reverse().prefix().to_string()),
+        "b" | "black" => Some(Color::Black.prefix().to_string()),
+        "bb" | "black_bold" => Some(Color::Black.bold().prefix().to_string()),
+        "bu" | "black_underline" => Some(Color::Black.underline().prefix().to_string()),
+        "bi" | "black_italic" => Some(Color::Black.italic().prefix().to_string()),
+        "bd" | "black_dimmed" => Some(Color::Black.dimmed().prefix().to_string()),
+        "br" | "black_reverse" => Some(Color::Black.reverse().prefix().to_string()),
+        "y" | "yellow" => Some(Color::Yellow.prefix().to_string()),
+        "yb" | "yellow_bold" => Some(Color::Yellow.bold().prefix().to_string()),
+        "yu" | "yellow_underline" => Some(Color::Yellow.underline().prefix().to_string()),
+        "yi" | "yellow_italic" => Some(Color::Yellow.italic().prefix().to_string()),
+        "yd" | "yellow_dimmed" => Some(Color::Yellow.dimmed().prefix().to_string()),
+        "yr" | "yellow_reverse" => Some(Color::Yellow.reverse().prefix().to_string()),
+        "p" | "purple" => Some(Color::Purple.prefix().to_string()),
+        "pb" | "purple_bold" => Some(Color::Purple.bold().prefix().to_string()),
+        "pu" | "purple_underline" => Some(Color::Purple.underline().prefix().to_string()),
+        "pi" | "purple_italic" => Some(Color::Purple.italic().prefix().to_string()),
+        "pd" | "purple_dimmed" => Some(Color::Purple.dimmed().prefix().to_string()),
+        "pr" | "purple_reverse" => Some(Color::Purple.reverse().prefix().to_string()),
+        "c" | "cyan" => Some(Color::Cyan.prefix().to_string()),
+        "cb" | "cyan_bold" => Some(Color::Cyan.bold().prefix().to_string()),
+        "cu" | "cyan_underline" => Some(Color::Cyan.underline().prefix().to_string()),
+        "ci" | "cyan_italic" => Some(Color::Cyan.italic().prefix().to_string()),
+        "cd" | "cyan_dimmed" => Some(Color::Cyan.dimmed().prefix().to_string()),
+        "cr" | "cyan_reverse" => Some(Color::Cyan.reverse().prefix().to_string()),
+        "w" | "white" => Some(Color::White.prefix().to_string()),
+        "wb" | "white_bold" => Some(Color::White.bold().prefix().to_string()),
+        "wu" | "white_underline" => Some(Color::White.underline().prefix().to_string()),
+        "wi" | "white_italic" => Some(Color::White.italic().prefix().to_string()),
+        "wd" | "white_dimmed" => Some(Color::White.dimmed().prefix().to_string()),
+        "wr" | "white_reverse" => Some(Color::White.reverse().prefix().to_string()),
         "reset" => Some("\x1b[0m".to_owned()),
         _ => None,
     }
@@ -138,11 +229,12 @@ fn str_to_ansi_color(s: String) -> Option<String> {
 #[cfg(test)]
 mod tests {
     use super::Ansi;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Ansi {})
+        Ok(test_examples(Ansi {})?)
     }
 }

crates/nu-cli/src/commands/append.rs

@@ -1,18 +1,17 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 
 #[derive(Deserialize)]
-struct AppendArgs {
-    row: Value,
+struct Arguments {
+    value: Value,
 }
 
-pub struct Append;
+pub struct Command;
 
 #[async_trait]
-impl WholeStreamCommand for Append {
+impl WholeStreamCommand for Command {
     fn name(&self) -> &str {
         "append"
     }
@@ -26,43 +25,61 @@ impl WholeStreamCommand for Append {
     }
 
     fn usage(&self) -> &str {
-        "Append the given row to the table"
+        "Append a row to the table"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let (AppendArgs { row }, input) = args.process(registry).await?;
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (Arguments { mut value }, input) = args.process().await?;
 
-        let eos = futures::stream::iter(vec![row]);
+        let input: Vec<Value> = input.collect().await;
 
-        Ok(input.chain(eos).to_output_stream())
+        if let Some(first) = input.get(0) {
+            value.tag = first.tag();
+        }
+
+        // Checks if we are trying to append a row literal
+        if let Value {
+            value: UntaggedValue::Table(values),
+            tag,
+        } = &value
+        {
+            if values.len() == 1 && values[0].is_row() {
+                value = values[0].value.clone().into_value(tag);
+            }
+        }
+
+        Ok(futures::stream::iter(
+            input
+                .into_iter()
+                .chain(vec![value])
+                .map(ReturnSuccess::value),
+        )
+        .to_output_stream())
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Add something to the end of a list or table",
-            example: "echo [1 2 3] | append 4",
-            result: Some(vec![
-                UntaggedValue::int(1).into(),
-                UntaggedValue::int(2).into(),
-                UntaggedValue::int(3).into(),
-                UntaggedValue::int(4).into(),
-            ]),
-        }]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Append;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Append {})
+        use nu_protocol::row;
+
+        vec![
+            Example {
+                description: "Add values to the end of the table",
+                example: "echo [1 2 3] | append 4",
+                result: Some(vec![
+                    UntaggedValue::int(1).into(),
+                    UntaggedValue::int(2).into(),
+                    UntaggedValue::int(3).into(),
+                    UntaggedValue::int(4).into(),
+                ]),
+            },
+            Example {
+                description: "Add row value to the end of the table",
+                example: "echo [[country]; [Ecuador] ['New Zealand']] | append [[country]; [USA]]",
+                result: Some(vec![
+                    row! { "country".into() => Value::from("Ecuador")},
+                    row! { "country".into() => Value::from("New Zealand")},
+                    row! { "country".into() => Value::from("USA")},
+                ]),
+            },
+        ]
     }
 }

crates/nu-cli/src/commands/autoenv.rs

@@ -55,20 +55,15 @@ impl WholeStreamCommand for Autoenv {
 The file can contain several optional sections:
     env: environment variables to set when visiting the directory. The variables are unset after leaving the directory and any overwritten values are restored.
     scriptvars: environment variables that should be set to the return value of a script. After they have been set, they behave in the same way as variables set in the env section.
-    scripts: scripts to run when entering the directory or leaving it. Note that exitscripts are not run in the directory they are declared in."#
+    scripts: scripts to run when entering the directory or leaving it."#
     }
 
     fn signature(&self) -> Signature {
         Signature::build("autoenv")
     }
-    async fn run(
-        &self,
-        _args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = registry.clone();
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(crate::commands::help::get_help(&Autoenv, &registry))
+            UntaggedValue::string(crate::commands::help::get_help(&Autoenv, &args.scope))
                 .into_value(Tag::unknown()),
         )))
     }
@@ -77,15 +72,15 @@ The file can contain several optional sections:
         vec![Example {
             description: "Example .nu-env file",
             example: r#"cat .nu-env
-    [env]
-    mykey = "myvalue"
+        [env]
+        mykey = "myvalue"
 
-    [scriptvars]
-    myscript = "echo myval"
+        [scriptvars]
+        myscript = "echo myval"
 
-    [scripts]
-    entryscripts = ["touch hello.txt", "touch hello2.txt"]
-    exitscripts = ["touch bye.txt"]"#,
+        [scripts]
+        entryscripts = ["touch hello.txt", "touch hello2.txt"]
+        exitscripts = ["touch bye.txt"]"#,
             result: None,
         }]
     }

crates/nu-cli/src/commands/autoenv_trust.rs

@@ -22,14 +22,11 @@ impl WholeStreamCommand for AutoenvTrust {
         "Trust a .nu-env file in the current or given directory"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let tag = args.call_info.name_tag.clone();
+        let ctx = EvaluationContext::from_args(&args);
 
-        let file_to_trust = match args.call_info.evaluate(registry).await?.args.nth(0) {
+        let file_to_trust = match args.call_info.evaluate(&ctx).await?.args.nth(0) {
             Some(Value {
                 value: UntaggedValue::Primitive(Primitive::String(ref path)),
                 tag: _,

crates/nu-cli/src/commands/autoenv_untrust.rs

@@ -26,13 +26,10 @@ impl WholeStreamCommand for AutoenvUnTrust {
         "Untrust a .nu-env file in the current or given directory"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let tag = args.call_info.name_tag.clone();
-        let file_to_untrust = match args.call_info.evaluate(registry).await?.args.nth(0) {
+        let ctx = EvaluationContext::from_args(&args);
+        let file_to_untrust = match args.call_info.evaluate(&ctx).await?.args.nth(0) {
             Some(Value {
                 value: UntaggedValue::Primitive(Primitive::String(ref path)),
                 tag: _,

crates/nu-cli/src/commands/autoview/command.rs

@@ -1,17 +1,19 @@
-use crate::commands::UnevaluatedCallInfo;
-use crate::commands::WholeStreamCommand;
-use crate::data::value::format_leaf;
+use crate::commands::autoview::options::{ConfigExtensions, NuConfig as AutoViewConfiguration};
+use crate::commands::{UnevaluatedCallInfo, WholeStreamCommand};
 use crate::prelude::*;
+use crate::primitive::get_color_config;
+use nu_data::value::format_leaf;
 use nu_errors::ShellError;
-use nu_protocol::{hir, hir::Expression, hir::Literal, hir::SpannedExpression};
-use nu_protocol::{Primitive, Scope, Signature, UntaggedValue, Value};
+use nu_protocol::hir::{self, Expression, ExternalRedirection, Literal, SpannedExpression};
+use nu_protocol::{Primitive, Signature, UntaggedValue, Value};
+use nu_table::TextStyle;
 use parking_lot::Mutex;
 use std::sync::atomic::AtomicBool;
 
-pub struct Autoview;
+pub struct Command;
 
 #[async_trait]
-impl WholeStreamCommand for Autoview {
+impl WholeStreamCommand for Command {
     fn name(&self) -> &str {
         "autoview"
     }
@@ -24,20 +26,15 @@ impl WholeStreamCommand for Autoview {
         "View the contents of the pipeline as a table or list."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         autoview(RunnableContext {
             input: args.input,
-            registry: registry.clone(),
+            scope: args.scope.clone(),
             shell_manager: args.shell_manager,
             host: args.host,
             ctrl_c: args.ctrl_c,
             current_errors: args.current_errors,
             name: args.call_info.name_tag,
-            raw_input: args.raw_input,
         })
         .await
     }
@@ -63,7 +60,7 @@ pub struct RunnableContextWithoutInput {
     pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
     pub current_errors: Arc<Mutex<Vec<ShellError>>>,
     pub ctrl_c: Arc<AtomicBool>,
-    pub registry: CommandRegistry,
+    pub scope: Scope,
     pub name: Tag,
 }
 
@@ -74,7 +71,7 @@ impl RunnableContextWithoutInput {
             host: context.host,
             ctrl_c: context.ctrl_c,
             current_errors: context.current_errors,
-            registry: context.registry,
+            scope: context.scope,
             name: context.name,
         };
         (context.input, new_context)
@@ -82,31 +79,17 @@ impl RunnableContextWithoutInput {
 }
 
 pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
+    let configuration = AutoViewConfiguration::new();
+
     let binary = context.get_command("binaryview");
     let text = context.get_command("textview");
     let table = context.get_command("table");
 
-    #[derive(PartialEq)]
-    enum AutoPivotMode {
-        Auto,
-        Always,
-        Never,
-    }
-
-    let pivot_mode = crate::data::config::config(Tag::unknown());
-    let pivot_mode = if let Some(v) = pivot_mode?.get("pivot_mode") {
-        match v.as_string() {
-            Ok(m) if m.to_lowercase() == "auto" => AutoPivotMode::Auto,
-            Ok(m) if m.to_lowercase() == "always" => AutoPivotMode::Always,
-            Ok(m) if m.to_lowercase() == "never" => AutoPivotMode::Never,
-            _ => AutoPivotMode::Always,
-        }
-    } else {
-        AutoPivotMode::Always
-    };
+    let pivot_mode = configuration.pivot_mode();
 
     let (mut input_stream, context) = RunnableContextWithoutInput::convert(context);
     let term_width = context.host.lock().width();
+    let color_hm = get_color_config();
 
     if let Some(x) = input_stream.next().await {
         match input_stream.next().await {
@@ -121,7 +104,7 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
 
                 if let Some(table) = table {
                     let command_args = create_default_command_args(&context).with_input(stream);
-                    let result = table.run(command_args, &context.registry).await?;
+                    let result = table.run(command_args).await?;
                     result.collect::<Vec<_>>().await;
                 }
             }
@@ -138,7 +121,7 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                             );
                             let command_args =
                                 create_default_command_args(&context).with_input(stream);
-                            let result = text.run(command_args, &context.registry).await?;
+                            let result = text.run(command_args).await?;
                             result.collect::<Vec<_>>().await;
                         } else {
                             out!("{}", s);
@@ -161,7 +144,7 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                             );
                             let command_args =
                                 create_default_command_args(&context).with_input(stream);
-                            let result = text.run(command_args, &context.registry).await?;
+                            let result = text.run(command_args).await?;
                             result.collect::<Vec<_>>().await;
                         } else {
                             out!("{}\n", s);
@@ -236,7 +219,7 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                             stream.push_back(x);
                             let command_args =
                                 create_default_command_args(&context).with_input(stream);
-                            let result = binary.run(command_args, &context.registry).await?;
+                            let result = binary.run(command_args).await?;
                             result.collect::<Vec<_>>().await;
                         } else {
                             use pretty_hex::*;
@@ -254,8 +237,8 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                     Value {
                         value: UntaggedValue::Row(row),
                         ..
-                    } if pivot_mode == AutoPivotMode::Always
-                        || (pivot_mode == AutoPivotMode::Auto
+                    } if pivot_mode.is_always()
+                        || (pivot_mode.is_auto()
                             && (row
                                 .entries
                                 .iter()
@@ -271,15 +254,14 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                             entries.push(vec![
                                 nu_table::StyledString::new(
                                     key.to_string(),
-                                    nu_table::TextStyle {
-                                        alignment: nu_table::Alignment::Left,
-                                        color: Some(ansi_term::Color::Green),
-                                        is_bold: true,
-                                    },
+                                    TextStyle::new()
+                                        .alignment(nu_table::Alignment::Left)
+                                        .fg(ansi_term::Color::Green)
+                                        .bold(Some(true)),
                                 ),
                                 nu_table::StyledString::new(
                                     format_leaf(value).plain_string(100_000),
-                                    nu_table::TextStyle::basic(),
+                                    nu_table::TextStyle::basic_left(),
                                 ),
                             ]);
                         }
@@ -287,9 +269,14 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                         let table =
                             nu_table::Table::new(vec![], entries, nu_table::Theme::compact());
 
-                        nu_table::draw_table(&table, term_width);
+                        nu_table::draw_table(&table, term_width, &color_hm);
+                    }
+                    Value {
+                        value: UntaggedValue::Primitive(Primitive::Nothing),
+                        ..
+                    } => {
+                        // Do nothing
                     }
-
                     Value {
                         value: ref item, ..
                     } => {
@@ -298,7 +285,7 @@ pub async fn autoview(context: RunnableContext) -> Result<OutputStream, ShellErr
                             stream.push_back(x);
                             let command_args =
                                 create_default_command_args(&context).with_input(stream);
-                            let result = table.run(command_args, &context.registry).await?;
+                            let result = table.run(command_args).await?;
                             result.collect::<Vec<_>>().await;
                         } else {
                             out!("{:?}", item);
@@ -328,22 +315,23 @@ fn create_default_command_args(context: &RunnableContextWithoutInput) -> RawComm
                 positional: None,
                 named: None,
                 span,
-                is_last: true,
+                external_redirection: ExternalRedirection::Stdout,
             },
             name_tag: context.name.clone(),
-            scope: Scope::new(),
         },
+        scope: Scope::new(),
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::Autoview;
+    use super::Command;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Autoview {})
+        Ok(test_examples(Command {})?)
     }
 }

crates/nu-cli/src/commands/autoview/mod.rs

@@ -0,0 +1,4 @@
+pub mod command;
+mod options;
+
+pub use command::Command as Autoview;

crates/nu-cli/src/commands/autoview/options.rs

@@ -0,0 +1,51 @@
+pub use nu_data::config::NuConfig;
+use std::fmt::Debug;
+
+#[derive(PartialEq, Debug)]
+pub enum AutoPivotMode {
+    Auto,
+    Always,
+    Never,
+}
+
+impl AutoPivotMode {
+    pub fn is_auto(&self) -> bool {
+        matches!(self, AutoPivotMode::Auto)
+    }
+
+    pub fn is_always(&self) -> bool {
+        matches!(self, AutoPivotMode::Always)
+    }
+
+    #[allow(unused)]
+    pub fn is_never(&self) -> bool {
+        matches!(self, AutoPivotMode::Never)
+    }
+}
+
+pub trait ConfigExtensions: Debug + Send {
+    fn pivot_mode(&self) -> AutoPivotMode;
+}
+
+pub fn pivot_mode(config: &NuConfig) -> AutoPivotMode {
+    let vars = &config.vars;
+
+    if let Some(mode) = vars.get("pivot_mode") {
+        let mode = match mode.as_string() {
+            Ok(m) if m.to_lowercase() == "auto" => AutoPivotMode::Auto,
+            Ok(m) if m.to_lowercase() == "always" => AutoPivotMode::Always,
+            Ok(m) if m.to_lowercase() == "never" => AutoPivotMode::Never,
+            _ => AutoPivotMode::Never,
+        };
+
+        return mode;
+    }
+
+    AutoPivotMode::Never
+}
+
+impl ConfigExtensions for NuConfig {
+    fn pivot_mode(&self) -> AutoPivotMode {
+        pivot_mode(self)
+    }
+}

crates/nu-cli/src/commands/benchmark.rs

@@ -1,18 +1,26 @@
 use crate::commands::classified::block::run_block;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
+#[cfg(feature = "rich-benchmark")]
+use heim::cpu::time;
 use nu_errors::ShellError;
 use nu_protocol::{
-    hir::Block, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+    hir::{Block, CapturedBlock, ClassifiedCommand, Group, InternalCommand, Pipeline},
+    Dictionary, Signature, SyntaxShape, UntaggedValue, Value,
 };
-
-use chrono::prelude::*;
+use rand::{
+    distributions::Alphanumeric,
+    prelude::{thread_rng, Rng},
+};
+use std::convert::TryInto;
+use std::time::{Duration, Instant};
 
 pub struct Benchmark;
 
 #[derive(Deserialize, Debug)]
 struct BenchmarkArgs {
-    block: Block,
+    block: CapturedBlock,
+    passthrough: Option<CapturedBlock>,
 }
 
 #[async_trait]
@@ -22,59 +30,181 @@ impl WholeStreamCommand for Benchmark {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("benchmark").required(
-            "block",
-            SyntaxShape::Block,
-            "the block to run and benchmark",
-        )
+        Signature::build("benchmark")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run and benchmark",
+            )
+            .named(
+                "passthrough",
+                SyntaxShape::Block,
+                "Display the benchmark results and pass through the block's output",
+                Some('p'),
+            )
     }
 
     fn usage(&self) -> &str {
-        "Runs a block and return the time it took to do execute it. Eg) benchmark { echo $nu.env.NAME }"
+        "Runs a block and returns the time it took to execute it"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        benchmark(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        benchmark(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Benchmarks a command within a block",
+                example: "benchmark { sleep 500ms }",
+                result: None,
+            },
+            Example {
+                description: "Benchmarks a command within a block and passes its output through",
+                example: "echo 45 | benchmark { sleep 500ms } --passthrough {}",
+                result: Some(vec![UntaggedValue::int(45).into()]),
+            },
+        ]
     }
 }
 
-async fn benchmark(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
+async fn benchmark(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = raw_args.call_info.args.span;
+    let mut context = EvaluationContext::from_raw(&raw_args);
+    let scope = raw_args.scope.clone();
+    let (BenchmarkArgs { block, passthrough }, input) = raw_args.process().await?;
 
-    let mut context = Context::from_raw(&raw_args, &registry);
-    let scope = raw_args.call_info.scope.clone();
-    let (BenchmarkArgs { block }, input) = raw_args.process(&registry).await?;
+    let env = scope.get_env_vars();
+    let name = generate_free_name(&env);
 
-    let start_time: chrono::DateTime<_> = Utc::now();
+    scope.add_env_var(name, generate_random_env_value());
 
-    let result = run_block(
-        &block,
-        &mut context,
-        input,
-        &scope.it,
-        &scope.vars,
-        &scope.env,
-    )
-    .await;
+    let start_time = Instant::now();
 
-    let output = match result {
-        Ok(mut stream) => {
-            let _ = stream.drain_vec().await;
-            let run_duration: chrono::Duration = Utc::now().signed_duration_since(start_time);
-            context.clear_errors();
-            Ok(ReturnSuccess::Value(Value {
-                value: UntaggedValue::Primitive(Primitive::from(run_duration)),
-                tag: Tag::from(block.span),
-            }))
+    #[cfg(feature = "rich-benchmark")]
+    let start = time().await;
+
+    context.scope.enter_scope();
+    let result = run_block(&block.block, &context, input).await;
+    context.scope.exit_scope();
+    let output = result?.into_vec().await;
+
+    #[cfg(feature = "rich-benchmark")]
+    let end = time().await;
+
+    let end_time = Instant::now();
+    context.clear_errors();
+
+    // return basic runtime
+    #[cfg(not(feature = "rich-benchmark"))]
+    {
+        let mut indexmap = IndexMap::with_capacity(1);
+
+        let real_time = into_big_int(end_time - start_time);
+        indexmap.insert("real time".to_string(), real_time);
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context).await
+    }
+    // return advanced stats
+    #[cfg(feature = "rich-benchmark")]
+    if let (Ok(start), Ok(end)) = (start, end) {
+        let mut indexmap = IndexMap::with_capacity(4);
+
+        let real_time = into_big_int(end_time - start_time);
+        indexmap.insert("real time".to_string(), real_time);
+
+        let user_time = into_big_int(end.user() - start.user());
+        indexmap.insert("user time".to_string(), user_time);
+
+        let system_time = into_big_int(end.system() - start.system());
+        indexmap.insert("system time".to_string(), system_time);
+
+        let idle_time = into_big_int(end.idle() - start.idle());
+        indexmap.insert("idle time".to_string(), idle_time);
+
+        benchmark_output(indexmap, output, passthrough, &tag, &mut context).await
+    } else {
+        Err(ShellError::untagged_runtime_error(
+            "Could not retrieve CPU time",
+        ))
+    }
+}
+
+async fn benchmark_output<T, Output>(
+    indexmap: IndexMap<String, BigInt>,
+    block_output: Output,
+    passthrough: Option<CapturedBlock>,
+    tag: T,
+    context: &mut EvaluationContext,
+) -> Result<OutputStream, ShellError>
+where
+    T: Into<Tag> + Copy,
+    Output: Into<OutputStream>,
+{
+    let value = UntaggedValue::Row(Dictionary::from(
+        indexmap
+            .into_iter()
+            .map(|(k, v)| (k, UntaggedValue::duration(v).into_value(tag)))
+            .collect::<IndexMap<String, Value>>(),
+    ))
+    .into_value(tag);
+
+    if let Some(time_block) = passthrough {
+        let benchmark_output = InputStream::one(value);
+
+        // add autoview for an empty block
+        let time_block = add_implicit_autoview(time_block.block);
+
+        context.scope.enter_scope();
+        let result = run_block(&time_block, context, benchmark_output).await;
+        context.scope.exit_scope();
+        result?;
+        context.clear_errors();
+
+        Ok(block_output.into())
+    } else {
+        let benchmark_output = OutputStream::one(value);
+        Ok(benchmark_output)
+    }
+}
+
+fn add_implicit_autoview(mut block: Block) -> Block {
+    if block.block.is_empty() {
+        let group = Group::new(
+            vec![{
+                let mut commands = Pipeline::new(block.span);
+                commands.push(ClassifiedCommand::Internal(InternalCommand::new(
+                    "autoview".to_string(),
+                    block.span,
+                    block.span,
+                )));
+                commands
+            }],
+            block.span,
+        );
+        block.push(group);
+    }
+    block
+}
+
+fn into_big_int<T: TryInto<Duration>>(time: T) -> BigInt {
+    time.try_into()
+        .unwrap_or_else(|_| Duration::new(0, 0))
+        .as_nanos()
+        .into()
+}
+
+fn generate_random_env_value() -> String {
+    let mut thread_rng = thread_rng();
+    let len = thread_rng.gen_range(1, 16 * 1024);
+    thread_rng.sample_iter(&Alphanumeric).take(len).collect()
+}
+
+fn generate_free_name(env: &indexmap::IndexMap<String, String>) -> String {
+    let mut thread_rng = thread_rng();
+    loop {
+        let candidate_name = format!("NU_RANDOM_VALUE_{}", thread_rng.gen::<usize>());
+        if !env.contains_key(&candidate_name) {
+            return candidate_name;
         }
-        Err(e) => Err(e),
-    };
-    Ok(OutputStream::from(vec![output]))
+    }
 }

crates/nu-cli/src/commands/build_string.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use nu_errors::ShellError;
 
 use crate::commands::WholeStreamCommand;
-use crate::data::value::format_leaf;
+use nu_data::value::format_leaf;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 
 #[derive(Deserialize)]
@@ -27,13 +27,9 @@ impl WholeStreamCommand for BuildString {
         "Builds a string from the arguments"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let tag = args.call_info.name_tag.clone();
-        let (BuildStringArgs { rest }, _) = args.process(&registry).await?;
+        let (BuildStringArgs { rest }, _) = args.process().await?;
 
         let mut output_string = String::new();
 

crates/nu-cli/src/commands/cal.rs

@@ -41,12 +41,8 @@ impl WholeStreamCommand for Cal {
         "Display a calendar."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        cal(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        cal(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -70,12 +66,8 @@ impl WholeStreamCommand for Cal {
     }
 }
 
-pub async fn cal(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
+pub async fn cal(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
     let mut calendar_vec_deque = VecDeque::new();
     let tag = args.call_info.name_tag.clone();
 
@@ -100,7 +92,7 @@ pub async fn cal(
         (current_month, current_month)
     };
 
-    let add_months_of_year_to_table_result = add_months_of_year_to_table(
+    add_months_of_year_to_table(
         &args,
         &mut calendar_vec_deque,
         &tag,
@@ -108,12 +100,9 @@ pub async fn cal(
         month_range,
         current_month,
         current_day_option,
-    );
+    )?;
 
-    match add_months_of_year_to_table_result {
-        Ok(()) => Ok(futures::stream::iter(calendar_vec_deque).to_output_stream()),
-        Err(error) => Err(error),
-    }
+    Ok(futures::stream::iter(calendar_vec_deque).to_output_stream())
 }
 
 fn get_invalid_year_shell_error(year_tag: &Tag) -> ShellError {
@@ -342,11 +331,12 @@ fn add_month_to_table(
 #[cfg(test)]
 mod tests {
     use super::Cal;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Cal {})
+        Ok(test_examples(Cal {})?)
     }
 }

crates/nu-cli/src/commands/cd.rs

@@ -32,14 +32,10 @@ impl WholeStreamCommand for Cd {
         "Change to a new path."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let name = args.call_info.name_tag.clone();
         let shell_manager = args.shell_manager.clone();
-        let (args, _): (CdArgs, _) = args.process(&registry).await?;
+        let (args, _): (CdArgs, _) = args.process().await?;
         shell_manager.cd(args, name)
     }
 
@@ -72,11 +68,12 @@ impl WholeStreamCommand for Cd {
 #[cfg(test)]
 mod tests {
     use super::Cd;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Cd {})
+        Ok(test_examples(Cd {})?)
     }
 }

crates/nu-cli/src/commands/char_.rs

@@ -9,6 +9,7 @@ pub struct Char;
 #[derive(Deserialize)]
 struct CharArgs {
     name: Tagged<String>,
+    unicode: bool,
 }
 
 #[async_trait]
@@ -18,11 +19,13 @@ impl WholeStreamCommand for Char {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("ansi").required(
-            "character",
-            SyntaxShape::Any,
-            "the name of the character to output",
-        )
+        Signature::build("ansi")
+            .required(
+                "character",
+                SyntaxShape::Any,
+                "the name of the character to output",
+            )
+            .switch("unicode", "unicode string i.e. 1f378", Some('u'))
     }
 
     fn usage(&self) -> &str {
@@ -45,32 +48,53 @@ impl WholeStreamCommand for Char {
                     UntaggedValue::string("\u{2261}").into(),
                 ]),
             },
+            Example {
+                description: "Output unicode character",
+                example: r#"char -u 1f378"#,
+                result: Some(vec![Value::from("\u{1f378}")]),
+            },
         ]
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let (CharArgs { name }, _) = args.process(&registry).await?;
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let (CharArgs { name, unicode }, _) = args.process().await?;
 
-        let special_character = str_to_character(&name.item);
-
-        if let Some(output) = special_character {
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::string(output).into_value(name.tag()),
-            )))
+        if unicode {
+            let decoded_char = string_to_unicode_char(&name.item);
+            if let Some(output) = decoded_char {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error decoding unicode character",
+                    "error decoding unicode character",
+                    name.tag(),
+                ))
+            }
         } else {
-            Err(ShellError::labeled_error(
-                "Unknown character",
-                "unknown character",
-                name.tag(),
-            ))
+            let special_character = str_to_character(&name.item);
+            if let Some(output) = special_character {
+                Ok(OutputStream::one(ReturnSuccess::value(
+                    UntaggedValue::string(output).into_value(name.tag()),
+                )))
+            } else {
+                Err(ShellError::labeled_error(
+                    "error finding named character",
+                    "error finding named character",
+                    name.tag(),
+                ))
+            }
         }
     }
 }
 
+fn string_to_unicode_char(s: &str) -> Option<char> {
+    u32::from_str_radix(s, 16)
+        .ok()
+        .and_then(std::char::from_u32)
+}
+
 fn str_to_character(s: &str) -> Option<String> {
     match s {
         "newline" | "enter" | "nl" => Some("\n".into()),
@@ -78,6 +102,7 @@ fn str_to_character(s: &str) -> Option<String> {
         "sp" | "space" => Some(" ".into()),
         // Unicode names came from https://www.compart.com/en/unicode
         // Private Use Area (U+E000-U+F8FF)
+        // Unicode can't be mixed with Ansi or it will break width calculation
         "branch" => Some('\u{e0a0}'.to_string()),  // 
         "segment" => Some('\u{e0b0}'.to_string()), // 
 
@@ -94,6 +119,35 @@ fn str_to_character(s: &str) -> Option<String> {
         "high_voltage_sign" | "elevated" => Some('\u{26a1}'.to_string()),           // ⚡
         "tilde" | "twiddle" | "squiggly" | "home" => Some("~".into()),              // ~
         "hash" | "hashtag" | "pound_sign" | "sharp" | "root" => Some("#".into()),   // #
+
+        // Weather symbols
+        "sun" | "sunny" | "sunrise" => Some("☀️".to_string()),
+        "moon" => Some("🌛".to_string()),
+        "cloudy" | "cloud" | "clouds" => Some("☁️".to_string()),
+        "rainy" | "rain" => Some("🌦️".to_string()),
+        "foggy" | "fog" => Some("🌫️".to_string()),
+        "mist" | "haze" => Some("\u{2591}".to_string()),
+        "snowy" | "snow" => Some("❄️".to_string()),
+        "thunderstorm" | "thunder" => Some("🌩️".to_string()),
+
+        // Reference for ansi codes https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
+        // Another good reference http://ascii-table.com/ansi-escape-sequences.php
+
+        // For setting title like `echo [$(char title) $(pwd) $(char bel)] | str collect`
+        "title" => Some("\x1b]2;".to_string()), // ESC]2; xterm sets window title
+        "bel" => Some('\x07'.to_string()),      // Terminal Bell
+        "backspace" => Some('\x08'.to_string()), // Backspace
+
+        // Ansi Erase Sequences
+        "clear_screen" => Some("\x1b[J".to_string()), // clears the screen
+        "clear_screen_from_cursor_to_end" => Some("\x1b[0J".to_string()), // clears from cursor until end of screen
+        "clear_screen_from_cursor_to_beginning" => Some("\x1b[1J".to_string()), // clears from cursor to beginning of screen
+        "cls" | "clear_entire_screen" => Some("\x1b[2J".to_string()), // clears the entire screen
+        "erase_line" => Some("\x1b[K".to_string()),                   // clears the current line
+        "erase_line_from_cursor_to_end" => Some("\x1b[0K".to_string()), // clears from cursor to end of line
+        "erase_line_from_cursor_to_beginning" => Some("\x1b[1K".to_string()), // clears from cursor to start of line
+        "erase_entire_line" => Some("\x1b[2K".to_string()),                   // clears entire line
+
         _ => None,
     }
 }
@@ -101,11 +155,12 @@ fn str_to_character(s: &str) -> Option<String> {
 #[cfg(test)]
 mod tests {
     use super::Char;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Char {})
+        Ok(test_examples(Char {})?)
     }
 }

crates/nu-cli/src/commands/chart.rs

@@ -0,0 +1,48 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+#[derive(Clone)]
+pub struct Chart;
+
+#[async_trait]
+impl WholeStreamCommand for Chart {
+    fn name(&self) -> &str {
+        "chart"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("chart")
+    }
+
+    fn usage(&self) -> &str {
+        "Displays charts."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        if args.scope.get_command("chart bar").is_none() {
+            return Err(ShellError::untagged_runtime_error(
+                "nu_plugin_chart not installed.",
+            ));
+        }
+
+        Ok(OutputStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(crate::commands::help::get_help(&Chart, &args.scope))
+                .into_value(Tag::unknown()),
+        ))))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Chart;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Chart {})?)
+    }
+}

crates/nu-cli/src/commands/classified/block.rs

@@ -1,42 +1,69 @@
 use crate::commands::classified::expr::run_expression_block;
 use crate::commands::classified::internal::run_internal_command;
-use crate::context::Context;
+use crate::evaluation_context::EvaluationContext;
 use crate::prelude::*;
-use crate::stream::InputStream;
+use async_recursion::async_recursion;
 use futures::stream::TryStreamExt;
 use nu_errors::ShellError;
-use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
+use nu_protocol::hir::{
+    Block, Call, ClassifiedCommand, Expression, Pipeline, SpannedExpression, Synthetic,
+};
 use nu_protocol::{ReturnSuccess, UntaggedValue, Value};
+use nu_stream::InputStream;
 use std::sync::atomic::Ordering;
 
-pub(crate) async fn run_block(
+#[async_recursion]
+pub async fn run_block(
     block: &Block,
-    ctx: &mut Context,
+    ctx: &EvaluationContext,
     mut input: InputStream,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
 ) -> Result<InputStream, ShellError> {
     let mut output: Result<InputStream, ShellError> = Ok(InputStream::empty());
-    for pipeline in &block.block {
+    for (_, definition) in block.definitions.iter() {
+        ctx.scope.add_definition(definition.clone());
+    }
+
+    for group in &block.block {
         match output {
             Ok(inp) if inp.is_empty() => {}
             Ok(inp) => {
-                let mut output_stream = inp.to_output_stream();
-
-                loop {
+                // Run autoview on the values we've seen so far
+                // We may want to make this configurable for other kinds of hosting
+                if let Some(autoview) = ctx.get_command("autoview") {
+                    let mut output_stream = match ctx
+                        .run_command(
+                            autoview,
+                            Tag::unknown(),
+                            Call::new(
+                                Box::new(SpannedExpression::new(
+                                    Expression::Synthetic(Synthetic::String("autoview".into())),
+                                    Span::unknown(),
+                                )),
+                                Span::unknown(),
+                            ),
+                            inp,
+                        )
+                        .await
+                    {
+                        Ok(x) => x,
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    };
                     match output_stream.try_next().await {
                         Ok(Some(ReturnSuccess::Value(Value {
                             value: UntaggedValue::Error(e),
                             ..
-                        }))) => return Err(e),
+                        }))) => {
+                            return Err(e);
+                        }
                         Ok(Some(_item)) => {
                             if let Some(err) = ctx.get_errors().get(0) {
                                 ctx.clear_errors();
                                 return Err(err.clone());
                             }
                             if ctx.ctrl_c.load(Ordering::SeqCst) {
-                                break;
+                                return Ok(InputStream::empty());
                             }
                         }
                         Ok(None) => {
@@ -44,9 +71,10 @@ pub(crate) async fn run_block(
                                 ctx.clear_errors();
                                 return Err(err.clone());
                             }
-                            break;
                         }
-                        Err(e) => return Err(e),
+                        Err(e) => {
+                            return Err(e);
+                        }
                     }
                 }
             }
@@ -54,43 +82,131 @@ pub(crate) async fn run_block(
                 return Err(e);
             }
         }
-        output = run_pipeline(pipeline, ctx, input, it, vars, env).await;
+        output = Ok(InputStream::empty());
+        for pipeline in &group.pipelines {
+            match output {
+                Ok(inp) if inp.is_empty() => {}
+                Ok(inp) => {
+                    let mut output_stream = inp.to_output_stream();
 
-        input = InputStream::empty();
+                    match output_stream.try_next().await {
+                        Ok(Some(ReturnSuccess::Value(Value {
+                            value: UntaggedValue::Error(e),
+                            ..
+                        }))) => {
+                            return Err(e);
+                        }
+                        Ok(Some(_item)) => {
+                            if let Some(err) = ctx.get_errors().get(0) {
+                                ctx.clear_errors();
+                                return Err(err.clone());
+                            }
+                            if ctx.ctrl_c.load(Ordering::SeqCst) {
+                                // This early return doesn't return the result
+                                // we have so far, but breaking out of this loop
+                                // causes lifetime issues. A future contribution
+                                // could attempt to return the current output.
+                                // https://github.com/nushell/nushell/pull/2830#discussion_r550319687
+                                return Ok(InputStream::empty());
+                            }
+                        }
+                        Ok(None) => {
+                            if let Some(err) = ctx.get_errors().get(0) {
+                                ctx.clear_errors();
+                                return Err(err.clone());
+                            }
+                        }
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+            output = run_pipeline(pipeline, ctx, input).await;
+
+            input = InputStream::empty();
+        }
     }
 
     output
 }
 
+#[async_recursion]
 async fn run_pipeline(
-    commands: &Commands,
-    ctx: &mut Context,
+    commands: &Pipeline,
+    ctx: &EvaluationContext,
     mut input: InputStream,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
 ) -> Result<InputStream, ShellError> {
-    let mut iter = commands.list.clone().into_iter().peekable();
-    loop {
-        let item: Option<ClassifiedCommand> = iter.next();
-        let next: Option<&ClassifiedCommand> = iter.peek();
+    for item in commands.list.clone() {
+        input = match item {
+            ClassifiedCommand::Dynamic(call) => {
+                let mut args = vec![];
+                if let Some(positional) = call.positional {
+                    for pos in &positional {
+                        let result = run_expression_block(pos, ctx).await?.into_vec().await;
+                        args.push(result);
+                    }
+                }
 
-        input = match (item, next) {
-            (Some(ClassifiedCommand::Dynamic(_)), _) | (_, Some(ClassifiedCommand::Dynamic(_))) => {
-                return Err(ShellError::unimplemented("Dynamic commands"))
+                match &call.head.expr {
+                    Expression::Block(block) => {
+                        ctx.scope.enter_scope();
+                        for (param, value) in block.params.positional.iter().zip(args.iter()) {
+                            ctx.scope.add_var(param.0.name(), value[0].clone());
+                        }
+                        let result = run_block(&block, ctx, input).await;
+                        ctx.scope.exit_scope();
+
+                        let result = result?;
+                        return Ok(result);
+                    }
+                    Expression::Variable(v, span) => {
+                        if let Some(value) = ctx.scope.get_var(v) {
+                            match &value.value {
+                                UntaggedValue::Block(captured_block) => {
+                                    ctx.scope.enter_scope();
+                                    ctx.scope.add_vars(&captured_block.captured.entries);
+                                    for (param, value) in captured_block
+                                        .block
+                                        .params
+                                        .positional
+                                        .iter()
+                                        .zip(args.iter())
+                                    {
+                                        ctx.scope.add_var(param.0.name(), value[0].clone());
+                                    }
+                                    let result = run_block(&captured_block.block, ctx, input).await;
+                                    ctx.scope.exit_scope();
+
+                                    let result = result?;
+                                    return Ok(result);
+                                }
+                                _ => {
+                                    return Err(ShellError::labeled_error("Dynamic commands must start with a block (or variable pointing to a block)", "needs to be a block", call.head.span));
+                                }
+                            }
+                        } else {
+                            return Err(ShellError::labeled_error(
+                                "Variable not found",
+                                "variable not found",
+                                span,
+                            ));
+                        }
+                    }
+                    _ => {
+                        return Err(ShellError::labeled_error("Dynamic commands must start with a block (or variable pointing to a block)", "needs to be a block", call.head.span));
+                    }
+                }
             }
 
-            (Some(ClassifiedCommand::Expr(expr)), _) => {
-                run_expression_block(*expr, ctx, it, vars, env).await?
-            }
-            (Some(ClassifiedCommand::Error(err)), _) => return Err(err.into()),
-            (_, Some(ClassifiedCommand::Error(err))) => return Err(err.clone().into()),
+            ClassifiedCommand::Expr(expr) => run_expression_block(&*expr, ctx).await?,
 
-            (Some(ClassifiedCommand::Internal(left)), _) => {
-                run_internal_command(left, ctx, input, it, vars, env).await?
-            }
+            ClassifiedCommand::Error(err) => return Err(err.into()),
 
-            (None, _) => break,
+            ClassifiedCommand::Internal(left) => run_internal_command(left, ctx, input).await?,
         };
     }
 

crates/nu-cli/src/commands/classified/expr.rs

@@ -6,22 +6,17 @@ use log::{log_enabled, trace};
 use futures::stream::once;
 use nu_errors::ShellError;
 use nu_protocol::hir::SpannedExpression;
-use nu_protocol::Value;
 
 pub(crate) async fn run_expression_block(
-    expr: SpannedExpression,
-    context: &mut Context,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
+    expr: &SpannedExpression,
+    ctx: &EvaluationContext,
 ) -> Result<InputStream, ShellError> {
     if log_enabled!(log::Level::Trace) {
         trace!(target: "nu::run::expr", "->");
         trace!(target: "nu::run::expr", "{:?}", expr);
     }
 
-    let registry = context.registry().clone();
-    let output = evaluate_baseline_expr(&expr, &registry, it, vars, env).await?;
+    let output = evaluate_baseline_expr(expr, ctx).await?;
 
     Ok(once(async { Ok(output) }).to_input_stream())
 }

crates/nu-cli/src/commands/classified/external.rs

@@ -3,6 +3,7 @@ use crate::evaluate::evaluate_baseline_expr;
 use crate::futures::ThreadedReceiver;
 use crate::prelude::*;
 
+use std::borrow::Cow;
 use std::io::Write;
 use std::ops::Deref;
 use std::process::{Command, Stdio};
@@ -13,16 +14,16 @@ use futures_codec::FramedRead;
 use log::trace;
 
 use nu_errors::ShellError;
-use nu_protocol::hir::ExternalCommand;
-use nu_protocol::{Primitive, Scope, ShellTypeName, UntaggedValue, Value};
+use nu_protocol::hir::Expression;
+use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
+use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
 use nu_source::Tag;
 
 pub(crate) async fn run_external_command(
     command: ExternalCommand,
-    context: &mut Context,
+    context: &mut EvaluationContext,
     input: InputStream,
-    scope: &Scope,
-    is_last: bool,
+    external_redirection: ExternalRedirection,
 ) -> Result<InputStream, ShellError> {
     trace!(target: "nu::run::external", "-> {}", command.name);
 
@@ -34,15 +35,14 @@ pub(crate) async fn run_external_command(
         ));
     }
 
-    run_with_stdin(command, context, input, scope, is_last).await
+    run_with_stdin(command, context, input, external_redirection).await
 }
 
 async fn run_with_stdin(
     command: ExternalCommand,
-    context: &mut Context,
+    context: &mut EvaluationContext,
     input: InputStream,
-    scope: &Scope,
-    is_last: bool,
+    external_redirection: ExternalRedirection,
 ) -> Result<InputStream, ShellError> {
     let path = context.shell_manager.path();
 
@@ -50,9 +50,8 @@ async fn run_with_stdin(
 
     let mut command_args = vec![];
     for arg in command.args.iter() {
-        let value =
-            evaluate_baseline_expr(arg, &context.registry, &scope.it, &scope.vars, &scope.env)
-                .await?;
+        let is_literal = matches!(arg.expr, Expression::Literal(_));
+        let value = evaluate_baseline_expr(arg, context).await?;
 
         // Skip any arguments that don't really exist, treating them as optional
         // FIXME: we may want to preserve the gap in the future, though it's hard to say
@@ -62,14 +61,36 @@ async fn run_with_stdin(
         }
 
         // Do the cleanup that we need to do on any argument going out:
-        let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
-
-        command_args.push(trimmed_value_string);
+        match &value.value {
+            UntaggedValue::Table(table) => {
+                for t in table {
+                    match &t.value {
+                        UntaggedValue::Primitive(_) => {
+                            command_args.push((
+                                t.convert_to_string().trim_end_matches('\n').to_string(),
+                                is_literal,
+                            ));
+                        }
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Could not convert to positional arguments",
+                                "could not convert to positional arguments",
+                                value.tag(),
+                            ));
+                        }
+                    }
+                }
+            }
+            _ => {
+                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
+                command_args.push((trimmed_value_string, is_literal));
+            }
+        }
     }
 
     let process_args = command_args
         .iter()
-        .map(|arg| {
+        .map(|(arg, _is_literal)| {
             let home_dir;
 
             #[cfg(feature = "dirs")]
@@ -85,8 +106,9 @@ async fn run_with_stdin(
 
             #[cfg(not(windows))]
             {
-                if argument_contains_whitespace(&arg) && !argument_is_quoted(&arg) {
-                    add_quotes(&arg)
+                if !_is_literal {
+                    let escaped = escape_double_quotes(&arg);
+                    add_double_quotes(&escaped)
                 } else {
                     arg.as_ref().to_string()
                 }
@@ -102,7 +124,14 @@ async fn run_with_stdin(
         })
         .collect::<Vec<String>>();
 
-    spawn(&command, &path, &process_args[..], input, is_last, scope)
+    spawn(
+        &command,
+        &path,
+        &process_args[..],
+        input,
+        external_redirection,
+        &context.scope,
+    )
 }
 
 fn spawn(
@@ -110,7 +139,7 @@ fn spawn(
     path: &str,
     args: &[String],
     input: InputStream,
-    is_last: bool,
+    external_redirection: ExternalRedirection,
     scope: &Scope,
 ) -> Result<InputStream, ShellError> {
     let command = command.clone();
@@ -142,16 +171,26 @@ fn spawn(
     trace!(target: "nu::run::external", "cwd = {:?}", &path);
 
     process.env_clear();
-    process.envs(scope.env.iter());
+    process.envs(scope.get_env_vars());
 
     // We want stdout regardless of what
     // we are doing ($it case or pipe stdin)
-    if !is_last {
-        process.stdout(Stdio::piped());
-        trace!(target: "nu::run::external", "set up stdout pipe");
-
-        process.stderr(Stdio::piped());
-        trace!(target: "nu::run::external", "set up stderr pipe");
+    match external_redirection {
+        ExternalRedirection::Stdout => {
+            process.stdout(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stdout pipe");
+        }
+        ExternalRedirection::Stderr => {
+            process.stderr(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stderr pipe");
+        }
+        ExternalRedirection::StdoutAndStderr => {
+            process.stdout(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stdout pipe");
+            process.stderr(Stdio::piped());
+            trace!(target: "nu::run::external", "set up stderr pipe");
+        }
+        _ => {}
     }
 
     // open since we have some contents for stdin
@@ -184,36 +223,19 @@ fn spawn(
                         UntaggedValue::Primitive(Primitive::Nothing) => continue,
                         UntaggedValue::Primitive(Primitive::String(s))
                         | UntaggedValue::Primitive(Primitive::Line(s)) => {
-                            if let Err(e) = stdin_write.write(s.as_bytes()) {
-                                let message = format!("Unable to write to stdin (error = {})", e);
-
-                                let _ = stdin_write_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        message,
-                                        "application may have closed before completing pipeline",
-                                        &stdin_name_tag,
-                                    )),
-                                    tag: stdin_name_tag,
-                                }));
-                                return Err(());
+                            if stdin_write.write(s.as_bytes()).is_err() {
+                                // Other side has closed, so exit
+                                return Ok(());
                             }
                         }
                         UntaggedValue::Primitive(Primitive::Binary(b)) => {
-                            if let Err(e) = stdin_write.write(b) {
-                                let message = format!("Unable to write to stdin (error = {})", e);
-
-                                let _ = stdin_write_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        message,
-                                        "application may have closed before completing pipeline",
-                                        &stdin_name_tag,
-                                    )),
-                                    tag: stdin_name_tag,
-                                }));
-                                return Err(());
+                            if stdin_write.write(b).is_err() {
+                                // Other side has closed, so exit
+                                return Ok(());
                             }
                         }
                         unsupported => {
+                            println!("Unsupported: {:?}", unsupported);
                             let _ = stdin_write_tx.send(Ok(Value {
                                 value: UntaggedValue::Error(ShellError::labeled_error(
                                     format!(
@@ -235,7 +257,9 @@ fn spawn(
         });
 
         std::thread::spawn(move || {
-            if !is_last {
+            if external_redirection == ExternalRedirection::Stdout
+                || external_redirection == ExternalRedirection::StdoutAndStderr
+            {
                 let stdout = if let Some(stdout) = child.stdout.take() {
                     stdout
                 } else {
@@ -250,20 +274,6 @@ fn spawn(
                     return Err(());
                 };
 
-                let stderr = if let Some(stderr) = child.stderr.take() {
-                    stderr
-                } else {
-                    let _ = stdout_read_tx.send(Ok(Value {
-                        value: UntaggedValue::Error(ShellError::labeled_error(
-                            "Can't redirect the stderr for external command",
-                            "can't redirect stderr",
-                            &stdout_name_tag,
-                        )),
-                        tag: stdout_name_tag,
-                    }));
-                    return Err(());
-                };
-
                 let file = futures::io::AllowStdIo::new(stdout);
                 let stream = FramedRead::new(file, MaybeTextCodec::default());
 
@@ -317,17 +327,34 @@ fn spawn(
                         }
                     }
                 }
+            }
+            if external_redirection == ExternalRedirection::Stderr
+                || external_redirection == ExternalRedirection::StdoutAndStderr
+            {
+                let stderr = if let Some(stderr) = child.stderr.take() {
+                    stderr
+                } else {
+                    let _ = stdout_read_tx.send(Ok(Value {
+                        value: UntaggedValue::Error(ShellError::labeled_error(
+                            "Can't redirect the stderr for external command",
+                            "can't redirect stderr",
+                            &stdout_name_tag,
+                        )),
+                        tag: stdout_name_tag,
+                    }));
+                    return Err(());
+                };
 
                 let file = futures::io::AllowStdIo::new(stderr);
-                let err_stream = FramedRead::new(file, MaybeTextCodec::default());
+                let stream = FramedRead::new(file, MaybeTextCodec::default());
 
-                for err_line in block_on_stream(err_stream) {
-                    match err_line {
+                for line in block_on_stream(stream) {
+                    match line {
                         Ok(line) => match line {
                             StringOrBinary::String(s) => {
                                 let result = stdout_read_tx.send(Ok(Value {
                                     value: UntaggedValue::Error(
-                                        ShellError::untagged_runtime_error(s.clone()),
+                                        ShellError::untagged_runtime_error(s),
                                     ),
                                     tag: stdout_name_tag.clone(),
                                 }));
@@ -339,9 +366,7 @@ fn spawn(
                             StringOrBinary::Binary(_) => {
                                 let result = stdout_read_tx.send(Ok(Value {
                                     value: UntaggedValue::Error(
-                                        ShellError::untagged_runtime_error(
-                                            "Binary in stderr output",
-                                        ),
+                                        ShellError::untagged_runtime_error("<binary stderr>"),
                                     ),
                                     tag: stdout_name_tag.clone(),
                                 }));
@@ -363,8 +388,8 @@ fn spawn(
                             if should_error {
                                 let _ = stdout_read_tx.send(Ok(Value {
                                     value: UntaggedValue::Error(ShellError::labeled_error(
-                                        format!("Unable to read from stderr ({})", e),
-                                        "unable to read from stderr",
+                                        format!("Unable to read from stdout ({})", e),
+                                        "unable to read from stdout",
                                         &stdout_name_tag,
                                     )),
                                     tag: stdout_name_tag.clone(),
@@ -385,7 +410,7 @@ fn spawn(
             };
 
             if external_failed {
-                let cfg = crate::data::config::config(Tag::unknown());
+                let cfg = nu_data::config::config(Tag::unknown());
                 if let Ok(cfg) = cfg {
                     if cfg.contains_key("nonzero_exit_errors") {
                         let _ = stdout_read_tx.send(Ok(Value {
@@ -435,10 +460,11 @@ pub fn did_find_command(#[allow(unused)] name: &str) -> bool {
         if which::which(name).is_ok() {
             true
         } else {
+            // Reference: https://ss64.com/nt/syntax-internal.html
             let cmd_builtins = [
-                "call", "cls", "color", "date", "dir", "echo", "find", "hostname", "pause",
-                "start", "time", "title", "ver", "copy", "mkdir", "rename", "rd", "rmdir", "type",
-                "mklink",
+                "assoc", "break", "color", "copy", "date", "del", "dir", "dpath", "echo", "erase",
+                "for", "ftype", "md", "mkdir", "mklink", "move", "path", "ren", "rename", "rd",
+                "rmdir", "set", "start", "time", "title", "type", "ver", "verify", "vol",
             ];
 
             cmd_builtins.contains(&name)
@@ -455,11 +481,6 @@ where
     shellexpand::tilde_with_context(input, home_dir)
 }
 
-#[allow(unused)]
-pub fn argument_contains_whitespace(argument: &str) -> bool {
-    argument.chars().any(|c| c.is_whitespace())
-}
-
 fn argument_is_quoted(argument: &str) -> bool {
     if argument.len() < 2 {
         return false;
@@ -470,10 +491,20 @@ fn argument_is_quoted(argument: &str) -> bool {
 }
 
 #[allow(unused)]
-fn add_quotes(argument: &str) -> String {
+fn add_double_quotes(argument: &str) -> String {
     format!("\"{}\"", argument)
 }
 
+#[allow(unused)]
+fn escape_double_quotes(argument: &str) -> Cow<'_, str> {
+    // allocate new string only if required
+    if argument.contains('"') {
+        Cow::Owned(argument.replace('"', r#"\""#))
+    } else {
+        Cow::Borrowed(argument)
+    }
+}
+
 #[allow(unused)]
 fn remove_quotes(argument: &str) -> Option<&str> {
     if !argument_is_quoted(argument) {
@@ -499,18 +530,16 @@ fn shell_os_paths() -> Vec<std::path::PathBuf> {
 #[cfg(test)]
 mod tests {
     use super::{
-        add_quotes, argument_contains_whitespace, argument_is_quoted, expand_tilde, remove_quotes,
+        add_double_quotes, argument_is_quoted, escape_double_quotes, expand_tilde, remove_quotes,
     };
     #[cfg(feature = "which")]
-    use super::{run_external_command, Context, InputStream};
+    use super::{run_external_command, EvaluationContext, InputStream};
 
     #[cfg(feature = "which")]
     use futures::executor::block_on;
     #[cfg(feature = "which")]
     use nu_errors::ShellError;
     #[cfg(feature = "which")]
-    use nu_protocol::Scope;
-    #[cfg(feature = "which")]
     use nu_test_support::commands::ExternalBuilder;
 
     // async fn read(mut stream: OutputStream) -> Option<Value> {
@@ -528,13 +557,15 @@ mod tests {
 
     #[cfg(feature = "which")]
     async fn non_existent_run() -> Result<(), ShellError> {
+        use nu_protocol::hir::ExternalRedirection;
         let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
 
         let input = InputStream::empty();
-        let mut ctx = Context::basic().expect("There was a problem creating a basic context.");
+        let mut ctx =
+            EvaluationContext::basic().expect("There was a problem creating a basic context.");
 
         assert!(
-            run_external_command(cmd, &mut ctx, input, &Scope::new(), false)
+            run_external_command(cmd, &mut ctx, input, ExternalRedirection::Stdout)
                 .await
                 .is_err()
         );
@@ -545,7 +576,7 @@ mod tests {
     // async fn failure_run() -> Result<(), ShellError> {
     //     let cmd = ExternalBuilder::for_name("fail").build();
 
-    //     let mut ctx = Context::basic().expect("There was a problem creating a basic context.");
+    //     let mut ctx = EvaluationContext::basic().expect("There was a problem creating a basic context.");
     //     let stream = run_external_command(cmd, &mut ctx, None, false)
     //         .await?
     //         .expect("There was a problem running the external command.");
@@ -573,10 +604,10 @@ mod tests {
     }
 
     #[test]
-    fn checks_contains_whitespace_from_argument_to_be_passed_in() {
-        assert_eq!(argument_contains_whitespace("andrés"), false);
-        assert_eq!(argument_contains_whitespace("and rés"), true);
-        assert_eq!(argument_contains_whitespace(r#"and\ rés"#), true);
+    fn checks_escape_double_quotes() {
+        assert_eq!(escape_double_quotes("andrés"), "andrés");
+        assert_eq!(escape_double_quotes(r#"an"drés"#), r#"an\"drés"#);
+        assert_eq!(escape_double_quotes(r#""an"drés""#), r#"\"an\"drés\""#);
     }
 
     #[test]
@@ -604,9 +635,8 @@ mod tests {
     }
 
     #[test]
-    fn adds_quotes_to_argument_to_be_passed_in() {
-        assert_eq!(add_quotes("andrés"), "\"andrés\"");
-        //assert_eq!(add_quotes("\"andrés\""), "\"andrés\"");
+    fn adds_double_quotes_to_argument_to_be_passed_in() {
+        assert_eq!(add_double_quotes("andrés"), "\"andrés\"");
     }
 
     #[test]

crates/nu-cli/src/commands/classified/internal.rs

@@ -1,35 +1,30 @@
-use crate::commands::command::whole_stream_command;
-use crate::commands::run_alias::AliasCommand;
+use std::sync::atomic::Ordering;
+
 use crate::commands::UnevaluatedCallInfo;
 use crate::prelude::*;
 use log::{log_enabled, trace};
 use nu_errors::ShellError;
-use nu_protocol::hir::InternalCommand;
-use nu_protocol::{CommandAction, Primitive, ReturnSuccess, Scope, UntaggedValue, Value};
+use nu_protocol::hir::{ExternalRedirection, InternalCommand};
+use nu_protocol::{CommandAction, Primitive, ReturnSuccess, UntaggedValue, Value};
 
 pub(crate) async fn run_internal_command(
     command: InternalCommand,
-    context: &mut Context,
+    context: &EvaluationContext,
     input: InputStream,
-    it: &Value,
-    vars: &IndexMap<String, Value>,
-    env: &IndexMap<String, String>,
 ) -> Result<InputStream, ShellError> {
     if log_enabled!(log::Level::Trace) {
         trace!(target: "nu::run::internal", "->");
         trace!(target: "nu::run::internal", "{}", command.name);
     }
 
-    let scope = Scope {
-        it: it.clone(),
-        vars: vars.clone(),
-        env: env.clone(),
-    };
     let objects: InputStream = trace_stream!(target: "nu::trace_stream::internal", "input" = input);
-    let internal_command = context.expect_command(&command.name);
+
+    let internal_command = context.scope.expect_command(&command.name);
 
     if command.name == "autoenv untrust" {
-        context.user_recently_used_autoenv_untrust = true;
+        context
+            .user_recently_used_autoenv_untrust
+            .store(true, Ordering::SeqCst);
     }
 
     let result = {
@@ -38,44 +33,38 @@ pub(crate) async fn run_internal_command(
                 internal_command?,
                 Tag::unknown_anchor(command.name_span),
                 command.args.clone(),
-                &scope,
                 objects,
             )
             .await?
     };
 
     let head = Arc::new(command.args.head.clone());
-    //let context = Arc::new(context.clone());
     let context = context.clone();
     let command = Arc::new(command);
-    let scope = Arc::new(scope);
-    // let scope = scope.clone();
 
     Ok(InputStream::from_stream(
         result
             .then(move |item| {
                 let head = head.clone();
                 let command = command.clone();
-                let mut context = context.clone();
-                let scope = scope.clone();
+                let context = context.clone();
                 async move {
                     match item {
                         Ok(ReturnSuccess::Action(action)) => match action {
                             CommandAction::ChangePath(path) => {
                                 context.shell_manager.set_path(path);
-                                InputStream::from_stream(futures::stream::iter(vec![]))
+                                InputStream::empty()
                             }
                             CommandAction::Exit => std::process::exit(0), // TODO: save history.txt
                             CommandAction::Error(err) => {
-                                context.error(err.clone());
-                                InputStream::one(UntaggedValue::Error(err).into_untagged_value())
+                                context.error(err);
+                                InputStream::empty()
                             }
                             CommandAction::AutoConvert(tagged_contents, extension) => {
                                 let contents_tag = tagged_contents.tag.clone();
                                 let command_name = format!("from {}", extension);
                                 let command = command.clone();
-                                if let Some(converter) = context.registry.get_command(&command_name)
-                                {
+                                if let Some(converter) = context.scope.get_command(&command_name) {
                                     let new_args = RawCommandArgs {
                                         host: context.host.clone(),
                                         ctrl_c: context.ctrl_c.clone(),
@@ -87,17 +76,14 @@ pub(crate) async fn run_internal_command(
                                                 positional: None,
                                                 named: None,
                                                 span: Span::unknown(),
-                                                is_last: false,
+                                                external_redirection: ExternalRedirection::Stdout,
                                             },
                                             name_tag: Tag::unknown_anchor(command.name_span),
-                                            scope: (&*scope).clone(),
                                         },
+                                        scope: context.scope.clone(),
                                     };
                                     let result = converter
-                                        .run(
-                                            new_args.with_input(vec![tagged_contents]),
-                                            &context.registry,
-                                        )
+                                        .run(new_args.with_input(vec![tagged_contents]))
                                         .await;
 
                                     match result {
@@ -131,8 +117,8 @@ pub(crate) async fn run_internal_command(
 
                                             futures::stream::iter(output).to_input_stream()
                                         }
-                                        Err(e) => {
-                                            context.add_error(e);
+                                        Err(err) => {
+                                            context.error(err);
                                             InputStream::empty()
                                         }
                                     }
@@ -148,13 +134,12 @@ pub(crate) async fn run_internal_command(
                                     context.shell_manager.insert_at_current(Box::new(
                                         match HelpShell::for_command(
                                             UntaggedValue::string(cmd).into_value(tag),
-                                            &context.registry(),
+                                            &context.scope,
                                         ) {
                                             Ok(v) => v,
                                             Err(err) => {
-                                                return InputStream::one(
-                                                    UntaggedValue::Error(err).into_untagged_value(),
-                                                )
+                                                context.error(err);
+                                                return InputStream::empty();
                                             }
                                         },
                                     ));
@@ -162,12 +147,11 @@ pub(crate) async fn run_internal_command(
                                 }
                                 _ => {
                                     context.shell_manager.insert_at_current(Box::new(
-                                        match HelpShell::index(&context.registry()) {
+                                        match HelpShell::index(&context.scope) {
                                             Ok(v) => v,
                                             Err(err) => {
-                                                return InputStream::one(
-                                                    UntaggedValue::Error(err).into_untagged_value(),
-                                                )
+                                                context.error(err);
+                                                return InputStream::empty();
                                             }
                                         },
                                     ));
@@ -182,50 +166,59 @@ pub(crate) async fn run_internal_command(
                             }
                             CommandAction::EnterShell(location) => {
                                 context.shell_manager.insert_at_current(Box::new(
-                                    match FilesystemShell::with_location(
-                                        location,
-                                        context.registry().clone(),
-                                    ) {
+                                    match FilesystemShell::with_location(location) {
                                         Ok(v) => v,
                                         Err(err) => {
-                                            return InputStream::one(
-                                                UntaggedValue::Error(err.into())
-                                                    .into_untagged_value(),
-                                            )
+                                            context.error(err.into());
+                                            return InputStream::empty();
                                         }
                                     },
                                 ));
                                 InputStream::from_stream(futures::stream::iter(vec![]))
                             }
-                            CommandAction::AddAlias(name, args, block) => {
-                                context.add_commands(vec![whole_stream_command(
-                                    AliasCommand::new(name, args, block),
-                                )]);
-                                InputStream::from_stream(futures::stream::iter(vec![]))
+                            CommandAction::AddPlugins(path) => {
+                                match crate::plugin::scan(vec![std::path::PathBuf::from(path)]) {
+                                    Ok(plugins) => {
+                                        context.add_commands(
+                                            plugins
+                                                .into_iter()
+                                                .filter(|p| {
+                                                    !context.is_command_registered(p.name())
+                                                })
+                                                .collect(),
+                                        );
+
+                                        InputStream::empty()
+                                    }
+                                    Err(reason) => {
+                                        context.error(reason);
+                                        InputStream::empty()
+                                    }
+                                }
                             }
                             CommandAction::PreviousShell => {
                                 context.shell_manager.prev();
-                                InputStream::from_stream(futures::stream::iter(vec![]))
+                                InputStream::empty()
                             }
                             CommandAction::NextShell => {
                                 context.shell_manager.next();
-                                InputStream::from_stream(futures::stream::iter(vec![]))
+                                InputStream::empty()
                             }
                             CommandAction::LeaveShell => {
                                 context.shell_manager.remove_at_current();
                                 if context.shell_manager.is_empty() {
                                     std::process::exit(0); // TODO: save history.txt
                                 }
-                                InputStream::from_stream(futures::stream::iter(vec![]))
+                                InputStream::empty()
                             }
                         },
 
                         Ok(ReturnSuccess::Value(Value {
                             value: UntaggedValue::Error(err),
-                            tag,
+                            ..
                         })) => {
-                            context.error(err.clone());
-                            InputStream::one(UntaggedValue::Error(err).into_value(tag))
+                            context.error(err);
+                            InputStream::empty()
                         }
 
                         Ok(ReturnSuccess::Value(v)) => InputStream::one(v),
@@ -245,8 +238,8 @@ pub(crate) async fn run_internal_command(
                         }
 
                         Err(err) => {
-                            context.error(err.clone());
-                            InputStream::one(UntaggedValue::Error(err).into_untagged_value())
+                            context.error(err);
+                            InputStream::empty()
                         }
                     }
                 }

crates/nu-cli/src/commands/classified/mod.rs

@@ -4,6 +4,7 @@ pub(crate) mod expr;
 pub(crate) mod external;
 pub(crate) mod internal;
 pub(crate) mod maybe_text_codec;
+pub(crate) mod plugin;
 
 #[allow(unused_imports)]
 pub(crate) use dynamic::Command as DynamicCommand;

crates/nu-cli/src/commands/classified/plugin.rs

@@ -1,30 +1,16 @@
-use crate::commands::WholeStreamCommand;
+use crate::commands::command::{whole_stream_command, WholeStreamCommand};
 use crate::prelude::*;
 use derive_new::new;
 use log::trace;
 use nu_errors::ShellError;
+use nu_plugin::jsonrpc::JsonRpc;
 use nu_protocol::{Primitive, ReturnValue, Signature, UntaggedValue, Value};
 use serde::{self, Deserialize, Serialize};
 use std::io::prelude::*;
 use std::io::BufReader;
 use std::io::Write;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct JsonRpc<T> {
-    jsonrpc: String,
-    pub method: String,
-    pub params: T,
-}
-
-impl<T> JsonRpc<T> {
-    pub fn new<U: Into<String>>(method: U, params: T) -> Self {
-        JsonRpc {
-            jsonrpc: "2.0".into(),
-            method: method.into(),
-            params,
-        }
-    }
-}
+use std::path::Path;
+use std::process::{Child, Command, Stdio};
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "method")]
@@ -35,15 +21,77 @@ pub enum NuResult {
     },
 }
 
+enum PluginCommand {
+    Filter(PluginFilter),
+    Sink(PluginSink),
+}
+
+impl PluginCommand {
+    fn command(self) -> Result<crate::commands::Command, ShellError> {
+        match self {
+            PluginCommand::Filter(cmd) => Ok(whole_stream_command(cmd)),
+            PluginCommand::Sink(cmd) => Ok(whole_stream_command(cmd)),
+        }
+    }
+}
+
+enum PluginMode {
+    Filter,
+    Sink,
+}
+
+pub struct PluginCommandBuilder {
+    mode: PluginMode,
+    name: String,
+    path: String,
+    config: Signature,
+}
+
+impl PluginCommandBuilder {
+    pub fn new(
+        name: impl Into<String>,
+        path: impl Into<String>,
+        config: impl Into<Signature>,
+    ) -> Self {
+        let config = config.into();
+
+        PluginCommandBuilder {
+            mode: if config.is_filter {
+                PluginMode::Filter
+            } else {
+                PluginMode::Sink
+            },
+            name: name.into(),
+            path: path.into(),
+            config,
+        }
+    }
+
+    pub fn build(&self) -> Result<crate::commands::Command, ShellError> {
+        let mode = &self.mode;
+
+        let name = self.name.clone();
+        let path = self.path.clone();
+        let config = self.config.clone();
+
+        let cmd = match mode {
+            PluginMode::Filter => PluginCommand::Filter(PluginFilter { name, path, config }),
+            PluginMode::Sink => PluginCommand::Sink(PluginSink { name, path, config }),
+        };
+
+        cmd.command()
+    }
+}
+
 #[derive(new)]
-pub struct PluginCommand {
+pub struct PluginFilter {
     name: String,
     path: String,
     config: Signature,
 }
 
 #[async_trait]
-impl WholeStreamCommand for PluginCommand {
+impl WholeStreamCommand for PluginFilter {
     fn name(&self) -> &str {
         &self.name
     }
@@ -56,24 +104,13 @@ impl WholeStreamCommand for PluginCommand {
         &self.config.usage
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        filter_plugin(self.path.clone(), args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        run_filter(self.path.clone(), (args)).await
     }
 }
 
-pub async fn filter_plugin(
-    path: String,
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+async fn run_filter(path: String, args: CommandArgs) -> Result<OutputStream, ShellError> {
     trace!("filter_plugin :: {}", path);
-    let registry = registry.clone();
-
-    let scope = args.call_info.scope.clone();
 
     let bos = futures::stream::iter(vec![
         UntaggedValue::Primitive(Primitive::BeginningOfStream).into_untagged_value()
@@ -82,13 +119,36 @@ pub async fn filter_plugin(
         UntaggedValue::Primitive(Primitive::EndOfStream).into_untagged_value()
     ]);
 
-    let args = args.evaluate_once_with_scope(&registry, &scope).await?;
+    let args = args.evaluate_once().await?;
 
-    let mut child = std::process::Command::new(path)
-        .stdin(std::process::Stdio::piped())
-        .stdout(std::process::Stdio::piped())
-        .spawn()
-        .expect("Failed to spawn child process");
+    let real_path = Path::new(&path);
+    let ext = real_path.extension();
+    let ps1_file = match ext {
+        Some(ext) => ext == "ps1",
+        None => false,
+    };
+
+    let mut child: Child = if ps1_file {
+        Command::new("pwsh")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .args(&[
+                "-NoLogo",
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                &real_path.to_string_lossy(),
+            ])
+            .spawn()
+            .expect("Failed to spawn PowerShell process")
+    } else {
+        Command::new(path)
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .expect("Failed to spawn child process")
+    };
 
     let call_info = args.call_info.clone();
 
@@ -111,6 +171,7 @@ pub async fn filter_plugin(
 
                     let request = JsonRpc::new("begin_filter", call_info.clone());
                     let request_raw = serde_json::to_string(&request);
+                    trace!("begin_filter:request {:?}", &request_raw);
 
                     match request_raw {
                         Err(_) => {
@@ -136,6 +197,8 @@ pub async fn filter_plugin(
                     match reader.read_line(&mut input) {
                         Ok(_) => {
                             let response = serde_json::from_str::<NuResult>(&input);
+                            trace!("begin_filter:response {:?}", &response);
+
                             match response {
                                 Ok(NuResult::response { params }) => match params {
                                     Ok(params) => futures::stream::iter(params).to_output_stream(),
@@ -168,6 +231,7 @@ pub async fn filter_plugin(
 
                     let request: JsonRpc<std::vec::Vec<Value>> = JsonRpc::new("end_filter", vec![]);
                     let request_raw = serde_json::to_string(&request);
+                    trace!("end_filter:request {:?}", &request_raw);
 
                     match request_raw {
                         Err(_) => {
@@ -193,6 +257,8 @@ pub async fn filter_plugin(
                     let stream = match reader.read_line(&mut input) {
                         Ok(_) => {
                             let response = serde_json::from_str::<NuResult>(&input);
+                            trace!("end_filter:response {:?}", &response);
+
                             match response {
                                 Ok(NuResult::response { params }) => match params {
                                     Ok(params) => futures::stream::iter(params).to_output_stream(),
@@ -220,6 +286,7 @@ pub async fn filter_plugin(
 
                     let request: JsonRpc<std::vec::Vec<Value>> = JsonRpc::new("quit", vec![]);
                     let request_raw = serde_json::to_string(&request);
+                    trace!("quit:request {:?}", &request_raw);
 
                     match request_raw {
                         Ok(request_raw) => {
@@ -246,6 +313,8 @@ pub async fn filter_plugin(
 
                     let request = JsonRpc::new("filter", v);
                     let request_raw = serde_json::to_string(&request);
+                    trace!("filter:request {:?}", &request_raw);
+
                     match request_raw {
                         Ok(request_raw) => {
                             let _ = stdin.write(format!("{}\n", request_raw).as_bytes());
@@ -262,6 +331,8 @@ pub async fn filter_plugin(
                     match reader.read_line(&mut input) {
                         Ok(_) => {
                             let response = serde_json::from_str::<NuResult>(&input);
+                            trace!("filter:response {:?}", &response);
+
                             match response {
                                 Ok(NuResult::response { params }) => match params {
                                     Ok(params) => futures::stream::iter(params).to_output_stream(),
@@ -308,22 +379,13 @@ impl WholeStreamCommand for PluginSink {
         &self.config.usage
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        sink_plugin(self.path.clone(), args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        run_sink(self.path.clone(), args).await
     }
 }
 
-pub async fn sink_plugin(
-    path: String,
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
+async fn run_sink(path: String, args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
     let call_info = args.call_info.clone();
 
     let input: Vec<Value> = args.input.collect().await;
@@ -335,7 +397,33 @@ pub async fn sink_plugin(
             let _ = writeln!(tmpfile, "{}", request_raw);
             let _ = tmpfile.flush();
 
-            let child = std::process::Command::new(path).arg(tmpfile.path()).spawn();
+            let real_path = Path::new(&path);
+            let ext = real_path.extension();
+            let ps1_file = match ext {
+                Some(ext) => ext == "ps1",
+                None => false,
+            };
+
+            // TODO: This sink may not work in powershell, trying to find
+            // an example of what CallInfo would look like in this temp file
+            let child = if ps1_file {
+                Command::new("pwsh")
+                    .args(&[
+                        "-NoLogo",
+                        "-NoProfile",
+                        "-ExecutionPolicy",
+                        "Bypass",
+                        "-File",
+                        &real_path.to_string_lossy(),
+                        &tmpfile
+                            .path()
+                            .to_str()
+                            .expect("Failed getting tmpfile path"),
+                    ])
+                    .spawn()
+            } else {
+                Command::new(path).arg(&tmpfile.path()).spawn()
+            };
 
             if let Ok(mut child) = child {
                 let _ = child.wait();

crates/nu-cli/src/commands/clear.rs

@@ -17,10 +17,10 @@ impl WholeStreamCommand for Clear {
     }
 
     fn usage(&self) -> &str {
-        "clears the terminal"
+        "Clears the terminal"
     }
 
-    async fn run(&self, _: CommandArgs, _: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    async fn run(&self, _: CommandArgs) -> Result<OutputStream, ShellError> {
         if cfg!(windows) {
             Command::new("cmd")
                 .args(&["/C", "cls"])
@@ -43,15 +43,3 @@ impl WholeStreamCommand for Clear {
         }]
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::Clear;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Clear {})
-    }
-}

crates/nu-cli/src/commands/clip.rs

@@ -1,11 +1,10 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use futures::stream::StreamExt;
 use nu_errors::ShellError;
 use nu_protocol::{Signature, Value};
 
-use clipboard::{ClipboardContext, ClipboardProvider};
+use arboard::Clipboard;
 
 pub struct Clip;
 
@@ -23,60 +22,57 @@ impl WholeStreamCommand for Clip {
         "Copy the contents of the pipeline to the copy/paste buffer"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        clip(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clip(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Save text to the clipboard",
-            example: "echo 'secret value' | clip",
-            result: None,
-        }]
+        vec![
+            Example {
+                description: "Save text to the clipboard",
+                example: "echo 'secret value' | clip",
+                result: None,
+            },
+            Example {
+                description: "Save numbers to the clipboard",
+                example: "random integer 10000000..99999999 | clip",
+                result: None,
+            },
+        ]
     }
 }
 
-pub async fn clip(
-    args: CommandArgs,
-    _registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn clip(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let input = args.input;
     let name = args.call_info.name_tag.clone();
     let values: Vec<Value> = input.collect().await;
 
-    if let Ok(clip_context) = ClipboardProvider::new() {
-        let mut clip_context: ClipboardContext = clip_context;
+    if let Ok(mut clip_context) = Clipboard::new() {
         let mut new_copy_data = String::new();
 
         if !values.is_empty() {
             let mut first = true;
             for i in values.iter() {
                 if !first {
-                    new_copy_data.push_str("\n");
+                    new_copy_data.push('\n');
                 } else {
                     first = false;
                 }
 
-                let string: String = match i.as_string() {
-                    Ok(string) => string.to_string(),
-                    Err(_) => {
-                        return Err(ShellError::labeled_error(
-                            "Given non-string data",
-                            "expected strings from pipeline",
-                            name,
-                        ))
-                    }
-                };
+                let string: String = i.convert_to_string();
+                if string.is_empty() {
+                    return Err(ShellError::labeled_error(
+                        "Unable to convert to string",
+                        "Unable to convert to string",
+                        name,
+                    ));
+                }
 
                 new_copy_data.push_str(&string);
             }
         }
 
-        match clip_context.set_contents(new_copy_data) {
+        match clip_context.set_text(new_copy_data) {
             Ok(_) => {}
             Err(_) => {
                 return Err(ShellError::labeled_error(
@@ -99,11 +95,12 @@ pub async fn clip(
 #[cfg(test)]
 mod tests {
     use super::Clip;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Clip {})
+        Ok(test_examples(Clip {})?)
     }
 }

crates/nu-cli/src/commands/command.rs

@@ -1,43 +1,26 @@
-use crate::commands::help::get_help;
-use crate::context::CommandRegistry;
 use crate::deserializer::ConfigDeserializer;
 use crate::evaluate::evaluate_args::evaluate_args;
 use crate::prelude::*;
+use crate::{commands::help::get_help, run_block};
 use derive_new::new;
 use getset::Getters;
 use nu_errors::ShellError;
-use nu_protocol::hir;
-use nu_protocol::{CallInfo, EvaluatedArgs, ReturnSuccess, Scope, Signature, UntaggedValue, Value};
+use nu_protocol::hir::{self, Block};
+use nu_protocol::{CallInfo, EvaluatedArgs, ReturnSuccess, Signature, UntaggedValue, Value};
 use parking_lot::Mutex;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use std::ops::Deref;
 use std::sync::atomic::AtomicBool;
 
-#[derive(Deserialize, Serialize, Debug, Clone)]
+#[derive(Debug, Clone)]
 pub struct UnevaluatedCallInfo {
     pub args: hir::Call,
     pub name_tag: Tag,
-    pub scope: Scope,
 }
 
 impl UnevaluatedCallInfo {
-    pub async fn evaluate(self, registry: &CommandRegistry) -> Result<CallInfo, ShellError> {
-        let args = evaluate_args(&self.args, registry, &self.scope).await?;
-
-        Ok(CallInfo {
-            args,
-            name_tag: self.name_tag,
-        })
-    }
-
-    pub async fn evaluate_with_new_it(
-        self,
-        registry: &CommandRegistry,
-        it: &Value,
-    ) -> Result<CallInfo, ShellError> {
-        let mut scope = self.scope.clone();
-        scope.it = it.clone();
-        let args = evaluate_args(&self.args, registry, &scope).await?;
+    pub async fn evaluate(self, ctx: &EvaluationContext) -> Result<CallInfo, ShellError> {
+        let args = evaluate_args(&self.args, ctx).await?;
 
         Ok(CallInfo {
             args,
@@ -58,8 +41,8 @@ pub struct CommandArgs {
     pub current_errors: Arc<Mutex<Vec<ShellError>>>,
     pub shell_manager: ShellManager,
     pub call_info: UnevaluatedCallInfo,
+    pub scope: Scope,
     pub input: InputStream,
-    pub raw_input: String,
 }
 
 #[derive(Getters, Clone)]
@@ -69,6 +52,7 @@ pub struct RawCommandArgs {
     pub ctrl_c: Arc<AtomicBool>,
     pub current_errors: Arc<Mutex<Vec<ShellError>>>,
     pub shell_manager: ShellManager,
+    pub scope: Scope,
     pub call_info: UnevaluatedCallInfo,
 }
 
@@ -80,8 +64,8 @@ impl RawCommandArgs {
             current_errors: self.current_errors,
             shell_manager: self.shell_manager,
             call_info: self.call_info,
+            scope: self.scope,
             input: input.into(),
-            raw_input: String::default(),
         }
     }
 }
@@ -93,15 +77,14 @@ impl std::fmt::Debug for CommandArgs {
 }
 
 impl CommandArgs {
-    pub async fn evaluate_once(
-        self,
-        registry: &CommandRegistry,
-    ) -> Result<EvaluatedWholeStreamCommandArgs, ShellError> {
+    pub async fn evaluate_once(self) -> Result<EvaluatedWholeStreamCommandArgs, ShellError> {
+        let ctx = EvaluationContext::from_args(&self);
         let host = self.host.clone();
         let ctrl_c = self.ctrl_c.clone();
         let shell_manager = self.shell_manager.clone();
         let input = self.input;
-        let call_info = self.call_info.evaluate(registry).await?;
+        let call_info = self.call_info.evaluate(&ctx).await?;
+        let scope = self.scope.clone();
 
         Ok(EvaluatedWholeStreamCommandArgs::new(
             host,
@@ -109,39 +92,12 @@ impl CommandArgs {
             shell_manager,
             call_info,
             input,
+            scope,
         ))
     }
 
-    pub async fn evaluate_once_with_scope(
-        self,
-        registry: &CommandRegistry,
-        scope: &Scope,
-    ) -> Result<EvaluatedWholeStreamCommandArgs, ShellError> {
-        let host = self.host.clone();
-        let ctrl_c = self.ctrl_c.clone();
-        let shell_manager = self.shell_manager.clone();
-        let input = self.input;
-        let call_info = UnevaluatedCallInfo {
-            name_tag: self.call_info.name_tag,
-            args: self.call_info.args,
-            scope: scope.clone(),
-        };
-        let call_info = call_info.evaluate(registry).await?;
-
-        Ok(EvaluatedWholeStreamCommandArgs::new(
-            host,
-            ctrl_c,
-            shell_manager,
-            call_info,
-            input,
-        ))
-    }
-
-    pub async fn process<'de, T: Deserialize<'de>>(
-        self,
-        registry: &CommandRegistry,
-    ) -> Result<(T, InputStream), ShellError> {
-        let args = self.evaluate_once(registry).await?;
+    pub async fn process<'de, T: Deserialize<'de>>(self) -> Result<(T, InputStream), ShellError> {
+        let args = self.evaluate_once().await?;
         let call_info = args.call_info.clone();
 
         let mut deserializer = ConfigDeserializer::from_call_info(call_info);
@@ -156,14 +112,13 @@ pub struct RunnableContext {
     pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
     pub ctrl_c: Arc<AtomicBool>,
     pub current_errors: Arc<Mutex<Vec<ShellError>>>,
-    pub registry: CommandRegistry,
+    pub scope: Scope,
     pub name: Tag,
-    pub raw_input: String,
 }
 
 impl RunnableContext {
     pub fn get_command(&self, name: &str) -> Option<Command> {
-        self.registry.get_command(name)
+        self.scope.get_command(name)
     }
 }
 
@@ -186,6 +141,7 @@ impl EvaluatedWholeStreamCommandArgs {
         shell_manager: ShellManager,
         call_info: CallInfo,
         input: impl Into<InputStream>,
+        scope: Scope,
     ) -> EvaluatedWholeStreamCommandArgs {
         EvaluatedWholeStreamCommandArgs {
             args: EvaluatedCommandArgs {
@@ -193,6 +149,7 @@ impl EvaluatedWholeStreamCommandArgs {
                 ctrl_c,
                 shell_manager,
                 call_info,
+                scope,
             },
             input: input.into(),
         }
@@ -215,37 +172,6 @@ impl EvaluatedWholeStreamCommandArgs {
     }
 }
 
-#[derive(Getters)]
-#[get = "pub"]
-pub struct EvaluatedFilterCommandArgs {
-    args: EvaluatedCommandArgs,
-}
-
-impl Deref for EvaluatedFilterCommandArgs {
-    type Target = EvaluatedCommandArgs;
-    fn deref(&self) -> &Self::Target {
-        &self.args
-    }
-}
-
-impl EvaluatedFilterCommandArgs {
-    pub fn new(
-        host: Arc<parking_lot::Mutex<dyn Host>>,
-        ctrl_c: Arc<AtomicBool>,
-        shell_manager: ShellManager,
-        call_info: CallInfo,
-    ) -> EvaluatedFilterCommandArgs {
-        EvaluatedFilterCommandArgs {
-            args: EvaluatedCommandArgs {
-                host,
-                ctrl_c,
-                shell_manager,
-                call_info,
-            },
-        }
-    }
-}
-
 #[derive(Getters, new)]
 #[get = "pub(crate)"]
 pub struct EvaluatedCommandArgs {
@@ -253,6 +179,7 @@ pub struct EvaluatedCommandArgs {
     pub ctrl_c: Arc<AtomicBool>,
     pub shell_manager: ShellManager,
     pub call_info: CallInfo,
+    pub scope: Scope,
 }
 
 impl EvaluatedCommandArgs {
@@ -262,10 +189,10 @@ impl EvaluatedCommandArgs {
 
     /// Get the nth positional argument, error if not possible
     pub fn expect_nth(&self, pos: usize) -> Result<&Value, ShellError> {
-        match self.call_info.args.nth(pos) {
-            None => Err(ShellError::unimplemented("Better error: expect_nth")),
-            Some(item) => Ok(item),
-        }
+        self.call_info
+            .args
+            .nth(pos)
+            .ok_or_else(|| ShellError::unimplemented("Better error: expect_nth"))
     }
 
     pub fn get(&self, name: &str) -> Option<&Value> {
@@ -293,21 +220,113 @@ pub trait WholeStreamCommand: Send + Sync {
 
     fn usage(&self) -> &str;
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError>;
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError>;
 
     fn is_binary(&self) -> bool {
         false
     }
 
+    // Commands that are not meant to be run by users
+    fn is_internal(&self) -> bool {
+        false
+    }
+
     fn examples(&self) -> Vec<Example> {
         Vec::new()
     }
 }
 
+// Custom commands are blocks, so we can use the information in the block to also
+// implement a WholeStreamCommand
+#[allow(clippy::suspicious_else_formatting)]
+#[async_trait]
+impl WholeStreamCommand for Block {
+    fn name(&self) -> &str {
+        &self.params.name
+    }
+
+    fn signature(&self) -> Signature {
+        self.params.clone()
+    }
+
+    fn usage(&self) -> &str {
+        ""
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let call_info = args.call_info.clone();
+
+        let mut block = self.clone();
+        block.set_redirect(call_info.args.external_redirection);
+
+        let ctx = EvaluationContext::from_args(&args);
+        let evaluated = call_info.evaluate(&ctx).await?;
+
+        let input = args.input;
+        ctx.scope.enter_scope();
+        if let Some(args) = evaluated.args.positional {
+            // FIXME: do not do this
+            for arg in args.into_iter().zip(self.params.positional.iter()) {
+                let name = arg.1 .0.name();
+
+                if name.starts_with('$') {
+                    ctx.scope.add_var(name, arg.0);
+                } else {
+                    ctx.scope.add_var(format!("${}", name), arg.0);
+                }
+            }
+        }
+        if let Some(args) = evaluated.args.named {
+            for named in &block.params.named {
+                let name = named.0;
+                if let Some(value) = args.get(name) {
+                    if name.starts_with('$') {
+                        ctx.scope.add_var(name, value.clone());
+                    } else {
+                        ctx.scope.add_var(format!("${}", name), value.clone());
+                    }
+                } else if name.starts_with('$') {
+                    ctx.scope
+                        .add_var(name, UntaggedValue::nothing().into_untagged_value());
+                } else {
+                    ctx.scope.add_var(
+                        format!("${}", name),
+                        UntaggedValue::nothing().into_untagged_value(),
+                    );
+                }
+            }
+        } else {
+            for named in &block.params.named {
+                let name = named.0;
+                if name.starts_with('$') {
+                    ctx.scope
+                        .add_var(name, UntaggedValue::nothing().into_untagged_value());
+                } else {
+                    ctx.scope.add_var(
+                        format!("${}", name),
+                        UntaggedValue::nothing().into_untagged_value(),
+                    );
+                }
+            }
+        }
+        let result = run_block(&block, &ctx, input).await;
+        ctx.scope.exit_scope();
+        result.map(|x| x.to_output_stream())
+    }
+
+    fn is_binary(&self) -> bool {
+        false
+    }
+
+    fn is_internal(&self) -> bool {
+        false
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![]
+    }
+}
+
 #[derive(Clone)]
 pub struct Command(Arc<dyn WholeStreamCommand>);
 
@@ -347,19 +366,14 @@ impl Command {
         self.0.examples()
     }
 
-    pub async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    pub async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         if args.call_info.switch_present("help") {
             let cl = self.0.clone();
-            let registry = registry.clone();
             Ok(OutputStream::one(Ok(ReturnSuccess::Value(
-                UntaggedValue::string(get_help(&*cl, &registry)).into_value(Tag::unknown()),
+                UntaggedValue::string(get_help(&*cl, &args.scope)).into_value(Tag::unknown()),
             ))))
         } else {
-            self.0.run(args, registry).await
+            self.0.run(args).await
         }
     }
 
@@ -367,74 +381,15 @@ impl Command {
         self.0.is_binary()
     }
 
+    pub fn is_internal(&self) -> bool {
+        self.0.is_internal()
+    }
+
     pub fn stream_command(&self) -> &dyn WholeStreamCommand {
         &*self.0
     }
 }
 
-pub struct FnFilterCommand {
-    name: String,
-    func: fn(EvaluatedFilterCommandArgs) -> Result<OutputStream, ShellError>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for FnFilterCommand {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn usage(&self) -> &str {
-        "usage"
-    }
-
-    async fn run(
-        &self,
-        CommandArgs {
-            host,
-            ctrl_c,
-            shell_manager,
-            call_info,
-            input,
-            ..
-        }: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = Arc::new(registry.clone());
-        let func = self.func;
-
-        Ok(input
-            .then(move |it| {
-                let host = host.clone();
-                let registry = registry.clone();
-                let ctrl_c = ctrl_c.clone();
-                let shell_manager = shell_manager.clone();
-                let call_info = call_info.clone();
-                async move {
-                    let call_info = match call_info.evaluate_with_new_it(&*registry, &it).await {
-                        Err(err) => {
-                            return OutputStream::one(Err(err));
-                        }
-                        Ok(args) => args,
-                    };
-
-                    let args = EvaluatedFilterCommandArgs::new(
-                        host.clone(),
-                        ctrl_c.clone(),
-                        shell_manager.clone(),
-                        call_info,
-                    );
-
-                    match func(args) {
-                        Err(err) => return OutputStream::one(Err(err)),
-                        Ok(stream) => stream,
-                    }
-                }
-            })
-            .flatten()
-            .to_output_stream())
-    }
-}
-
 pub fn whole_stream_command(command: impl WholeStreamCommand + 'static) -> Command {
     Command(Arc::new(command))
 }

crates/nu-cli/src/commands/compact.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use futures::future;
 use futures::stream::StreamExt;
@@ -28,40 +27,21 @@ impl WholeStreamCommand for Compact {
         "Creates a table with non-empty rows"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        compact(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        compact(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Filter out all null entries in a list",
-                example: "echo [1 2 $null 3 $null $null] | compact",
-                result: Some(vec![
-                    UntaggedValue::int(1).into(),
-                    UntaggedValue::int(2).into(),
-                    UntaggedValue::int(3).into(),
-                ]),
-            },
-            Example {
-                description: "Filter out all directory entries having no 'target'",
-                example: "ls -af | compact target",
-                result: None,
-            },
-        ]
+        vec![Example {
+            description: "Filter out all directory entries having no 'target'",
+            example: "ls -la | compact target",
+            result: None,
+        }]
     }
 }
 
-pub async fn compact(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (CompactArgs { rest: columns }, input) = args.process(&registry).await?;
+pub async fn compact(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (CompactArgs { rest: columns }, input) = args.process().await?;
     Ok(input
         .filter_map(move |item| {
             future::ready(if columns.is_empty() {
@@ -95,11 +75,12 @@ pub async fn compact(
 #[cfg(test)]
 mod tests {
     use super::Compact;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Compact {})
+        Ok(test_examples(Compact {})?)
     }
 }

crates/nu-cli/src/commands/config/clear.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
@@ -20,12 +19,8 @@ impl WholeStreamCommand for SubCommand {
         "clear the config"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        clear(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clear(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -37,15 +32,12 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn clear(
-    args: CommandArgs,
-    _registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn clear(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_span = args.call_info.name_tag.clone();
 
     // NOTE: None because we are not loading a new config file, we just want to read from the
     // existing config
-    let mut result = crate::data::config::read(name_span, &None)?;
+    let mut result = nu_data::config::read(name_span, &None)?;
 
     result.clear();
 

crates/nu-cli/src/commands/config/command.rs

@@ -1,6 +1,6 @@
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
-use crate::{CommandArgs, CommandRegistry, OutputStream};
+use crate::{CommandArgs, OutputStream};
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
 
@@ -20,14 +20,10 @@ impl WholeStreamCommand for Command {
         "Configuration management."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        _registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let name_span = args.call_info.name_tag.clone();
         let name = args.call_info.name_tag;
-        let result = crate::data::config::read(name_span, &None)?;
+        let result = nu_data::config::read(name_span, &None)?;
 
         Ok(futures::stream::iter(vec![ReturnSuccess::value(
             UntaggedValue::Row(result.into()).into_value(name),

crates/nu-cli/src/commands/config/get.rs

@@ -1,15 +1,13 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 
 pub struct SubCommand;
 
 #[derive(Deserialize)]
 pub struct GetArgs {
-    get: Tagged<String>,
+    path: ColumnPath,
 }
 
 #[async_trait]
@@ -21,7 +19,7 @@ impl WholeStreamCommand for SubCommand {
     fn signature(&self) -> Signature {
         Signature::build("config get").required(
             "get",
-            SyntaxShape::Any,
+            SyntaxShape::ColumnPath,
             "value to get from the config",
         )
     }
@@ -30,12 +28,8 @@ impl WholeStreamCommand for SubCommand {
         "Gets a value from the config"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        get(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        get(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -47,21 +41,15 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn get(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let (GetArgs { get }, _) = args.process(&registry).await?;
+pub async fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (GetArgs { path }, _) = args.process().await?;
 
     // NOTE: None because we are not loading a new config file, we just want to read from the
     // existing config
-    let result = crate::data::config::read(name_span, &None)?;
+    let result = UntaggedValue::row(nu_data::config::read(&name_tag, &None)?).into_value(&name_tag);
 
-    let key = get.to_string();
-    let value = result
-        .get(&key)
-        .ok_or_else(|| ShellError::labeled_error("Missing key in config", "key", get.tag()))?;
+    let value = crate::commands::get::get_column_path(&path, &result)?;
 
     Ok(match value {
         Value {
@@ -75,9 +63,6 @@ pub async fn get(
 
             futures::stream::iter(list).to_output_stream()
         }
-        x => {
-            let x = x.clone();
-            OutputStream::one(ReturnSuccess::value(x))
-        }
+        x => OutputStream::one(ReturnSuccess::value(x)),
     })
 }

crates/nu-cli/src/commands/config/load.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
@@ -31,26 +30,19 @@ impl WholeStreamCommand for SubCommand {
         "Loads the config from the path given"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        set(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args).await
     }
 }
 
-pub async fn set(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
     let name_span = args.call_info.name_tag.clone();
-    let (LoadArgs { load }, _) = args.process(&registry).await?;
+    let (LoadArgs { load }, _) = args.process().await?;
 
     let configuration = load.item().clone();
 
-    let result = crate::data::config::read(name_span, &Some(configuration))?;
+    let result = nu_data::config::read(name_span, &Some(configuration))?;
 
     Ok(futures::stream::iter(vec![ReturnSuccess::value(
         UntaggedValue::Row(result.into()).into_value(name),

crates/nu-cli/src/commands/config/path.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue};
@@ -20,12 +19,8 @@ impl WholeStreamCommand for SubCommand {
         "return the path to the config file"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        path(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        path(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -37,10 +32,7 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn path(
-    args: CommandArgs,
-    _registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn path(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let path = config::default_path()?;
 
     Ok(OutputStream::one(ReturnSuccess::value(

crates/nu-cli/src/commands/config/remove.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
@@ -30,31 +29,24 @@ impl WholeStreamCommand for SubCommand {
         "Removes a value from the config"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        remove(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        remove(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Remove the startup commands",
-            example: "config --remove startup",
+            example: "config remove startup",
             result: None,
         }]
     }
 }
 
-pub async fn remove(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn remove(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_span = args.call_info.name_tag.clone();
-    let (RemoveArgs { remove }, _) = args.process(&registry).await?;
+    let (RemoveArgs { remove }, _) = args.process().await?;
 
-    let mut result = crate::data::config::read(name_span, &None)?;
+    let mut result = nu_data::config::read(name_span, &None)?;
 
     let key = remove.to_string();
 

crates/nu-cli/src/commands/config/set.rs

@@ -1,15 +1,13 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
+use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 
 pub struct SubCommand;
 
 #[derive(Deserialize)]
 pub struct SetArgs {
-    key: Tagged<String>,
+    path: ColumnPath,
     value: Value,
 }
 
@@ -21,7 +19,7 @@ impl WholeStreamCommand for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("config set")
-            .required("key", SyntaxShape::String, "variable name to set")
+            .required("key", SyntaxShape::ColumnPath, "variable name to set")
             .required("value", SyntaxShape::Any, "value to use")
     }
 
@@ -29,39 +27,63 @@ impl WholeStreamCommand for SubCommand {
         "Sets a value in the config"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        set(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Set completion_mode to circular",
-            example: "config set [completion_mode circular]",
-            result: None,
-        }]
+        vec![
+            Example {
+                description: "Set auto pivoting",
+                example: "config set pivot_mode always",
+                result: None,
+            },
+            Example {
+                description: "Set line editor options",
+                example: "config set line_editor [[edit_mode, completion_type]; [emacs circular]]",
+                result: None,
+            },
+            Example {
+                description: "Set coloring options",
+                example: "config set color_config [[header_align header_bold]; [left $true]]",
+                result: None,
+            },
+            Example {
+                description: "Set nested options",
+                example: "config set color_config.header_color white",
+                result: None,
+            },
+        ]
     }
 }
 
-pub async fn set(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let (SetArgs { key, value }, _) = args.process(&registry).await?;
+pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name_tag = args.call_info.name_tag.clone();
+    let (SetArgs { path, mut value }, _) = args.process().await?;
 
     // NOTE: None because we are not loading a new config file, we just want to read from the
     // existing config
-    let mut result = crate::data::config::read(name_span, &None)?;
+    let raw_entries = nu_data::config::read(&name_tag, &None)?;
+    let configuration = UntaggedValue::row(raw_entries).into_value(&name_tag);
 
-    result.insert(key.to_string(), value.clone());
+    if let UntaggedValue::Table(rows) = &value.value {
+        if rows.len() == 1 && rows[0].is_row() {
+            value = rows[0].clone();
+        }
+    }
 
-    config::write(&result, &None)?;
+    match configuration.forgiving_insert_data_at_column_path(&path, value) {
+        Ok(Value {
+            value: UntaggedValue::Row(changes),
+            ..
+        }) => {
+            config::write(&changes.entries, &None)?;
 
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::Row(result.into()).into_value(&value.tag),
-    )))
+            Ok(OutputStream::one(ReturnSuccess::value(
+                UntaggedValue::Row(changes).into_value(name_tag),
+            )))
+        }
+        Ok(_) => Ok(OutputStream::empty()),
+        Err(reason) => Err(reason),
+    }
 }

crates/nu-cli/src/commands/config/set_into.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
@@ -30,12 +29,8 @@ impl WholeStreamCommand for SubCommand {
         "Sets a value in the config"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        set_into(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set_into(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -47,20 +42,17 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn set_into(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn set_into(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_span = args.call_info.name_tag.clone();
     let name = args.call_info.name_tag.clone();
 
-    let (SetIntoArgs { set_into: v }, input) = args.process(&registry).await?;
+    let (SetIntoArgs { set_into: v }, input) = args.process().await?;
 
     // NOTE: None because we are not loading a new config file, we just want to read from the
     // existing config
-    let mut result = crate::data::config::read(name_span, &None)?;
+    let mut result = nu_data::config::read(name_span, &None)?;
 
-    // In the original code, this is set to `Some` if the `--load flag is set`
+    // In the original code, this is set to `Some` if the `load flag is set`
     let configuration = None;
 
     let rows: Vec<Value> = input.collect().await;

crates/nu-cli/src/commands/count.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use futures::stream::StreamExt;
 use nu_errors::ShellError;
@@ -7,6 +6,11 @@ use nu_protocol::{Signature, UntaggedValue, Value};
 
 pub struct Count;
 
+#[derive(Deserialize)]
+pub struct CountArgs {
+    column: bool,
+}
+
 #[async_trait]
 impl WholeStreamCommand for Count {
     fn name(&self) -> &str {
@@ -14,43 +18,69 @@ impl WholeStreamCommand for Count {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("count")
+        Signature::build("count").switch(
+            "column",
+            "Calculate number of columns in table",
+            Some('c'),
+        )
     }
 
     fn usage(&self) -> &str {
         "Show the total number of rows or items."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        _registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let name = args.call_info.name_tag.clone();
-        let rows: Vec<Value> = args.input.collect().await;
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let tag = args.call_info.name_tag.clone();
+        let (CountArgs { column }, input) = args.process().await?;
+        let rows: Vec<Value> = input.collect().await;
 
-        Ok(OutputStream::one(
-            UntaggedValue::int(rows.len()).into_value(name),
-        ))
+        let count = if column {
+            if rows.is_empty() {
+                0
+            } else {
+                match &rows[0].value {
+                    UntaggedValue::Row(dictionary) => dictionary.length(),
+                    _ => {
+                        return Err(ShellError::labeled_error(
+                            "Cannot obtain column count",
+                            "cannot obtain column count",
+                            tag,
+                        ));
+                    }
+                }
+            }
+        } else {
+            rows.len()
+        };
+
+        Ok(OutputStream::one(UntaggedValue::int(count).into_value(tag)))
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Count the number of entries in a list",
-            example: "echo [1 2 3 4 5] | count",
-            result: Some(vec![UntaggedValue::int(5).into()]),
-        }]
+        vec![
+            Example {
+                description: "Count the number of entries in a list",
+                example: "echo [1 2 3 4 5] | count",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Count the number of columns in the calendar table",
+                example: "cal | count -c",
+                result: None,
+            },
+        ]
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::Count;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Count {})
+        Ok(test_examples(Count {})?)
     }
 }

crates/nu-cli/src/commands/cp.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{Signature, SyntaxShape};
@@ -36,14 +35,10 @@ impl WholeStreamCommand for Cpy {
         "Copy files."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let shell_manager = args.shell_manager.clone();
         let name = args.call_info.name_tag.clone();
-        let (args, _) = args.process(&registry).await?;
+        let (args, _) = args.process().await?;
         shell_manager.cp(args, name)
     }
 
@@ -66,11 +61,12 @@ impl WholeStreamCommand for Cpy {
 #[cfg(test)]
 mod tests {
     use super::Cpy;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Cpy {})
+        Ok(test_examples(Cpy {})?)
     }
 }

crates/nu-cli/src/commands/date.rs

@@ -1,175 +0,0 @@
-use crate::prelude::*;
-use chrono::{DateTime, Local, Utc};
-use nu_errors::ShellError;
-use nu_protocol::{Dictionary, Value};
-
-use crate::commands::WholeStreamCommand;
-use chrono::{Datelike, TimeZone, Timelike};
-use core::fmt::Display;
-use indexmap::IndexMap;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
-
-pub struct Date;
-
-#[async_trait]
-impl WholeStreamCommand for Date {
-    fn name(&self) -> &str {
-        "date"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("date")
-            .switch("utc", "use universal time (UTC)", Some('u'))
-            .switch("local", "use the local time", Some('l'))
-            .named(
-                "format",
-                SyntaxShape::String,
-                "report datetime in supplied strftime format",
-                Some('f'),
-            )
-            .switch("raw", "print date without tables", Some('r'))
-    }
-
-    fn usage(&self) -> &str {
-        "Get the current datetime."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        date(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Get the current local time and date",
-                example: "date",
-                result: None,
-            },
-            Example {
-                description: "Get the current UTC time and date",
-                example: "date --utc",
-                result: None,
-            },
-            Example {
-                description: "Get the current time and date and report it based on format",
-                example: "date --format '%Y-%m-%d %H:%M:%S.%f %z'",
-                result: None,
-            },
-            Example {
-                description: "Get the current time and date and report it without a table",
-                example: "date --format '%Y-%m-%d %H:%M:%S.%f %z' --raw",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub fn date_to_value_raw<T: TimeZone>(dt: DateTime<T>, dt_format: String) -> String
-where
-    T::Offset: Display,
-{
-    let result = dt.format(&dt_format);
-    format!("{}", result)
-}
-
-pub fn date_to_value<T: TimeZone>(dt: DateTime<T>, tag: Tag, dt_format: String) -> Value
-where
-    T::Offset: Display,
-{
-    let mut indexmap = IndexMap::new();
-
-    if dt_format.is_empty() {
-        indexmap.insert(
-            "year".to_string(),
-            UntaggedValue::int(dt.year()).into_value(&tag),
-        );
-        indexmap.insert(
-            "month".to_string(),
-            UntaggedValue::int(dt.month()).into_value(&tag),
-        );
-        indexmap.insert(
-            "day".to_string(),
-            UntaggedValue::int(dt.day()).into_value(&tag),
-        );
-        indexmap.insert(
-            "hour".to_string(),
-            UntaggedValue::int(dt.hour()).into_value(&tag),
-        );
-        indexmap.insert(
-            "minute".to_string(),
-            UntaggedValue::int(dt.minute()).into_value(&tag),
-        );
-        indexmap.insert(
-            "second".to_string(),
-            UntaggedValue::int(dt.second()).into_value(&tag),
-        );
-
-        let tz = dt.offset();
-        indexmap.insert(
-            "timezone".to_string(),
-            UntaggedValue::string(format!("{}", tz)).into_value(&tag),
-        );
-    } else {
-        let result = dt.format(&dt_format);
-        indexmap.insert(
-            "formatted".to_string(),
-            UntaggedValue::string(format!("{}", result)).into_value(&tag),
-        );
-    }
-
-    UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)
-}
-
-pub async fn date(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
-    let tag = args.call_info.name_tag.clone();
-    let raw = args.has("raw");
-
-    let dt_fmt = if args.has("format") {
-        if let Some(dt_fmt) = args.get("format") {
-            dt_fmt.convert_to_string()
-        } else {
-            "".to_string()
-        }
-    } else {
-        "".to_string()
-    };
-
-    let value = if args.has("utc") {
-        let utc: DateTime<Utc> = Utc::now();
-        if raw {
-            UntaggedValue::string(date_to_value_raw(utc, dt_fmt)).into_untagged_value()
-        } else {
-            date_to_value(utc, tag, dt_fmt)
-        }
-    } else {
-        let local: DateTime<Local> = Local::now();
-        if raw {
-            UntaggedValue::string(date_to_value_raw(local, dt_fmt)).into_untagged_value()
-        } else {
-            date_to_value(local, tag, dt_fmt)
-        }
-    };
-
-    Ok(OutputStream::one(value))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Date;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Date {})
-    }
-}

crates/nu-cli/src/commands/date/command.rs

@@ -0,0 +1,41 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "date"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date")
+    }
+
+    fn usage(&self) -> &str {
+        "Apply date function"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(ReturnSuccess::value(
+            UntaggedValue::string(crate::commands::help::get_help(&Command, &args.scope))
+                .into_value(Tag::unknown()),
+        )))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Command;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Command {})?)
+    }
+}

crates/nu-cli/src/commands/date/format.rs

@@ -0,0 +1,109 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use std::fmt::{self, write};
+
+pub struct Date;
+
+#[derive(Deserialize)]
+pub struct FormatArgs {
+    format: Tagged<String>,
+    table: bool,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date format"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date format")
+            .required("format", SyntaxShape::String, "strftime format")
+            .switch("table", "print date in a table", Some('t'))
+    }
+
+    fn usage(&self) -> &str {
+        "Format a given date using the given format string."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        format(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Format the current date",
+                example: "date now | date format '%Y.%m.%d_%H %M %S,%z'",
+                result: None,
+            },
+            Example {
+                description: "Format the current date and print in a table",
+                example: "date now | date format -t '%Y-%m-%d_%H:%M:%S %z'",
+                result: None,
+            },
+        ]
+    }
+}
+
+pub async fn format(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (FormatArgs { format, table }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => {
+                let mut output = String::new();
+                if let Err(fmt::Error) =
+                    write(&mut output, format_args!("{}", dt.format(&format.item)))
+                {
+                    Err(ShellError::labeled_error(
+                        "The date format is invalid",
+                        "invalid strftime format",
+                        &format.tag,
+                    ))
+                } else {
+                    let value = if table {
+                        let mut indexmap = IndexMap::new();
+                        indexmap.insert(
+                            "formatted".to_string(),
+                            UntaggedValue::string(&output).into_value(&tag),
+                        );
+
+                        UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag)
+                    } else {
+                        UntaggedValue::string(&output).into_value(&tag)
+                    };
+
+                    ReturnSuccess::value(value)
+                }
+            }
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/list_timezone.rs

@@ -0,0 +1,75 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use chrono_tz::TZ_VARIANTS;
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, ReturnSuccess, Signature, UntaggedValue};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date list-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date list-timezone")
+    }
+
+    fn usage(&self) -> &str {
+        "List supported time zones."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        list_timezone(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "List all supported time zones",
+                example: "date list-timezone",
+                result: None,
+            },
+            Example {
+                description: "List all supported European time zones",
+                example: "date list-timezone | where timezone =~ Europe",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn list_timezone(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let list = TZ_VARIANTS.iter().map(move |tz| {
+        let mut entries = IndexMap::new();
+
+        entries.insert(
+            "timezone".to_string(),
+            UntaggedValue::string(tz.name()).into_value(&tag),
+        );
+
+        Ok(ReturnSuccess::Value(
+            UntaggedValue::Row(Dictionary { entries }).into_value(&tag),
+        ))
+    });
+
+    Ok(futures::stream::iter(list).to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/mod.rs

@@ -0,0 +1,15 @@
+pub mod command;
+pub mod format;
+pub mod list_timezone;
+pub mod now;
+pub mod to_table;
+pub mod to_timezone;
+
+mod parser;
+
+pub use command::Command as Date;
+pub use format::Date as DateFormat;
+pub use list_timezone::Date as DateListTimeZone;
+pub use now::Date as DateNow;
+pub use to_table::Date as DateToTable;
+pub use to_timezone::Date as DateToTimeZone;

crates/nu-cli/src/commands/date/now.rs

@@ -0,0 +1,50 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use chrono::{DateTime, Local};
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date now"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date now")
+    }
+
+    fn usage(&self) -> &str {
+        "Get the current date."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        now(args).await
+    }
+}
+
+pub async fn now(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let now: DateTime<Local> = Local::now();
+
+    let value = UntaggedValue::date(now.with_timezone(now.offset())).into_value(&tag);
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/parser.rs

@@ -0,0 +1,107 @@
+// Modified from chrono::format::scan
+
+use chrono::{DateTime, FixedOffset, Local, Offset, TimeZone};
+use chrono_tz::Tz;
+use titlecase::titlecase;
+
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub enum ParseErrorKind {
+    /// Given field is out of permitted range.
+    OutOfRange,
+
+    /// The input string has some invalid character sequence for given formatting items.
+    Invalid,
+
+    /// The input string has been prematurely ended.
+    TooShort,
+}
+
+pub fn datetime_in_timezone(
+    dt: &DateTime<FixedOffset>,
+    s: &str,
+) -> Result<DateTime<FixedOffset>, ParseErrorKind> {
+    match timezone_offset_internal(s, true, true) {
+        Ok(offset) => match FixedOffset::east_opt(offset) {
+            Some(offset) => Ok(dt.with_timezone(&offset)),
+            None => Err(ParseErrorKind::OutOfRange),
+        },
+        Err(ParseErrorKind::Invalid) => {
+            if s.to_lowercase() == "local" {
+                Ok(dt.with_timezone(Local::now().offset()))
+            } else {
+                let tz: Tz = parse_timezone_internal(s)?;
+                let offset = tz.offset_from_utc_datetime(&dt.naive_utc()).fix();
+                Ok(dt.with_timezone(&offset))
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn parse_timezone_internal(s: &str) -> Result<Tz, ParseErrorKind> {
+    if let Ok(tz) = s.parse() {
+        Ok(tz)
+    } else if let Ok(tz) = titlecase(s).parse() {
+        Ok(tz)
+    } else if let Ok(tz) = s.to_uppercase().parse() {
+        Ok(tz)
+    } else {
+        Err(ParseErrorKind::Invalid)
+    }
+}
+
+fn timezone_offset_internal(
+    mut s: &str,
+    consume_colon: bool,
+    allow_missing_minutes: bool,
+) -> Result<i32, ParseErrorKind> {
+    fn digits(s: &str) -> Result<(u8, u8), ParseErrorKind> {
+        let b = s.as_bytes();
+        if b.len() < 2 {
+            Err(ParseErrorKind::TooShort)
+        } else {
+            Ok((b[0], b[1]))
+        }
+    }
+    let negative = match s.as_bytes().first() {
+        Some(&b'+') => false,
+        Some(&b'-') => true,
+        Some(_) => return Err(ParseErrorKind::Invalid),
+        None => return Err(ParseErrorKind::TooShort),
+    };
+    s = &s[1..];
+
+    // hours (00--99)
+    let hours = match digits(s)? {
+        (h1 @ b'0'..=b'9', h2 @ b'0'..=b'9') => i32::from((h1 - b'0') * 10 + (h2 - b'0')),
+        _ => return Err(ParseErrorKind::Invalid),
+    };
+    s = &s[2..];
+
+    // colons (and possibly other separators)
+    if consume_colon {
+        s = s.trim_start_matches(|c: char| c == ':' || c.is_whitespace());
+    }
+
+    // minutes (00--59)
+    // if the next two items are digits then we have to add minutes
+    let minutes = if let Ok(ds) = digits(s) {
+        match ds {
+            (m1 @ b'0'..=b'5', m2 @ b'0'..=b'9') => i32::from((m1 - b'0') * 10 + (m2 - b'0')),
+            (b'6'..=b'9', b'0'..=b'9') => return Err(ParseErrorKind::OutOfRange),
+            _ => return Err(ParseErrorKind::Invalid),
+        }
+    } else if allow_missing_minutes {
+        0
+    } else {
+        return Err(ParseErrorKind::TooShort);
+    };
+    match s.len() {
+        len if len >= 2 => &s[2..],
+        len if len == 0 => s,
+        _ => return Err(ParseErrorKind::TooShort),
+    };
+
+    let seconds = hours * 3600 + minutes * 60;
+    Ok(if negative { -seconds } else { seconds })
+}

crates/nu-cli/src/commands/date/to_table.rs

@@ -0,0 +1,105 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use chrono::{Datelike, Timelike};
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{Dictionary, Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date to-table"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date to-table")
+    }
+
+    fn usage(&self) -> &str {
+        "Print the date in a structured table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        to_table(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Print the current date in a table",
+            example: "date now | date to-table",
+            result: None,
+        }]
+    }
+}
+
+async fn to_table(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+    let input = args.input;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => {
+                let mut indexmap = IndexMap::new();
+
+                indexmap.insert(
+                    "year".to_string(),
+                    UntaggedValue::int(dt.year()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "month".to_string(),
+                    UntaggedValue::int(dt.month()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "day".to_string(),
+                    UntaggedValue::int(dt.day()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "hour".to_string(),
+                    UntaggedValue::int(dt.hour()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "minute".to_string(),
+                    UntaggedValue::int(dt.minute()).into_value(&tag),
+                );
+                indexmap.insert(
+                    "second".to_string(),
+                    UntaggedValue::int(dt.second()).into_value(&tag),
+                );
+
+                let tz = dt.offset();
+                indexmap.insert(
+                    "timezone".to_string(),
+                    UntaggedValue::string(format!("{}", tz)).into_value(&tag),
+                );
+
+                let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);
+
+                ReturnSuccess::value(value)
+            }
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/to_timezone.rs

@@ -0,0 +1,110 @@
+use crate::commands::date::parser::{datetime_in_timezone, ParseErrorKind};
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_source::Tagged;
+
+pub struct Date;
+
+#[derive(Deserialize)]
+struct DateToTimeZoneArgs {
+    timezone: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date to-timezone"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date to-timezone").required(
+            "time zone",
+            SyntaxShape::String,
+            "time zone description",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert a date to a given time zone.
+        
+Use `date list-timezone` to list all supported time zones.
+        "
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        to_timezone(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get the current date in UTC+05:00",
+                example: "date now | date to-timezone +0500",
+                result: None,
+            },
+            Example {
+                description: "Get the current local date",
+                example: "date now | date to-timezone local",
+                result: None,
+            },
+            Example {
+                description: "Get the current date in Hawaii",
+                example: "date now | date to-timezone US/Hawaii",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn to_timezone(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (DateToTimeZoneArgs { timezone }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |value| match value {
+            Value {
+                value: UntaggedValue::Primitive(Primitive::Date(dt)),
+                ..
+            } => match datetime_in_timezone(&dt, &timezone.item) {
+                Ok(dt) => {
+                    let value = UntaggedValue::date(dt).into_value(&tag);
+
+                    ReturnSuccess::value(value)
+                }
+                Err(e) => Err(ShellError::labeled_error(
+                    error_message(e),
+                    "invalid time zone",
+                    &timezone.tag,
+                )),
+            },
+            _ => Err(ShellError::labeled_error(
+                "Expected a date from pipeline",
+                "requires date input",
+                &tag,
+            )),
+        })
+        .to_output_stream())
+}
+
+fn error_message(err: ParseErrorKind) -> &'static str {
+    match err {
+        ParseErrorKind::Invalid => "The time zone description is invalid",
+        ParseErrorKind::OutOfRange => "The time zone offset is out of range",
+        ParseErrorKind::TooShort => "The format of the time zone is invalid",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/date/utc.rs

@@ -0,0 +1,55 @@
+use crate::prelude::*;
+use chrono::{DateTime, Utc};
+use nu_errors::ShellError;
+
+use crate::commands::date::utils::date_to_value;
+use crate::commands::WholeStreamCommand;
+use nu_protocol::Signature;
+
+pub struct Date;
+
+#[async_trait]
+impl WholeStreamCommand for Date {
+    fn name(&self) -> &str {
+        "date utc"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("date utc")
+    }
+
+    fn usage(&self) -> &str {
+        "return the current date in utc."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        utc(args).await
+    }
+}
+
+pub async fn utc(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
+    let tag = args.call_info.name_tag.clone();
+
+    let no_fmt = "".to_string();
+
+    let value = {
+        let local: DateTime<Utc> = Utc::now();
+        date_to_value(local, tag, no_fmt)
+    };
+
+    Ok(OutputStream::one(value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Date;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(Date {})?)
+    }
+}

crates/nu-cli/src/commands/debug.rs

@@ -24,21 +24,13 @@ impl WholeStreamCommand for Debug {
         "Print the Rust debug representation of the values"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        debug_value(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        debug_value(args).await
     }
 }
 
-async fn debug_value(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (DebugArgs { raw }, input) = args.process(&registry).await?;
+async fn debug_value(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (DebugArgs { raw }, input) = args.process().await?;
     Ok(input
         .map(move |v| {
             if raw {
@@ -55,11 +47,12 @@ async fn debug_value(
 #[cfg(test)]
 mod tests {
     use super::Debug;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Debug {})
+        Ok(test_examples(Debug {})?)
     }
 }

crates/nu-cli/src/commands/def.rs

@@ -0,0 +1,48 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+
+use nu_errors::ShellError;
+use nu_protocol::{hir::CapturedBlock, Signature, SyntaxShape, Value};
+use nu_source::Tagged;
+
+pub struct Def;
+
+#[derive(Deserialize)]
+pub struct DefArgs {
+    pub name: Tagged<String>,
+    pub args: Tagged<Vec<Value>>,
+    pub block: CapturedBlock,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Def {
+    fn name(&self) -> &str {
+        "def"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("def")
+            .required("name", SyntaxShape::String, "the name of the command")
+            .required(
+                "params",
+                SyntaxShape::Table,
+                "the parameters of the command",
+            )
+            .required("block", SyntaxShape::Block, "the body of the command")
+    }
+
+    fn usage(&self) -> &str {
+        "Create a command and set it to a definition."
+    }
+
+    async fn run(&self, _args: CommandArgs) -> Result<OutputStream, ShellError> {
+        // Currently, we don't do anything here because we should have already
+        // installed the definition as we entered the scope
+        // We just create a command so that we can get proper coloring
+        Ok(OutputStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![]
+    }
+}

crates/nu-cli/src/commands/default.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
@@ -34,39 +33,31 @@ impl WholeStreamCommand for Default {
         "Sets a default row's column if missing."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        default(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        default(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Give a default 'target' to all file entries",
-            example: "ls -af | default target 'nothing'",
+            example: "ls -la | default target 'nothing'",
             result: None,
         }]
     }
 }
 
-async fn default(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (DefaultArgs { column, value }, input) = args.process(&registry).await?;
+async fn default(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (DefaultArgs { column, value }, input) = args.process().await?;
 
     Ok(input
         .map(move |item| {
-            let should_add = match item {
+            let should_add = matches!(
+                item,
                 Value {
                     value: UntaggedValue::Row(ref r),
                     ..
-                } => r.get_data(&column.item).borrow().is_none(),
-                _ => false,
-            };
+                } if r.get_data(&column.item).borrow().is_none()
+            );
 
             if should_add {
                 match item.insert_data_at_path(&column.item, value.clone()) {
@@ -83,11 +74,12 @@ async fn default(
 #[cfg(test)]
 mod tests {
     use super::Default;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Default {})
+        Ok(test_examples(Default {})?)
     }
 }

crates/nu-cli/src/commands/default_context.rs

@@ -0,0 +1,248 @@
+use crate::prelude::*;
+use std::error::Error;
+
+pub fn create_default_context(interactive: bool) -> Result<EvaluationContext, Box<dyn Error>> {
+    let context = EvaluationContext::basic()?;
+
+    {
+        use crate::commands::*;
+
+        context.add_commands(vec![
+            // Fundamentals
+            whole_stream_command(NuPlugin),
+            whole_stream_command(Let),
+            whole_stream_command(LetEnv),
+            whole_stream_command(Def),
+            whole_stream_command(Source),
+            // System/file operations
+            whole_stream_command(Exec),
+            whole_stream_command(Pwd),
+            whole_stream_command(Ls),
+            whole_stream_command(Du),
+            whole_stream_command(Cd),
+            whole_stream_command(Remove),
+            whole_stream_command(Open),
+            whole_stream_command(Config),
+            whole_stream_command(ConfigGet),
+            whole_stream_command(ConfigSet),
+            whole_stream_command(ConfigSetInto),
+            whole_stream_command(ConfigClear),
+            whole_stream_command(ConfigLoad),
+            whole_stream_command(ConfigRemove),
+            whole_stream_command(ConfigPath),
+            whole_stream_command(Help),
+            whole_stream_command(History),
+            whole_stream_command(Save),
+            whole_stream_command(Touch),
+            whole_stream_command(Cpy),
+            whole_stream_command(Date),
+            whole_stream_command(DateListTimeZone),
+            whole_stream_command(DateNow),
+            whole_stream_command(DateToTable),
+            whole_stream_command(DateToTimeZone),
+            whole_stream_command(DateFormat),
+            whole_stream_command(Cal),
+            whole_stream_command(Mkdir),
+            whole_stream_command(Mv),
+            whole_stream_command(Kill),
+            whole_stream_command(Version),
+            whole_stream_command(Clear),
+            whole_stream_command(Describe),
+            whole_stream_command(Which),
+            whole_stream_command(Debug),
+            whole_stream_command(WithEnv),
+            whole_stream_command(Do),
+            whole_stream_command(Sleep),
+            // Statistics
+            whole_stream_command(Size),
+            whole_stream_command(Count),
+            whole_stream_command(Benchmark),
+            // Metadata
+            whole_stream_command(Tags),
+            // Shells
+            whole_stream_command(Next),
+            whole_stream_command(Previous),
+            whole_stream_command(Shells),
+            whole_stream_command(Enter),
+            whole_stream_command(Exit),
+            // Viz
+            whole_stream_command(Chart),
+            // Viewers
+            whole_stream_command(Autoview),
+            whole_stream_command(Table),
+            // Text manipulation
+            whole_stream_command(Hash),
+            whole_stream_command(HashBase64),
+            whole_stream_command(Split),
+            whole_stream_command(SplitColumn),
+            whole_stream_command(SplitRow),
+            whole_stream_command(SplitChars),
+            whole_stream_command(Lines),
+            whole_stream_command(Echo),
+            whole_stream_command(Parse),
+            whole_stream_command(Str),
+            whole_stream_command(StrToDecimal),
+            whole_stream_command(StrToInteger),
+            whole_stream_command(StrDowncase),
+            whole_stream_command(StrUpcase),
+            whole_stream_command(StrCapitalize),
+            whole_stream_command(StrFindReplace),
+            whole_stream_command(StrFrom),
+            whole_stream_command(StrSubstring),
+            whole_stream_command(StrSet),
+            whole_stream_command(StrToDatetime),
+            whole_stream_command(StrContains),
+            whole_stream_command(StrIndexOf),
+            whole_stream_command(StrTrim),
+            whole_stream_command(StrTrimLeft),
+            whole_stream_command(StrTrimRight),
+            whole_stream_command(StrStartsWith),
+            whole_stream_command(StrEndsWith),
+            whole_stream_command(StrCollect),
+            whole_stream_command(StrLength),
+            whole_stream_command(StrLPad),
+            whole_stream_command(StrReverse),
+            whole_stream_command(StrRPad),
+            whole_stream_command(StrCamelCase),
+            whole_stream_command(StrPascalCase),
+            whole_stream_command(StrKebabCase),
+            whole_stream_command(StrSnakeCase),
+            whole_stream_command(StrScreamingSnakeCase),
+            whole_stream_command(BuildString),
+            whole_stream_command(Ansi),
+            whole_stream_command(Char),
+            // Column manipulation
+            whole_stream_command(Move),
+            whole_stream_command(Reject),
+            whole_stream_command(Select),
+            whole_stream_command(Get),
+            whole_stream_command(Update),
+            whole_stream_command(Insert),
+            whole_stream_command(IntoInt),
+            whole_stream_command(SplitBy),
+            // Row manipulation
+            whole_stream_command(Reverse),
+            whole_stream_command(Append),
+            whole_stream_command(Prepend),
+            whole_stream_command(SortBy),
+            whole_stream_command(GroupBy),
+            whole_stream_command(GroupByDate),
+            whole_stream_command(First),
+            whole_stream_command(Last),
+            whole_stream_command(Every),
+            whole_stream_command(Nth),
+            whole_stream_command(Drop),
+            whole_stream_command(Format),
+            whole_stream_command(FileSize),
+            whole_stream_command(Where),
+            whole_stream_command(If),
+            whole_stream_command(Compact),
+            whole_stream_command(Default),
+            whole_stream_command(Skip),
+            whole_stream_command(SkipUntil),
+            whole_stream_command(SkipWhile),
+            whole_stream_command(Keep),
+            whole_stream_command(KeepUntil),
+            whole_stream_command(KeepWhile),
+            whole_stream_command(Range),
+            whole_stream_command(Rename),
+            whole_stream_command(Uniq),
+            whole_stream_command(Each),
+            whole_stream_command(EachGroup),
+            whole_stream_command(EachWindow),
+            whole_stream_command(Empty),
+            // Table manipulation
+            whole_stream_command(Flatten),
+            whole_stream_command(Move),
+            whole_stream_command(Merge),
+            whole_stream_command(Shuffle),
+            whole_stream_command(Wrap),
+            whole_stream_command(Pivot),
+            whole_stream_command(Headers),
+            whole_stream_command(Reduce),
+            // Data processing
+            whole_stream_command(Histogram),
+            whole_stream_command(Autoenv),
+            whole_stream_command(AutoenvTrust),
+            whole_stream_command(AutoenvUnTrust),
+            whole_stream_command(Math),
+            whole_stream_command(MathAbs),
+            whole_stream_command(MathAverage),
+            whole_stream_command(MathEval),
+            whole_stream_command(MathMedian),
+            whole_stream_command(MathMinimum),
+            whole_stream_command(MathMode),
+            whole_stream_command(MathMaximum),
+            whole_stream_command(MathStddev),
+            whole_stream_command(MathSummation),
+            whole_stream_command(MathVariance),
+            whole_stream_command(MathProduct),
+            whole_stream_command(MathRound),
+            whole_stream_command(MathFloor),
+            whole_stream_command(MathCeil),
+            // File format output
+            whole_stream_command(To),
+            whole_stream_command(ToCSV),
+            whole_stream_command(ToHTML),
+            whole_stream_command(ToJSON),
+            whole_stream_command(ToMarkdown),
+            whole_stream_command(ToTOML),
+            whole_stream_command(ToTSV),
+            whole_stream_command(ToURL),
+            whole_stream_command(ToYAML),
+            whole_stream_command(ToXML),
+            // File format input
+            whole_stream_command(From),
+            whole_stream_command(FromCSV),
+            whole_stream_command(FromEML),
+            whole_stream_command(FromTSV),
+            whole_stream_command(FromSSV),
+            whole_stream_command(FromINI),
+            whole_stream_command(FromJSON),
+            whole_stream_command(FromODS),
+            whole_stream_command(FromTOML),
+            whole_stream_command(FromURL),
+            whole_stream_command(FromXLSX),
+            whole_stream_command(FromXML),
+            whole_stream_command(FromYAML),
+            whole_stream_command(FromYML),
+            whole_stream_command(FromIcs),
+            whole_stream_command(FromVcf),
+            // "Private" commands (not intended to be accessed directly)
+            whole_stream_command(RunExternalCommand { interactive }),
+            // Random value generation
+            whole_stream_command(Random),
+            whole_stream_command(RandomBool),
+            whole_stream_command(RandomDice),
+            #[cfg(feature = "uuid_crate")]
+            whole_stream_command(RandomUUID),
+            whole_stream_command(RandomInteger),
+            whole_stream_command(RandomDecimal),
+            whole_stream_command(RandomChars),
+            // Path
+            whole_stream_command(PathBasename),
+            whole_stream_command(PathCommand),
+            whole_stream_command(PathDirname),
+            whole_stream_command(PathExists),
+            whole_stream_command(PathExpand),
+            whole_stream_command(PathExtension),
+            whole_stream_command(PathFilestem),
+            whole_stream_command(PathType),
+            // Url
+            whole_stream_command(UrlCommand),
+            whole_stream_command(UrlScheme),
+            whole_stream_command(UrlPath),
+            whole_stream_command(UrlHost),
+            whole_stream_command(UrlQuery),
+            whole_stream_command(Seq),
+            whole_stream_command(SeqDates),
+        ]);
+
+        #[cfg(feature = "clipboard-cli")]
+        {
+            context.add_commands(vec![whole_stream_command(crate::commands::clip::Clip)]);
+        }
+    }
+
+    Ok(context)
+}

crates/nu-cli/src/commands/describe.rs

@@ -4,13 +4,13 @@ use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
 
-pub struct What;
+pub struct Describe;
 
 #[derive(Deserialize)]
-pub struct WhatArgs {}
+pub struct DescribeArgs {}
 
 #[async_trait]
-impl WholeStreamCommand for What {
+impl WholeStreamCommand for Describe {
     fn name(&self) -> &str {
         "describe"
     }
@@ -23,19 +23,12 @@ impl WholeStreamCommand for What {
         "Describes the objects in the stream."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        what(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        describe(args).await
     }
 }
 
-pub async fn what(
-    args: CommandArgs,
-    _registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+pub async fn describe(args: CommandArgs) -> Result<OutputStream, ShellError> {
     Ok(args
         .input
         .map(|row| {
@@ -49,12 +42,13 @@ pub async fn what(
 
 #[cfg(test)]
 mod tests {
-    use super::What;
+    use super::Describe;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(What {})
+        Ok(test_examples(Describe {})?)
     }
 }

crates/nu-cli/src/commands/do_.rs

@@ -2,13 +2,13 @@ use crate::commands::classified::block::run_block;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{hir::Block, ReturnSuccess, Signature, SyntaxShape, Value};
+use nu_protocol::{hir::CapturedBlock, hir::ExternalRedirection, Signature, SyntaxShape, Value};
 
 pub struct Do;
 
 #[derive(Deserialize, Debug)]
 struct DoArgs {
-    block: Block,
+    block: CapturedBlock,
     ignore_errors: bool,
 }
 
@@ -32,12 +32,8 @@ impl WholeStreamCommand for Do {
         "Runs a block, optionally ignoring errors"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        do_(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        do_(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -50,48 +46,58 @@ impl WholeStreamCommand for Do {
             Example {
                 description: "Run the block and ignore errors",
                 example: r#"do -i { thisisnotarealcommand }"#,
-                result: Some(vec![Value::nothing()]),
+                result: Some(vec![]),
             },
         ]
     }
 }
 
-async fn do_(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let is_last = raw_args.call_info.args.is_last;
+async fn do_(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let external_redirection = raw_args.call_info.args.external_redirection;
 
-    let mut context = Context::from_raw(&raw_args, &registry);
-    let scope = raw_args.call_info.scope.clone();
+    let context = EvaluationContext::from_raw(&raw_args);
     let (
         DoArgs {
             ignore_errors,
             mut block,
         },
         input,
-    ) = raw_args.process(&registry).await?;
-    block.set_is_last(is_last);
+    ) = raw_args.process().await?;
 
-    let result = run_block(
-        &block,
-        &mut context,
-        input,
-        &scope.it,
-        &scope.vars,
-        &scope.env,
-    )
-    .await;
+    let block_redirection = match external_redirection {
+        ExternalRedirection::None => {
+            if ignore_errors {
+                ExternalRedirection::Stderr
+            } else {
+                ExternalRedirection::None
+            }
+        }
+        ExternalRedirection::Stdout => {
+            if ignore_errors {
+                ExternalRedirection::StdoutAndStderr
+            } else {
+                ExternalRedirection::Stdout
+            }
+        }
+        x => x,
+    };
+
+    block.block.set_redirect(block_redirection);
+    context.scope.enter_scope();
+    let result = run_block(&block.block, &context, input).await;
+    context.scope.exit_scope();
 
     if ignore_errors {
+        // To properly ignore errors we need to redirect stderr, consume it, and remove
+        // any errors we see in the process.
+
         match result {
             Ok(mut stream) => {
                 let output = stream.drain_vec().await;
                 context.clear_errors();
                 Ok(futures::stream::iter(output).to_output_stream())
             }
-            Err(_) => Ok(OutputStream::one(ReturnSuccess::value(Value::nothing()))),
+            Err(_) => Ok(OutputStream::empty()),
         }
     } else {
         result.map(|x| x.to_output_stream())
@@ -101,11 +107,12 @@ async fn do_(
 #[cfg(test)]
 mod tests {
     use super::Do;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Do {})
+        Ok(test_examples(Do {})?)
     }
 }

crates/nu-cli/src/commands/drop.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
@@ -22,20 +21,16 @@ impl WholeStreamCommand for Drop {
         Signature::build("drop").optional(
             "rows",
             SyntaxShape::Number,
-            "starting from the back, the number of rows to drop",
+            "starting from the back, the number of rows to remove",
         )
     }
 
     fn usage(&self) -> &str {
-        "Drop the last number of rows."
+        "Remove the last number of rows. If you want to remove columns, try 'reject'."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        drop(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        drop(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -57,8 +52,8 @@ impl WholeStreamCommand for Drop {
     }
 }
 
-async fn drop(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let (DropArgs { rows }, input) = args.process(&registry).await?;
+async fn drop(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (DropArgs { rows }, input) = args.process().await?;
     let v: Vec<_> = input.into_vec().await;
 
     let rows_to_drop = if let Some(quantity) = rows {
@@ -85,11 +80,12 @@ async fn drop(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
 #[cfg(test)]
 mod tests {
     use super::Drop;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Drop {})
+        Ok(test_examples(Drop {})?)
     }
 }

crates/nu-cli/src/commands/du.rs

@@ -73,12 +73,8 @@ impl WholeStreamCommand for Du {
         "Find disk usage sizes of specified items"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        du(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        du(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -90,13 +86,12 @@ impl WholeStreamCommand for Du {
     }
 }
 
-async fn du(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
+async fn du(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
     let ctrl_c = args.ctrl_c.clone();
     let ctrl_c_copy = ctrl_c.clone();
 
-    let (args, _): (DuArgs, _) = args.process(&registry).await?;
+    let (args, _): (DuArgs, _) = args.process().await?;
     let exclude = args.exclude.map_or(Ok(None), move |x| {
         Pattern::new(&x.item)
             .map(Option::Some)
@@ -427,11 +422,12 @@ impl From<FileInfo> for Value {
 #[cfg(test)]
 mod tests {
     use super::Du;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Du {})
+        Ok(test_examples(Du {})?)
     }
 }

crates/nu-cli/src/commands/each/command.rs

@@ -1,13 +1,11 @@
 use crate::commands::classified::block::run_block;
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 
 use futures::stream::once;
 use nu_errors::ShellError;
 use nu_protocol::{
-    hir::Block, hir::Expression, hir::SpannedExpression, hir::Synthetic, Scope, Signature,
-    SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+    hir::CapturedBlock, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
 };
 use nu_source::Tagged;
 
@@ -15,7 +13,7 @@ pub struct Each;
 
 #[derive(Deserialize)]
 pub struct EachArgs {
-    block: Block,
+    block: CapturedBlock,
     numbered: Tagged<bool>,
 }
 
@@ -39,12 +37,8 @@ impl WholeStreamCommand for Each {
         "Run a block on each row of the table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        each(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        each(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -73,64 +67,65 @@ impl WholeStreamCommand for Each {
     }
 }
 
-fn is_expanded_it_usage(head: &SpannedExpression) -> bool {
-    matches!(&*head, SpannedExpression {
-        expr: Expression::Synthetic(Synthetic::String(s)),
-        ..
-    } if s == "expanded-each")
-}
-
 pub async fn process_row(
-    block: Arc<Block>,
-    scope: Arc<Scope>,
-    head: Arc<Box<SpannedExpression>>,
-    mut context: Arc<Context>,
+    captured_block: Arc<Box<CapturedBlock>>,
+    context: Arc<EvaluationContext>,
     input: Value,
 ) -> Result<OutputStream, ShellError> {
     let input_clone = input.clone();
-    let input_stream = if is_expanded_it_usage(&head) {
+    // When we process a row, we need to know whether the block wants to have the contents of the row as
+    // a parameter to the block (so it gets assigned to a variable that can be used inside the block) or
+    // if it wants the contents as as an input stream
+
+    let input_stream = if !captured_block.block.params.positional.is_empty() {
         InputStream::empty()
     } else {
         once(async { Ok(input_clone) }).to_input_stream()
     };
-    Ok(run_block(
-        &block,
-        Arc::make_mut(&mut context),
-        input_stream,
-        &input,
-        &scope.vars,
-        &scope.env,
-    )
-    .await?
-    .to_output_stream())
+
+    context.scope.enter_scope();
+    context.scope.add_vars(&captured_block.captured.entries);
+
+    if !captured_block.block.params.positional.is_empty() {
+        // FIXME: add check for more than parameter, once that's supported
+        context
+            .scope
+            .add_var(captured_block.block.params.positional[0].0.name(), input);
+    } else {
+        context.scope.add_var("$it", input);
+    }
+
+    let result = run_block(&captured_block.block, &*context, input_stream).await;
+
+    context.scope.exit_scope();
+
+    Ok(result?.to_output_stream())
 }
 
-async fn each(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let head = Arc::new(raw_args.call_info.args.head.clone());
-    let scope = Arc::new(raw_args.call_info.scope.clone());
-    let context = Arc::new(Context::from_raw(&raw_args, &registry));
-    let (each_args, input): (EachArgs, _) = raw_args.process(&registry).await?;
-    let block = Arc::new(each_args.block);
+pub(crate) fn make_indexed_item(index: usize, item: Value) -> Value {
+    let mut dict = TaggedDictBuilder::new(item.tag());
+    dict.insert_untagged("index", UntaggedValue::int(index));
+    dict.insert_value("item", item);
+
+    dict.into_value()
+}
+
+async fn each(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+
+    let (each_args, input): (EachArgs, _) = raw_args.process().await?;
+    let block = Arc::new(Box::new(each_args.block));
 
     if each_args.numbered.item {
         Ok(input
             .enumerate()
             .then(move |input| {
                 let block = block.clone();
-                let scope = scope.clone();
-                let head = head.clone();
                 let context = context.clone();
-
-                let mut dict = TaggedDictBuilder::new(input.1.tag());
-                dict.insert_untagged("index", UntaggedValue::int(input.0));
-                dict.insert_value("item", input.1);
+                let row = make_indexed_item(input.0, input.1);
 
                 async {
-                    match process_row(block, scope, head, context, dict.into_value()).await {
+                    match process_row(block, context, row).await {
                         Ok(s) => s,
                         Err(e) => OutputStream::one(Err(e)),
                     }
@@ -142,12 +137,10 @@ async fn each(
         Ok(input
             .then(move |input| {
                 let block = block.clone();
-                let scope = scope.clone();
-                let head = head.clone();
                 let context = context.clone();
 
                 async {
-                    match process_row(block, scope, head, context, input).await {
+                    match process_row(block, context, input).await {
                         Ok(s) => s,
                         Err(e) => OutputStream::one(Err(e)),
                     }
@@ -161,11 +154,12 @@ async fn each(
 #[cfg(test)]
 mod tests {
     use super::Each;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Each {})
+        Ok(test_examples(Each {})?)
     }
 }

crates/nu-cli/src/commands/each/group.rs

@@ -0,0 +1,116 @@
+use crate::commands::each::process_row;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use serde::Deserialize;
+
+pub struct EachGroup;
+
+#[derive(Deserialize)]
+pub struct EachGroupArgs {
+    group_size: Tagged<usize>,
+    block: CapturedBlock,
+    //numbered: Tagged<bool>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for EachGroup {
+    fn name(&self) -> &str {
+        "each group"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each group")
+            .required("group_size", SyntaxShape::Int, "the size of each group")
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run on each group",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block on groups of `group_size` rows of a table at a time."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Echo the sum of each pair",
+            example: "echo [1 2 3 4] | each group 2 { echo $it | math sum }",
+            result: None,
+        }]
+    }
+
+    async fn run(&self, raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+        let (each_args, input): (EachGroupArgs, _) = raw_args.process().await?;
+        let block = Arc::new(Box::new(each_args.block));
+
+        Ok(input
+            .chunks(each_args.group_size.item)
+            .then(move |input| run_block_on_vec(input, block.clone(), context.clone()))
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+pub(crate) fn run_block_on_vec(
+    input: Vec<Value>,
+    block: Arc<Box<CapturedBlock>>,
+    context: Arc<EvaluationContext>,
+) -> impl Future<Output = OutputStream> {
+    let value = Value {
+        value: UntaggedValue::Table(input),
+        tag: Tag::unknown(),
+    };
+
+    async {
+        match process_row(block, context, value).await {
+            Ok(s) => {
+                // We need to handle this differently depending on whether process_row
+                // returned just 1 value or if it returned multiple as a stream.
+                let vec = s.collect::<Vec<_>>().await;
+
+                // If it returned just one value, just take that value
+                if vec.len() == 1 {
+                    return OutputStream::one(vec.into_iter().next().expect(
+                        "This should be impossible, we just checked that vec.len() == 1.",
+                    ));
+                }
+
+                // If it returned multiple values, we need to put them into a table and
+                // return that.
+                let result = vec.into_iter().collect::<Result<Vec<ReturnSuccess>, _>>();
+                let result_table = match result {
+                    Ok(t) => t,
+                    Err(e) => return OutputStream::one(Err(e)),
+                };
+
+                let table = result_table
+                    .into_iter()
+                    .filter_map(|x| x.raw_value())
+                    .collect();
+
+                OutputStream::one(Ok(ReturnSuccess::Value(UntaggedValue::Table(table).into())))
+            }
+            Err(e) => OutputStream::one(Err(e)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EachGroup;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(EachGroup {})?)
+    }
+}

crates/nu-cli/src/commands/each/mod.rs

@@ -0,0 +1,9 @@
+pub mod command;
+pub mod group;
+pub mod window;
+
+pub(crate) use command::make_indexed_item;
+pub use command::process_row;
+pub use command::Each;
+pub use group::EachGroup;
+pub use window::EachWindow;

crates/nu-cli/src/commands/each/window.rs

@@ -0,0 +1,105 @@
+use crate::commands::each::group::run_block_on_vec;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+//use itertools::Itertools;
+use nu_errors::ShellError;
+use nu_protocol::{hir::CapturedBlock, Primitive, Signature, SyntaxShape, UntaggedValue};
+use nu_source::Tagged;
+use serde::Deserialize;
+
+pub struct EachWindow;
+
+#[derive(Deserialize)]
+pub struct EachWindowArgs {
+    window_size: Tagged<usize>,
+    block: CapturedBlock,
+    stride: Option<Tagged<usize>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for EachWindow {
+    fn name(&self) -> &str {
+        "each window"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each window")
+            .required("window_size", SyntaxShape::Int, "the size of each window")
+            .named(
+                "stride",
+                SyntaxShape::Int,
+                "the number of rows to slide over between windows",
+                Some('s'),
+            )
+            .required(
+                "block",
+                SyntaxShape::Block,
+                "the block to run on each group",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Runs a block on sliding windows of `window_size` rows of a table at a time."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Echo the sum of each window",
+            example: "echo [1 2 3 4] | each window 2 { echo $it | math sum }",
+            result: None,
+        }]
+    }
+
+    async fn run(&self, raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let context = Arc::new(EvaluationContext::from_raw(&raw_args));
+        let (each_args, mut input): (EachWindowArgs, _) = raw_args.process().await?;
+        let block = Arc::new(Box::new(each_args.block));
+
+        let mut window: Vec<_> = input
+            .by_ref()
+            .take(*each_args.window_size - 1)
+            .collect::<Vec<_>>()
+            .await;
+
+        // `window` must start with dummy values, which will be removed on the first iteration
+        let stride = each_args.stride.map(|x| *x).unwrap_or(1);
+        window.insert(0, UntaggedValue::Primitive(Primitive::Nothing).into());
+
+        Ok(input
+            .enumerate()
+            .then(move |(i, input)| {
+                // This would probably be more efficient if `last` was a VecDeque
+                // But we can't have that because it needs to be put into a Table
+                window.remove(0);
+                window.push(input);
+
+                let block = block.clone();
+                let context = context.clone();
+                let local_window = window.clone();
+
+                async move {
+                    if i % stride == 0 {
+                        Some(run_block_on_vec(local_window, block, context).await)
+                    } else {
+                        None
+                    }
+                }
+            })
+            .filter_map(|x| async { x })
+            .flatten()
+            .to_output_stream())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::EachWindow;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(EachWindow {})?)
+    }
+}

crates/nu-cli/src/commands/echo.rs

@@ -8,7 +8,7 @@ use nu_protocol::{
 
 pub struct Echo;
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
 pub struct EchoArgs {
     pub rest: Vec<Value>,
 }
@@ -27,12 +27,8 @@ impl WholeStreamCommand for Echo {
         "Echo the arguments back to the user."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        echo(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        echo(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -51,9 +47,8 @@ impl WholeStreamCommand for Echo {
     }
 }
 
-async fn echo(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (args, _): (EchoArgs, _) = args.process(&registry).await?;
+async fn echo(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (args, _): (EchoArgs, _) = args.process().await?;
 
     let stream = args.rest.into_iter().map(|i| match i.as_string() {
         Ok(s) => OutputStream::one(Ok(ReturnSuccess::Value(
@@ -69,7 +64,7 @@ async fn echo(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStr
                 value: UntaggedValue::Primitive(Primitive::Range(range)),
                 tag,
             } => futures::stream::iter(RangeIterator::new(*range, tag)).to_output_stream(),
-            _ => OutputStream::one(Ok(ReturnSuccess::Value(i.clone()))),
+            x => OutputStream::one(Ok(ReturnSuccess::Value(x))),
         },
     });
 
@@ -81,17 +76,20 @@ struct RangeIterator {
     end: Primitive,
     tag: Tag,
     is_end_inclusive: bool,
-    is_done: bool,
 }
 
 impl RangeIterator {
     pub fn new(range: Range, tag: Tag) -> RangeIterator {
+        let start = match range.from.0.item {
+            Primitive::Nothing => Primitive::Int(0.into()),
+            x => x,
+        };
+
         RangeIterator {
-            curr: range.from.0.item,
+            curr: start,
             end: range.to.0.item,
             tag,
             is_end_inclusive: matches!(range.to.1, RangeInclusion::Inclusive),
-            is_done: false,
         }
     }
 }
@@ -99,14 +97,40 @@ impl RangeIterator {
 impl Iterator for RangeIterator {
     type Item = Result<ReturnSuccess, ShellError>;
     fn next(&mut self) -> Option<Self::Item> {
-        if self.curr != self.end {
+        let ordering = if self.end == Primitive::Nothing {
+            Ordering::Less
+        } else {
+            let result =
+                nu_data::base::coerce_compare_primitive(&self.curr, &self.end).map_err(|_| {
+                    ShellError::labeled_error(
+                        "Cannot create range",
+                        "unsupported range",
+                        self.tag.span,
+                    )
+                });
+
+            if let Err(result) = result {
+                return Some(Err(result));
+            }
+
+            let result = result
+                .expect("Internal error: the error case was already protected, but that failed");
+
+            result.compare()
+        };
+
+        use std::cmp::Ordering;
+
+        if (ordering == Ordering::Less) || (self.is_end_inclusive && ordering == Ordering::Equal) {
             let output = UntaggedValue::Primitive(self.curr.clone()).into_value(self.tag.clone());
 
-            self.curr = match crate::data::value::compute_values(
+            let next_value = nu_data::value::compute_values(
                 Operator::Plus,
                 &UntaggedValue::Primitive(self.curr.clone()),
                 &UntaggedValue::int(1),
-            ) {
+            );
+
+            self.curr = match next_value {
                 Ok(result) => match result {
                     UntaggedValue::Primitive(p) => p,
                     _ => {
@@ -123,11 +147,6 @@ impl Iterator for RangeIterator {
                 }
             };
             Some(ReturnSuccess::value(output))
-        } else if self.is_end_inclusive && !self.is_done {
-            self.is_done = true;
-            Some(ReturnSuccess::value(
-                UntaggedValue::Primitive(self.curr.clone()).into_value(self.tag.clone()),
-            ))
         } else {
             // TODO: add inclusive/exclusive ranges
             None
@@ -138,11 +157,12 @@ impl Iterator for RangeIterator {
 #[cfg(test)]
 mod tests {
     use super::Echo;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Echo {})
+        Ok(test_examples(Echo {})?)
     }
 }

crates/nu-cli/src/commands/empty.rs

@@ -0,0 +1,275 @@
+use crate::commands::classified::block::run_block;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    hir::CapturedBlock, ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape,
+    UntaggedValue, Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::{as_string, ValueExt};
+
+use futures::stream::once;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Value>,
+}
+
+pub struct Command;
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "empty?"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("empty?").rest(
+            SyntaxShape::Any,
+            "the names of the columns to check emptiness. Pass an optional block to replace if empty",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Check for empty values"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        is_empty(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Check if a value is empty",
+                example: "echo '' | empty?",
+                result: Some(vec![UntaggedValue::boolean(true).into()]),
+            },
+            Example {
+                description: "more than one column",
+                example: "echo [[meal size]; [arepa small] [taco '']] | empty? meal size",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(false),
+                        })
+                        .into(),
+                        UntaggedValue::row(indexmap! {
+                                "meal".to_string() => Value::from(false),
+                                "size".to_string() => Value::from(true),
+                        })
+                        .into(),
+                    ],
+                ),
+            },Example {
+                description: "use a block if setting the empty cell contents is wanted",
+                example: "echo [[2020/04/16 2020/07/10 2020/11/16]; ['' [27] [37]]] | empty? 2020/04/16 { = [33 37] }",
+                result: Some(
+                    vec![
+                        UntaggedValue::row(indexmap! {
+                                "2020/04/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(33).into(), UntaggedValue::int(37).into()]).into(),
+                                "2020/07/10".to_string() => UntaggedValue::table(&[UntaggedValue::int(27).into()]).into(),
+                                "2020/11/16".to_string() => UntaggedValue::table(&[UntaggedValue::int(37).into()]).into(),
+                        })
+                        .into(),
+                    ],
+                ),
+            },
+        ]
+    }
+}
+
+async fn is_empty(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let name_tag = Arc::new(args.call_info.name_tag.clone());
+    let context = Arc::new(EvaluationContext::from_raw(&args));
+    let (Arguments { rest }, input) = args.process().await?;
+    let (columns, default_block): (Vec<ColumnPath>, Option<Box<CapturedBlock>>) = arguments(rest)?;
+    let default_block = Arc::new(default_block);
+
+    if input.is_empty() {
+        let stream = futures::stream::iter(vec![
+            UntaggedValue::Primitive(Primitive::Nothing).into_value(tag)
+        ]);
+
+        return Ok(InputStream::from_stream(stream)
+            .then(move |input| {
+                let tag = name_tag.clone();
+                let context = context.clone();
+                let block = default_block.clone();
+                let columns = vec![];
+
+                async {
+                    match process_row(context, input, block, columns, tag).await {
+                        Ok(s) => s,
+                        Err(e) => OutputStream::one(Err(e)),
+                    }
+                }
+            })
+            .flatten()
+            .to_output_stream());
+    }
+
+    Ok(input
+        .then(move |input| {
+            let tag = name_tag.clone();
+            let context = context.clone();
+            let block = default_block.clone();
+            let columns = columns.clone();
+
+            async {
+                match process_row(context, input, block, columns, tag).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn arguments(
+    rest: Vec<Value>,
+) -> Result<(Vec<ColumnPath>, Option<Box<CapturedBlock>>), ShellError> {
+    let mut rest = rest;
+    let mut columns = vec![];
+    let mut default = None;
+
+    let last_argument = rest.pop();
+
+    match last_argument {
+        Some(Value {
+            value: UntaggedValue::Block(call),
+            ..
+        }) => default = Some(call),
+        Some(other) => {
+            let Tagged { item: path, .. } = other.as_column_path()?;
+
+            columns = vec![path];
+        }
+        None => {}
+    };
+
+    for argument in rest {
+        let Tagged { item: path, .. } = argument.as_column_path()?;
+
+        columns.push(path);
+    }
+
+    Ok((columns, default))
+}
+
+async fn process_row(
+    context: Arc<EvaluationContext>,
+    input: Value,
+    default_block: Arc<Option<Box<CapturedBlock>>>,
+    column_paths: Vec<ColumnPath>,
+    tag: Arc<Tag>,
+) -> Result<OutputStream, ShellError> {
+    let _tag = &*tag;
+    let mut out = Arc::new(None);
+    let results = Arc::make_mut(&mut out);
+
+    if let Some(default_block) = &*default_block {
+        let for_block = input.clone();
+        let input_stream = once(async { Ok(for_block) }).to_input_stream();
+
+        context.scope.enter_scope();
+        context.scope.add_vars(&default_block.captured.entries);
+        context.scope.add_var("$it", input.clone());
+
+        let stream = run_block(&default_block.block, &*context, input_stream).await;
+        context.scope.exit_scope();
+
+        let mut stream = stream?;
+        *results = Some({
+            let values = stream.drain_vec().await;
+
+            let errors = context.get_errors();
+
+            if let Some(error) = errors.first() {
+                return Err(error.clone());
+            }
+
+            if values.len() == 1 {
+                let value = values
+                    .get(0)
+                    .ok_or_else(|| ShellError::unexpected("No value."))?;
+
+                Value {
+                    value: value.value.clone(),
+                    tag: input.tag.clone(),
+                }
+            } else if values.is_empty() {
+                UntaggedValue::nothing().into_value(&input.tag)
+            } else {
+                UntaggedValue::table(&values).into_value(&input.tag)
+            }
+        });
+    }
+
+    match input {
+        Value {
+            value: UntaggedValue::Row(ref r),
+            ref tag,
+        } => {
+            if column_paths.is_empty() {
+                Ok(OutputStream::one(ReturnSuccess::value({
+                    let is_empty = input.is_empty();
+
+                    if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            input.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    }
+                })))
+            } else {
+                let mut obj = input.clone();
+
+                for column in column_paths.clone() {
+                    let path = UntaggedValue::Primitive(Primitive::ColumnPath(column.clone()))
+                        .into_value(tag);
+                    let data = r.get_data(&as_string(&path)?).borrow().clone();
+                    let is_empty = data.is_empty();
+
+                    let default = if default_block.is_some() {
+                        if is_empty {
+                            results
+                                .clone()
+                                .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(tag))
+                        } else {
+                            data.clone()
+                        }
+                    } else {
+                        UntaggedValue::boolean(is_empty).into_value(tag)
+                    };
+
+                    if let Ok(value) =
+                        obj.swap_data_by_column_path(&column, Box::new(move |_| Ok(default)))
+                    {
+                        obj = value;
+                    }
+                }
+
+                Ok(OutputStream::one(ReturnSuccess::value(obj)))
+            }
+        }
+        other => Ok(OutputStream::one(ReturnSuccess::value({
+            if other.is_empty() {
+                results
+                    .clone()
+                    .unwrap_or_else(|| UntaggedValue::boolean(true).into_value(other.tag))
+            } else {
+                UntaggedValue::boolean(false).into_value(other.tag)
+            }
+        }))),
+    }
+}

crates/nu-cli/src/commands/enter.rs

@@ -1,8 +1,8 @@
 use crate::commands::UnevaluatedCallInfo;
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
+use nu_protocol::hir::ExternalRedirection;
 use nu_protocol::{
     CommandAction, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
 };
@@ -49,12 +49,8 @@ For a more complete list of encodings please refer to the encoding_rs
 documentation link at https://docs.rs/encoding_rs/0.8.23/encoding_rs/#statics"#
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        enter(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        enter(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -78,19 +74,15 @@ documentation link at https://docs.rs/encoding_rs/0.8.23/encoding_rs/#statics"#
     }
 }
 
-async fn enter(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let scope = raw_args.call_info.scope.clone();
+async fn enter(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let scope = raw_args.scope.clone();
     let shell_manager = raw_args.shell_manager.clone();
     let head = raw_args.call_info.args.head.clone();
     let ctrl_c = raw_args.ctrl_c.clone();
     let current_errors = raw_args.current_errors.clone();
     let host = raw_args.host.clone();
     let tag = raw_args.call_info.name_tag.clone();
-    let (EnterArgs { location, encoding }, _) = raw_args.process(&registry).await?;
+    let (EnterArgs { location, encoding }, _) = raw_args.process().await?;
     let location_string = location.display().to_string();
     let location_clone = location_string.clone();
 
@@ -100,7 +92,7 @@ async fn enter(
         if spec.len() == 2 {
             let (_, command) = (spec[0], spec[1]);
 
-            if registry.has(command) {
+            if scope.has_command(command) {
                 return Ok(OutputStream::one(ReturnSuccess::action(
                     CommandAction::EnterHelpShell(
                         UntaggedValue::string(command).into_value(Tag::unknown()),
@@ -120,11 +112,12 @@ async fn enter(
         let cwd = shell_manager.path();
 
         let full_path = std::path::PathBuf::from(cwd);
+        let span = location.span();
 
         let (file_extension, tagged_contents) = crate::commands::open::fetch(
             &full_path,
             &PathBuf::from(location_clone),
-            tag.span,
+            span,
             encoding,
         )
         .await?;
@@ -133,7 +126,7 @@ async fn enter(
             UntaggedValue::Primitive(Primitive::String(_)) => {
                 if let Some(extension) = file_extension {
                     let command_name = format!("from {}", extension);
-                    if let Some(converter) = registry.get_command(&command_name) {
+                    if let Some(converter) = scope.get_command(&command_name) {
                         let new_args = RawCommandArgs {
                             host,
                             ctrl_c,
@@ -145,15 +138,15 @@ async fn enter(
                                     positional: None,
                                     named: None,
                                     span: Span::unknown(),
-                                    is_last: false,
+                                    external_redirection: ExternalRedirection::Stdout,
                                 },
                                 name_tag: tag.clone(),
-                                scope: scope.clone(),
                             },
+                            scope: scope.clone(),
                         };
                         let tag = tagged_contents.tag.clone();
                         let mut result = converter
-                            .run(new_args.with_input(vec![tagged_contents]), &registry)
+                            .run(new_args.with_input(vec![tagged_contents]))
                             .await?;
                         let result_vec: Vec<Result<ReturnSuccess, ShellError>> =
                             result.drain_vec().await;
@@ -190,11 +183,12 @@ async fn enter(
 #[cfg(test)]
 mod tests {
     use super::Enter;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Enter {})
+        Ok(test_examples(Enter {})?)
     }
 }

crates/nu-cli/src/commands/every.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
@@ -37,12 +36,8 @@ impl WholeStreamCommand for Every {
         "Show (or skip) every n-th row, starting from the first one."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        every(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        every(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -68,9 +63,8 @@ impl WholeStreamCommand for Every {
     }
 }
 
-async fn every(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (EveryArgs { stride, skip }, input) = args.process(&registry).await?;
+async fn every(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (EveryArgs { stride, skip }, input) = args.process().await?;
 
     let stride = stride.item;
     let skip = skip.item;
@@ -93,11 +87,12 @@ async fn every(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputSt
 #[cfg(test)]
 mod tests {
     use super::Every;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Every {})
+        Ok(test_examples(Every {})?)
     }
 }

crates/nu-cli/src/commands/exec.rs

@@ -0,0 +1,81 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+use nu_source::Tagged;
+use std::path::PathBuf;
+
+pub struct Exec;
+
+#[derive(Deserialize)]
+pub struct ExecArgs {
+    pub command: Tagged<PathBuf>,
+    pub rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Exec {
+    fn name(&self) -> &str {
+        "exec"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("exec")
+            .required("command", SyntaxShape::Path, "the command to execute")
+            .rest(SyntaxShape::Pattern, "any additional arguments for command")
+    }
+
+    fn usage(&self) -> &str {
+        "Execute command"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        exec(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Execute 'ps aux'",
+                example: "exec ps aux",
+                result: None,
+            },
+            Example {
+                description: "Execute 'nautilus'",
+                example: "exec nautilus",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(unix)]
+async fn exec(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    use std::os::unix::process::CommandExt;
+    use std::process::Command;
+
+    let name = args.call_info.name_tag.clone();
+    let (args, _): (ExecArgs, _) = args.process().await?;
+
+    let mut command = Command::new(args.command.item);
+    for tagged_arg in args.rest {
+        command.arg(tagged_arg.item);
+    }
+
+    let err = command.exec(); // this replaces our process, should not return
+
+    Err(ShellError::labeled_error(
+        "Error on exec",
+        format!("{}", err),
+        &name,
+    ))
+}
+
+#[cfg(not(unix))]
+async fn exec(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    Err(ShellError::labeled_error(
+        "Error on exec",
+        "exec is not supported on your platform",
+        &args.call_info.name_tag,
+    ))
+}

crates/nu-cli/src/commands/exit.rs

@@ -1,5 +1,4 @@
 use crate::commands::command::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{CommandAction, ReturnSuccess, Signature};
@@ -20,12 +19,8 @@ impl WholeStreamCommand for Exit {
         "Exit the current shell (or all shells)"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        exit(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        exit(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -44,12 +39,8 @@ impl WholeStreamCommand for Exit {
     }
 }
 
-pub async fn exit(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
+pub async fn exit(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
 
     let command_action = if args.call_info.args.has("now") {
         CommandAction::Exit
@@ -63,11 +54,12 @@ pub async fn exit(
 #[cfg(test)]
 mod tests {
     use super::Exit;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Exit {})
+        Ok(test_examples(Exit {})?)
     }
 }

crates/nu-cli/src/commands/first.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::prelude::*;
 use nu_errors::ShellError;
 use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
@@ -30,12 +29,8 @@ impl WholeStreamCommand for First {
         "Show only the first number of rows."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        first(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        first(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -57,9 +52,8 @@ impl WholeStreamCommand for First {
     }
 }
 
-async fn first(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (FirstArgs { rows }, input) = args.process(&registry).await?;
+async fn first(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (FirstArgs { rows }, input) = args.process().await?;
     let rows_desired = if let Some(quantity) = rows {
         *quantity
     } else {
@@ -72,11 +66,12 @@ async fn first(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputSt
 #[cfg(test)]
 mod tests {
     use super::First;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(First {})
+        Ok(test_examples(First {})?)
     }
 }

crates/nu-cli/src/commands/flatten.rs

@@ -0,0 +1,183 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    Dictionary, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct Command;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    rest: Vec<Tagged<String>>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "flatten"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("flatten").rest(SyntaxShape::String, "optionally flatten data by column")
+    }
+
+    fn usage(&self) -> &str {
+        "Flatten the table."
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        flatten(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "flatten a table",
+                example: "echo [[N, u, s, h, e, l, l]] | flatten | first",
+                result: Some(vec![Value::from("N")]),
+            },
+            Example {
+                description: "flatten a column having a nested table",
+                example: "echo [[origin, people]; [Ecuador, $(echo [[name, meal]; ['Andres', 'arepa']])]] | flatten | get meal",
+                result: Some(vec![Value::from("arepa")]),
+            },
+            Example {
+                description: "restrict the flattening by passing column names",
+                example: "echo [[origin, crate, versions]; [World, $(echo [[name]; ['nu-cli']]), ['0.21', '0.22']]] | flatten versions | last | get versions",
+                result: Some(vec![Value::from("0.22")]),
+            }
+        ]
+    }
+}
+
+async fn flatten(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let (Arguments { rest: columns }, input) = args.process().await?;
+
+    Ok(input
+        .map(move |item| {
+            futures::stream::iter(flat_value(&columns, &item, &tag).into_iter().flatten())
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+enum TableInside<'a> {
+    Entries(&'a str, &'a Tag, Vec<&'a Value>),
+}
+
+fn flat_value(
+    columns: &[Tagged<String>],
+    item: &Value,
+    name_tag: impl Into<Tag>,
+) -> Result<Vec<Result<ReturnSuccess, ShellError>>, ShellError> {
+    let tag = item.tag.clone();
+    let name_tag = name_tag.into();
+
+    let res = {
+        if item.is_row() {
+            let mut out = TaggedDictBuilder::new(tag);
+            let mut a_table = None;
+            let mut tables_explicitly_flattened = 0;
+
+            for (column, value) in item.row_entries() {
+                let column_requested = columns.iter().find(|c| c.item == *column);
+
+                if let Value {
+                    value: UntaggedValue::Row(Dictionary { entries: mapa }),
+                    ..
+                } = value
+                {
+                    if column_requested.is_none() && !columns.is_empty() {
+                        if out.contains_key(&column) {
+                            out.insert_value(format!("{}_{}", column, column), value.clone());
+                        } else {
+                            out.insert_value(column, value.clone());
+                        }
+                        continue;
+                    }
+
+                    for (k, v) in mapa.into_iter() {
+                        if out.contains_key(k) {
+                            out.insert_value(format!("{}_{}", column, k), v.clone());
+                        } else {
+                            out.insert_value(k, v.clone());
+                        }
+                    }
+                } else if value.is_table() {
+                    if tables_explicitly_flattened >= 1 && column_requested.is_some() {
+                        let attempted = if let Some(name) = column_requested {
+                            name.span()
+                        } else {
+                            name_tag.span
+                        };
+
+                        let already_flattened =
+                            if let Some(TableInside::Entries(_, column_tag, _)) = a_table {
+                                column_tag.span
+                            } else {
+                                name_tag.span
+                            };
+
+                        return Ok(vec![ReturnSuccess::value(
+                            UntaggedValue::Error(ShellError::labeled_error_with_secondary(
+                                "can only flatten one inner table at the same time",
+                                "tried flattening more than one column with inner tables",
+                                attempted,
+                                "...but is flattened already",
+                                already_flattened,
+                            ))
+                            .into_value(name_tag),
+                        )]);
+                    }
+
+                    if !columns.is_empty() {
+                        if let Some(requested) = column_requested {
+                            a_table = Some(TableInside::Entries(
+                                &requested.item,
+                                &requested.tag,
+                                value.table_entries().collect(),
+                            ));
+
+                            tables_explicitly_flattened += 1;
+                        } else {
+                            out.insert_value(column, value.clone());
+                        }
+                    } else if a_table.is_none() {
+                        a_table = Some(TableInside::Entries(
+                            &column,
+                            &value.tag,
+                            value.table_entries().collect(),
+                        ))
+                    } else {
+                        out.insert_value(column, value.clone());
+                    }
+                } else {
+                    out.insert_value(column, value.clone());
+                }
+            }
+
+            let mut expanded = vec![];
+
+            if let Some(TableInside::Entries(column, _, entries)) = a_table {
+                for entry in entries.into_iter() {
+                    let mut base = out.clone();
+                    base.insert_value(column, entry.clone());
+                    expanded.push(base.into_value());
+                }
+            } else {
+                expanded.push(out.into_value());
+            }
+
+            expanded
+        } else if item.is_table() {
+            item.table_entries().map(Clone::clone).collect()
+        } else {
+            vec![item.clone()]
+        }
+    };
+
+    Ok(res.into_iter().map(ReturnSuccess::value).collect())
+}

crates/nu-cli/src/commands/format/command.rs

@@ -1,5 +1,4 @@
 use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
 use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use nu_errors::ShellError;
@@ -32,12 +31,8 @@ impl WholeStreamCommand for Format {
         "Format columns into a string using a simple pattern."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        format_command(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        format_command(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -49,13 +44,9 @@ impl WholeStreamCommand for Format {
     }
 }
 
-async fn format_command(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = Arc::new(registry.clone());
-    let scope = Arc::new(args.call_info.scope.clone());
-    let (FormatArgs { pattern }, input) = args.process(&registry).await?;
+async fn format_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let ctx = Arc::new(EvaluationContext::from_args(&args));
+    let (FormatArgs { pattern }, input) = args.process().await?;
 
     let format_pattern = format(&pattern);
     let commands = Arc::new(format_pattern);
@@ -64,8 +55,7 @@ async fn format_command(
         .then(move |value| {
             let mut output = String::new();
             let commands = commands.clone();
-            let registry = registry.clone();
-            let scope = scope.clone();
+            let ctx = ctx.clone();
 
             async move {
                 for command in &*commands {
@@ -77,17 +67,13 @@ async fn format_command(
                             // FIXME: use the correct spans
                             let full_column_path = nu_parser::parse_full_column_path(
                                 &(c.to_string()).spanned(Span::unknown()),
-                                &*registry,
+                                &ctx.scope,
                             );
 
-                            let result = evaluate_baseline_expr(
-                                &full_column_path.0,
-                                &registry,
-                                &value,
-                                &scope.vars,
-                                &scope.env,
-                            )
-                            .await;
+                            ctx.scope.enter_scope();
+                            ctx.scope.add_var("$it", value.clone());
+                            let result = evaluate_baseline_expr(&full_column_path.0, &*ctx).await;
+                            ctx.scope.exit_scope();
 
                             if let Ok(c) = result {
                                 output
@@ -153,11 +139,12 @@ fn format(input: &str) -> Vec<FormatCommand> {
 #[cfg(test)]
 mod tests {
     use super::Format;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(Format {})
+        Ok(test_examples(Format {})?)
     }
 }

crates/nu-cli/src/commands/format/format_filesize.rs

@@ -0,0 +1,186 @@
+use crate::prelude::*;
+use nu_errors::ShellError;
+
+use crate::commands::WholeStreamCommand;
+use nu_protocol::{
+    ColumnPath, Primitive::Filesize, ReturnSuccess, Signature, SyntaxShape, UntaggedValue,
+    UntaggedValue::Primitive, Value,
+};
+use nu_source::Tagged;
+use nu_value_ext::get_data_by_column_path;
+
+use num_format::{Locale, ToFormattedString};
+
+pub struct FileSize;
+
+#[derive(Deserialize)]
+pub struct Arguments {
+    field: ColumnPath,
+    format: Tagged<String>,
+}
+
+#[async_trait]
+impl WholeStreamCommand for FileSize {
+    fn name(&self) -> &str {
+        "format filesize"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("format filesize")
+            .required(
+                "field",
+                SyntaxShape::ColumnPath,
+                "the name of the column to update",
+            )
+            .required(
+                "format value",
+                SyntaxShape::String,
+                "the format into which convert the filesizes",
+            )
+    }
+
+    fn usage(&self) -> &str {
+        "Converts a column of filesizes to some specified format"
+    }
+
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        filesize(args).await
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert the size row to KB",
+                example: "ls | format filesize size KB",
+                result: None,
+            },
+            Example {
+                description: "Convert the apparent row to B",
+                example: "du | format filesize apparent B",
+                result: None,
+            },
+        ]
+    }
+}
+
+async fn process_row(
+    input: Value,
+    format: Tagged<String>,
+    field: Arc<ColumnPath>,
+) -> Result<OutputStream, ShellError> {
+    Ok({
+        let replace_for = get_data_by_column_path(&input, &field, move |_, _, error| error);
+        match replace_for {
+            Ok(s) => match convert_bytes_to_string_using_format(s, format) {
+                Ok(b) => OutputStream::one(ReturnSuccess::value(
+                    input.replace_data_at_column_path(&field, b).expect("Given that the existence check was already done, this shouldn't trigger never"),
+                )),
+                Err(e) => OutputStream::one(Err(e)),
+            },
+            Err(e) => OutputStream::one(Err(e)),
+        }
+    })
+}
+
+async fn filesize(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let (Arguments { field, format }, input) = raw_args.process().await?;
+    let field = Arc::new(field);
+
+    Ok(input
+        .then(move |input| {
+            let format = format.clone();
+            let field = field.clone();
+
+            async {
+                match process_row(input, format, field).await {
+                    Ok(s) => s,
+                    Err(e) => OutputStream::one(Err(e)),
+                }
+            }
+        })
+        .flatten()
+        .to_output_stream())
+}
+
+fn convert_bytes_to_string_using_format(
+    bytes: Value,
+    format: Tagged<String>,
+) -> Result<Value, ShellError> {
+    match bytes.value {
+        Primitive(Filesize(b)) => {
+            let byte = byte_unit::Byte::from_bytes(b as u128);
+            let value = match format.item().to_lowercase().as_str() {
+                "b" => Ok(UntaggedValue::string(b.to_formatted_string(&Locale::en))),
+                "kb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::KB).to_string(),
+                )),
+                "kib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::KiB).to_string(),
+                )),
+                "mb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::MB).to_string(),
+                )),
+                "mib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::MiB).to_string(),
+                )),
+                "gb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::GB).to_string(),
+                )),
+                "gib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::GiB).to_string(),
+                )),
+                "tb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::TB).to_string(),
+                )),
+                "tib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::TiB).to_string(),
+                )),
+                "pb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::PB).to_string(),
+                )),
+                "pib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::PiB).to_string(),
+                )),
+                "eb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::EB).to_string(),
+                )),
+                "eib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::EiB).to_string(),
+                )),
+                "zb" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::ZB).to_string(),
+                )),
+                "zib" => Ok(UntaggedValue::string(
+                    byte.get_adjusted_unit(byte_unit::ByteUnit::ZiB).to_string(),
+                )),
+                _ => Err(ShellError::labeled_error(
+                    format!("Invalid format code: {:}", format.item()),
+                    "invalid format",
+                    format.tag(),
+                )),
+            };
+            match value {
+                Ok(b) => Ok(Value { value: b, ..bytes }),
+                Err(e) => Err(e),
+            }
+        }
+        _ => Err(ShellError::labeled_error(
+            "the data in this row is not of the type filesize",
+            "invalid row type",
+            bytes.tag(),
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FileSize;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        Ok(test_examples(FileSize {})?)
+    }
+}

crates/nu-cli/src/commands/format/mod.rs

@@ -0,0 +1,5 @@
+pub mod command;
+pub mod format_filesize;
+
+pub use command::Format;
+pub use format_filesize::FileSize;

crates/nu-cli/src/commands/from.rs

@@ -19,14 +19,9 @@ impl WholeStreamCommand for From {
         "Parse content (string or binary) as a table (input format based on subcommand, like csv, ini, json, toml)"
     }
 
-    async fn run(
-        &self,
-        _args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = registry.clone();
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(crate::commands::help::get_help(&From, &registry))
+            UntaggedValue::string(crate::commands::help::get_help(&From, &args.scope))
                 .into_value(Tag::unknown()),
         )))
     }
@@ -35,11 +30,12 @@ impl WholeStreamCommand for From {
 #[cfg(test)]
 mod tests {
     use super::From;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(From {})
+        Ok(test_examples(From {})?)
     }
 }

crates/nu-cli/src/commands/from_csv.rs

@@ -37,12 +37,8 @@ impl WholeStreamCommand for FromCSV {
         "Parse text as .csv and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_csv(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_csv(args).await
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -66,11 +62,7 @@ impl WholeStreamCommand for FromCSV {
     }
 }
 
-async fn from_csv(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
+async fn from_csv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
 
     let (
@@ -79,7 +71,7 @@ async fn from_csv(
             separator,
         },
         input,
-    ) = args.process(&registry).await?;
+    ) = args.process().await?;
     let sep = match separator {
         Some(Value {
             value: UntaggedValue::Primitive(Primitive::String(s)),
@@ -109,11 +101,12 @@ async fn from_csv(
 #[cfg(test)]
 mod tests {
     use super::FromCSV;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromCSV {})
+        Ok(test_examples(FromCSV {})?)
     }
 }

crates/nu-cli/src/commands/from_delimited_data.rs

@@ -14,6 +14,7 @@ fn from_delimited_string_to_value(
         .delimiter(separator as u8)
         .from_reader(s.as_bytes());
     let tag = tag.into();
+    let span = tag.span;
 
     let headers = if headerless {
         (1..=reader.headers()?.len())
@@ -30,7 +31,10 @@ fn from_delimited_string_to_value(
             if let Ok(i) = value.parse::<i64>() {
                 tagged_row.insert_value(header, UntaggedValue::int(i).into_value(&tag))
             } else if let Ok(f) = value.parse::<f64>() {
-                tagged_row.insert_value(header, UntaggedValue::decimal(f).into_value(&tag))
+                tagged_row.insert_value(
+                    header,
+                    UntaggedValue::decimal_from_float(f, span).into_value(&tag),
+                )
             } else {
                 tagged_row.insert_value(header, UntaggedValue::string(value).into_value(&tag))
             }
@@ -50,6 +54,7 @@ pub async fn from_delimited_data(
 ) -> Result<OutputStream, ShellError> {
     let name_tag = name;
     let concat_string = input.collect_string(name_tag.clone()).await?;
+    let sample_lines = concat_string.item.lines().take(3).collect_vec().join("\n");
 
     match from_delimited_string_to_value(concat_string.item, headerless, sep, name_tag.clone()) {
         Ok(x) => match x {
@@ -61,10 +66,16 @@ pub async fn from_delimited_data(
         },
         Err(err) => {
             let line_one = match pretty_csv_error(err) {
-                Some(pretty) => format!("Could not parse as {} ({})", format_name, pretty),
-                None => format!("Could not parse as {}", format_name),
+                Some(pretty) => format!(
+                    "Could not parse as {} split by '{}' ({})",
+                    format_name, sep, pretty
+                ),
+                None => format!("Could not parse as {} split by '{}'", format_name, sep),
             };
-            let line_two = format!("input cannot be parsed as {}", format_name);
+            let line_two = format!(
+                "input cannot be parsed as {} split by '{}'. Input's first lines:\n{}",
+                format_name, sep, sample_lines
+            );
 
             Err(ShellError::labeled_error_with_secondary(
                 line_one,

crates/nu-cli/src/commands/from_eml.rs

@@ -35,12 +35,8 @@ impl WholeStreamCommand for FromEML {
         "Parse text as .eml and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_eml(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_eml(args).await
     }
 }
 
@@ -77,13 +73,9 @@ fn headerfieldvalue_to_value(tag: &Tag, value: &HeaderFieldValue) -> UntaggedVal
     }
 }
 
-async fn from_eml(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+async fn from_eml(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
-    let registry = registry.clone();
-    let (eml_args, input): (FromEMLArgs, _) = args.process(&registry).await?;
+    let (eml_args, input): (FromEMLArgs, _) = args.process().await?;
     let value = input.collect_string(tag.clone()).await?;
 
     let body_preview = eml_args
@@ -130,11 +122,12 @@ async fn from_eml(
 #[cfg(test)]
 mod tests {
     use super::FromEML;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromEML {})
+        Ok(test_examples(FromEML {})?)
     }
 }

crates/nu-cli/src/commands/from_ics.rs

@@ -23,21 +23,13 @@ impl WholeStreamCommand for FromIcs {
         "Parse text as .ics and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_ics(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ics(args).await
     }
 }
 
-async fn from_ics(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
+async fn from_ics(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
     let tag = args.name_tag();
     let input = args.input;
 
@@ -249,11 +241,12 @@ fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
 #[cfg(test)]
 mod tests {
     use super::FromIcs;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromIcs {})
+        Ok(test_examples(FromIcs {})?)
     }
 }

crates/nu-cli/src/commands/from_ini.rs

@@ -20,12 +20,8 @@ impl WholeStreamCommand for FromINI {
         "Parse text as .ini and create table"
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_ini(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ini(args).await
     }
 }
 
@@ -64,12 +60,8 @@ pub fn from_ini_string_to_value(
     Ok(convert_ini_top_to_nu_value(&v, tag))
 }
 
-async fn from_ini(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
+async fn from_ini(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
     let tag = args.name_tag();
     let input = args.input;
     let concat_string = input.collect_string(tag.clone()).await?;
@@ -95,11 +87,12 @@ async fn from_ini(
 #[cfg(test)]
 mod tests {
     use super::FromINI;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromINI {})
+        Ok(test_examples(FromINI {})?)
     }
 }

crates/nu-cli/src/commands/from_json.rs

@@ -28,34 +28,31 @@ impl WholeStreamCommand for FromJSON {
         "Parse text as .json and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_json(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_json(args).await
     }
 }
 
-fn convert_json_value_to_nu_value(v: &serde_hjson::Value, tag: impl Into<Tag>) -> Value {
+fn convert_json_value_to_nu_value(v: &nu_json::Value, tag: impl Into<Tag>) -> Value {
     let tag = tag.into();
+    let span = tag.span;
 
     match v {
-        serde_hjson::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
-        serde_hjson::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
-        serde_hjson::Value::F64(n) => UntaggedValue::decimal(*n).into_value(&tag),
-        serde_hjson::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
-        serde_hjson::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
-        serde_hjson::Value::String(s) => {
+        nu_json::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
+        nu_json::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
+        nu_json::Value::F64(n) => UntaggedValue::decimal_from_float(*n, span).into_value(&tag),
+        nu_json::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
+        nu_json::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
+        nu_json::Value::String(s) => {
             UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(&tag)
         }
-        serde_hjson::Value::Array(a) => UntaggedValue::Table(
+        nu_json::Value::Array(a) => UntaggedValue::Table(
             a.iter()
                 .map(|x| convert_json_value_to_nu_value(x, &tag))
                 .collect(),
         )
         .into_value(tag),
-        serde_hjson::Value::Object(o) => {
+        nu_json::Value::Object(o) => {
             let mut collected = TaggedDictBuilder::new(&tag);
             for (k, v) in o.iter() {
                 collected.insert_value(k.clone(), convert_json_value_to_nu_value(v, &tag));
@@ -66,19 +63,15 @@ fn convert_json_value_to_nu_value(v: &serde_hjson::Value, tag: impl Into<Tag>) -
     }
 }
 
-pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> serde_hjson::Result<Value> {
-    let v: serde_hjson::Value = serde_hjson::from_str(&s)?;
+pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> nu_json::Result<Value> {
+    let v: nu_json::Value = nu_json::from_str(&s)?;
     Ok(convert_json_value_to_nu_value(&v, tag))
 }
 
-async fn from_json(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+async fn from_json(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name_tag = args.call_info.name_tag.clone();
-    let registry = registry.clone();
 
-    let (FromJSONArgs { objects }, input) = args.process(&registry).await?;
+    let (FromJSONArgs { objects }, input) = args.process().await?;
     let concat_string = input.collect_string(name_tag.clone()).await?;
 
     let string_clone: Vec<_> = concat_string.item.lines().map(|x| x.to_string()).collect();
@@ -95,7 +88,7 @@ async fn from_json(
                     Err(e) => {
                         let mut message = "Could not parse as JSON (".to_string();
                         message.push_str(&e.to_string());
-                        message.push_str(")");
+                        message.push(')');
 
                         Some(Err(ShellError::labeled_error_with_secondary(
                             message,
@@ -124,7 +117,7 @@ async fn from_json(
             Err(e) => {
                 let mut message = "Could not parse as JSON (".to_string();
                 message.push_str(&e.to_string());
-                message.push_str(")");
+                message.push(')');
 
                 Ok(OutputStream::one(Err(
                     ShellError::labeled_error_with_secondary(
@@ -143,11 +136,12 @@ async fn from_json(
 #[cfg(test)]
 mod tests {
     use super::FromJSON;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromJSON {})
+        Ok(test_examples(FromJSON {})?)
     }
 }

crates/nu-cli/src/commands/from_ods.rs

@@ -1,7 +1,7 @@
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
-use crate::TaggedListBuilder;
 use calamine::*;
+use nu_data::TaggedListBuilder;
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue};
 use std::io::Cursor;
@@ -31,28 +31,21 @@ impl WholeStreamCommand for FromODS {
         "Parse OpenDocument Spreadsheet(.ods) data and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_ods(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ods(args).await
     }
 }
 
-async fn from_ods(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+async fn from_ods(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let tag = args.call_info.name_tag.clone();
-    let registry = registry.clone();
+    let span = tag.span;
 
     let (
         FromODSArgs {
             headerless: _headerless,
         },
         input,
-    ) = args.process(&registry).await?;
+    ) = args.process().await?;
     let bytes = input.collect_binary(tag.clone()).await?;
     let buf: Cursor<Vec<u8>> = Cursor::new(bytes.item);
     let mut ods = Ods::<_>::new(buf).map_err(|_| {
@@ -73,7 +66,7 @@ async fn from_ods(
                     let value = match cell {
                         DataType::Empty => UntaggedValue::nothing(),
                         DataType::String(s) => UntaggedValue::string(s),
-                        DataType::Float(f) => UntaggedValue::decimal(*f),
+                        DataType::Float(f) => UntaggedValue::decimal_from_float(*f, span),
                         DataType::Int(i) => UntaggedValue::int(*i),
                         DataType::Bool(b) => UntaggedValue::boolean(*b),
                         _ => UntaggedValue::nothing(),
@@ -101,11 +94,12 @@ async fn from_ods(
 #[cfg(test)]
 mod tests {
     use super::FromODS;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromODS {})
+        Ok(test_examples(FromODS {})?)
     }
 }

crates/nu-cli/src/commands/from_ssv.rs

@@ -46,12 +46,8 @@ impl WholeStreamCommand for FromSSV {
         "Parse text as space-separated values and create a table. The default minimum number of spaces counted as a separator is 2."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_ssv(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_ssv(args).await
     }
 }
 
@@ -135,7 +131,7 @@ fn parse_aligned_columns<'a>(
             .flat_map(|s| find_indices(*s))
             .collect::<Vec<usize>>();
 
-        indices.sort();
+        indices.sort_unstable();
         indices.dedup();
 
         let headers: Vec<(String, usize)> = indices
@@ -251,12 +247,8 @@ fn from_ssv_string_to_value(
     Some(UntaggedValue::Table(rows).into_value(&tag))
 }
 
-async fn from_ssv(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
+async fn from_ssv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let registry = registry.clone();
     let (
         FromSSVArgs {
             headerless,
@@ -264,7 +256,7 @@ async fn from_ssv(
             minimum_spaces,
         },
         input,
-    ) = args.process(&registry).await?;
+    ) = args.process().await?;
     let concat_string = input.collect_string(name.clone()).await?;
     let split_at = match minimum_spaces {
         Some(number) => number.item,
@@ -302,7 +294,9 @@ async fn from_ssv(
 
 #[cfg(test)]
 mod tests {
+    use super::ShellError;
     use super::*;
+
     fn owned(x: &str, y: &str) -> (String, String) {
         (String::from(x), String::from(y))
     }
@@ -504,10 +498,10 @@ mod tests {
     }
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use super::FromSSV;
         use crate::examples::test as test_examples;
 
-        test_examples(FromSSV {})
+        Ok(test_examples(FromSSV {})?)
     }
 }

crates/nu-cli/src/commands/from_toml.rs

@@ -19,22 +19,19 @@ impl WholeStreamCommand for FromTOML {
         "Parse text as .toml and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_toml(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_toml(args).await
     }
 }
 
 pub fn convert_toml_value_to_nu_value(v: &toml::Value, tag: impl Into<Tag>) -> Value {
     let tag = tag.into();
+    let span = tag.span;
 
     match v {
         toml::Value::Boolean(b) => UntaggedValue::boolean(*b).into_value(tag),
         toml::Value::Integer(n) => UntaggedValue::int(*n).into_value(tag),
-        toml::Value::Float(n) => UntaggedValue::decimal(*n).into_value(tag),
+        toml::Value::Float(n) => UntaggedValue::decimal_from_float(*n, span).into_value(tag),
         toml::Value::String(s) => {
             UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(tag)
         }
@@ -64,12 +61,8 @@ pub fn from_toml_string_to_value(s: String, tag: impl Into<Tag>) -> Result<Value
     Ok(convert_toml_value_to_nu_value(&v, tag))
 }
 
-pub async fn from_toml(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
+pub async fn from_toml(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once().await?;
     let tag = args.name_tag();
     let input = args.input;
 
@@ -100,11 +93,12 @@ pub async fn from_toml(
 #[cfg(test)]
 mod tests {
     use super::FromTOML;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromTOML {})
+        Ok(test_examples(FromTOML {})?)
     }
 }

crates/nu-cli/src/commands/from_tsv.rs

@@ -29,22 +29,14 @@ impl WholeStreamCommand for FromTSV {
         "Parse text as .tsv and create table."
     }
 
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_tsv(args, registry).await
+    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        from_tsv(args).await
     }
 }
 
-async fn from_tsv(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
+async fn from_tsv(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let (FromTSVArgs { headerless }, input) = args.process(&registry).await?;
+    let (FromTSVArgs { headerless }, input) = args.process().await?;
 
     from_delimited_data(headerless, '\t', "TSV", input, name).await
 }
@@ -52,11 +44,12 @@ async fn from_tsv(
 #[cfg(test)]
 mod tests {
     use super::FromTSV;
+    use super::ShellError;
 
     #[test]
-    fn examples_work_as_expected() {
+    fn examples_work_as_expected() -> Result<(), ShellError> {
         use crate::examples::test as test_examples;
 
-        test_examples(FromTSV {})
+        Ok(test_examples(FromTSV {})?)
     }
 }