Bump to 0.28 (#3149)

* move bel and backspace to char since they're not ansi

* Trigger Build

.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

.gitpod.yml

@@ -4,7 +4,7 @@ tasks:
   - name: Clippy
     init: cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
   - name: Testing
-    init: cargo test --all --features=stable,test-bins
+    init: cargo test --all --features=stable
   - name: Build
     init: cargo build --features=stable
   - name: Nu

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.28.0"
 
 [workspace]
 members = ["crates/*/"]
@@ -18,92 +18,147 @@ 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.28.0", path = "./crates/nu-cli", default-features = false }
+nu-command = { version = "0.28.0", path = "./crates/nu-command" }
+nu-data = { version = "0.28.0", path = "./crates/nu-data" }
+nu-engine = { version = "0.28.0", path = "./crates/nu-engine" }
+nu-errors = { version = "0.28.0", path = "./crates/nu-errors" }
+nu-parser = { version = "0.28.0", path = "./crates/nu-parser" }
+nu-plugin = { version = "0.28.0", path = "./crates/nu-plugin" }
+nu-protocol = { version = "0.28.0", path = "./crates/nu-protocol" }
+nu-source = { version = "0.28.0", path = "./crates/nu-source" }
+nu-value-ext = { version = "0.28.0", 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.28.0", path = "./crates/nu_plugin_binaryview", optional = true }
+nu_plugin_chart = { version = "0.28.0", path = "./crates/nu_plugin_chart", optional = true }
+nu_plugin_fetch = { version = "0.28.0", path = "./crates/nu_plugin_fetch", optional = true }
+nu_plugin_from_bson = { version = "0.28.0", path = "./crates/nu_plugin_from_bson", optional = true }
+nu_plugin_from_sqlite = { version = "0.28.0", path = "./crates/nu_plugin_from_sqlite", optional = true }
+nu_plugin_inc = { version = "0.28.0", path = "./crates/nu_plugin_inc", optional = true }
+nu_plugin_match = { version = "0.28.0", path = "./crates/nu_plugin_match", optional = true }
+nu_plugin_post = { version = "0.28.0", path = "./crates/nu_plugin_post", optional = true }
+nu_plugin_ps = { version = "0.28.0", path = "./crates/nu_plugin_ps", optional = true }
+nu_plugin_s3 = { version = "0.28.0", path = "./crates/nu_plugin_s3", optional = true }
+nu_plugin_selector = { version = "0.28.0", path = "./crates/nu_plugin_selector", optional = true }
+nu_plugin_start = { version = "0.28.0", path = "./crates/nu_plugin_start", optional = true }
+nu_plugin_sys = { version = "0.28.0", path = "./crates/nu_plugin_sys", optional = true }
+nu_plugin_textview = { version = "0.28.0", path = "./crates/nu_plugin_textview", optional = true }
+nu_plugin_to_bson = { version = "0.28.0", path = "./crates/nu_plugin_to_bson", optional = true }
+nu_plugin_to_sqlite = { version = "0.28.0", path = "./crates/nu_plugin_to_sqlite", optional = true }
+nu_plugin_tree = { version = "0.28.0", path = "./crates/nu_plugin_tree", optional = true }
+nu_plugin_xpath = { version = "0.28.0", 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.7", optional = true }
+futures = { version = "0.3.12", features = ["compat", "io-compat"] }
+itertools = "0.10.0"
+log = "0.4.14"
 pretty_env_logger = "0.4.0"
-starship = "0.43.0"
 
 [dev-dependencies]
-nu-test-support = {version = "0.17.0", path = "./crates/nu-test-support"}
+nu-test-support = { version = "0.28.0", path = "./crates/nu-test-support" }
+dunce = "1.0.1"
+serial_test = "0.5.1"
+
 
 [build-dependencies]
-nu-build = {version = "0.17.0", path = "./crates/nu-build"}
-serde = {version = "1.0.110", features = ["derive"]}
-toml = "0.5.6"
 
 [features]
-default = [
-  "sys",
-  "ps",
-  "textview",
-  "inc",
-  "git-support",
-  "directories-support",
-  "ctrlc-support",
-  "which-support",
-  "ptree-support",
-  "term-support",
-  "uuid-support",
+ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
+directories-support = [
+    "nu-cli/directories",
+    "nu-cli/dirs",
+    "nu-command/directories",
+    "nu-command/dirs",
+    "nu-data/directories",
+    "nu-data/dirs",
+    "nu-engine/dirs",
+]
+ptree-support = ["nu-cli/ptree", "nu-command/ptree"]
+rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
+term-support = ["nu-cli/term", "nu-command/term"]
+uuid-support = ["nu-cli/uuid_crate", "nu-command/uuid_crate"]
+which-support = [
+    "nu-cli/ichwh",
+    "nu-cli/which",
+    "nu-command/ichwh",
+    "nu-command/which",
 ]
-stable = ["default", "binaryview", "match", "tree", "post", "fetch", "clipboard-cli", "trash-support", "start", "starship-prompt", "bson", "sqlite"]
 
-# Default
-inc = ["semver", "nu_plugin_inc"]
-ps = ["nu_plugin_ps"]
-sys = ["nu_plugin_sys"]
-textview = ["crossterm", "syntect", "url", "nu_plugin_textview"]
+default = [
+    "nu-cli/shadow-rs",
+    "sys",
+    "ps",
+    "textview",
+    "inc",
+    "directories-support",
+    "ctrlc-support",
+    "which-support",
+    "ptree-support",
+    "term-support",
+    "uuid-support",
+    "rustyline-support",
+    "match",
+    "post",
+    "fetch",
+    "zip-support",
+]
 
-# Stable
-binaryview = ["nu_plugin_binaryview"]
-bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
+stable = ["default"]
+extra = [
+    "default",
+    "binaryview",
+    "tree",
+    "clipboard-cli",
+    "trash-support",
+    "start",
+    "bson",
+    "sqlite",
+    "s3",
+    "chart",
+    "xpath",
+    "selector",
+]
+
+wasi = ["inc", "match", "ptree-support", "match", "tree", "rustyline-support"]
+
+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", "nu-command/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", "nu-command/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"]
+trash-support = [
+    "nu-cli/trash-support",
+    "nu-command/trash-support",
+    "nu-engine/trash-support",
+]
 tree = ["nu_plugin_tree"]
+xpath = ["nu_plugin_xpath"]
+#This is disabled in extra for now
+table-pager = ["nu-command/table-pager"]
 
-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"]
+[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 +183,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

@@ -1,17 +1,18 @@
 # README
 
-[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/nushell/nushell)
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
-[![Build Status](https://dev.azure.com/nushell/nushell/_apis/build/status/nushell.nushell?branchName=master)](https://dev.azure.com/nushell/nushell/_build/latest?definitionId=2&branchName=master)
+[![Build Status](https://dev.azure.com/nushell/nushell/_apis/build/status/nushell.nushell?branchName=main)](https://dev.azure.com/nushell/nushell/_build/latest?definitionId=2&branchName=main)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![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)
+![GitHub commit activity](https://img.shields.io/github/commit-activity/m/nushell/nushell)
+![GitHub contributors](https://img.shields.io/github/contributors/nushell/nushell)
 
-## Nu Shell
+## Nushell
 
 A new type of shell.
 
-![Example of nushell](images/nushell-autocomplete.gif "Example of nushell")
+![Example of nushell](images/nushell-autocomplete5.gif "Example of nushell")
 
 ## Status
 
@@ -34,7 +35,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 +45,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`
+-   pkg-config and libssl (only needed on Linux)
+    -   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`
+-   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`
 
 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 +65,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
@@ -139,9 +140,9 @@ Just as the Unix philosophy, Nu allows commands to output from stdout and read f
 Additionally, commands can output structured data (you can think of this as a third kind of stream).
 Commands that work in the pipeline fit into one of three categories:
 
-* Commands that produce a stream (eg, `ls`)
-* Commands that filter a stream (eg, `where type == "Dir"`)
-* Commands that consume the output of the pipeline (eg, `autoview`)
+-   Commands that produce a stream (eg, `ls`)
+-   Commands that filter a stream (eg, `where type == "Dir"`)
+-   Commands that consume the output of the pipeline (eg, `autoview`)
 
 Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.
 
@@ -194,7 +195,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 +220,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 line_editor.edit_mode "vi"
+> config set path $nu.path
 ```
 
 ### Shells
@@ -270,49 +271,55 @@ If the plugin is a sink, it is given the full vector of final data and is given
 
 Nu adheres closely to a set of goals that make up its design philosophy. As features are added, they are checked against these goals.
 
-* First and foremost, Nu is cross-platform. Commands and techniques should carry between platforms and offer first-class consistent support for Windows, macOS, and Linux.
+-   First and foremost, Nu is cross-platform. Commands and techniques should carry between platforms and offer first-class consistent support for Windows, macOS, and Linux.
 
-* Nu ensures direct compatibility with existing platform-specific executables that make up people's workflows.
+-   Nu ensures direct compatibility with existing platform-specific executables that make up people's workflows.
 
-* Nu's workflow and tools should have the usability in day-to-day experience of using a shell in 2019 (and beyond).
+-   Nu's workflow and tools should have the usability in day-to-day experience of using a shell in 2019 (and beyond).
 
-* Nu views data as both structured and unstructured. It is a structured shell like PowerShell.
+-   Nu views data as both structured and unstructured. It is a structured shell like PowerShell.
 
-* Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
+-   Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
 
 ## Commands
 
-You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/documentation.html#quick-command-references).
+You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/book/command_reference.html).
 
 ## Progress
 
-Nu is in heavy development, and will naturally change as it matures and people use it.  The chart below isn't meant to be exhaustive, but rather helps give an idea for some of the areas of development and their relative completion:
+Nu is in heavy development, and will naturally change as it matures and people use it. The chart below isn't meant to be exhaustive, but rather helps give an idea for some of the areas of development and their relative completion:
 
-| Features | Not started | Prototype | MVP | Preview | Mature | Notes
-| -------- |:-----------:|:---------:|:---:|:-------:|:------:| -----
-| Aliases  |             |     X     |     |         |        | Initial implementation but lacks necessary features
-| Notebook |             |     X     |     |         |        | Initial jupyter support, but it loses state and lacks features
-| File ops |             |           |  X  |         |        | cp, mv, rm, mkdir have some support, but lacking others
-| Environment |          |     X     |     |         |        | Temporary environment, but no session-wide env variables
-| Shells   |             |     X     |     |         |        | Basic value and file shells, but no opt-in/opt-out for commands
-| Protocol |             |           |  X  |         |        | Streaming protocol is serviceable
-| Plugins  |             |     X     |     |         |        | Plugins work on one row at a time, lack batching and expression eval
-| Errors   |             |           |  X  |         |        | Error reporting works, but could use usability polish
-| Documentation |        |     X     |     |         |        | Book and related are barebones and lack task-based lessons
-| Paging   |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables
-| Functions|      X      |           |     |         |        | No functions, yet, only aliases
-| Variables|      X      |           |     |         |        | Nu doesn't yet support variables
-| Completions |          |     X     |     |         |        | Completions are currently barebones, at best
-| Type-checking |        |     X     |     |         |        | Commands check basic types, but input/output isn't checked
+| Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
+| ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
+| Aliases       |             |     X     |     |         |        | Initial implementation but lacks necessary features                  |
+| Notebook      |             |     X     |     |         |        | Initial jupyter support, but it loses state and lacks features       |
+| File ops      |             |           |  X  |         |        | cp, mv, rm, mkdir have some support, but lacking others              |
+| Environment   |             |     X     |     |         |        | Temporary environment, but no session-wide env variables             |
+| Shells        |             |     X     |     |         |        | Basic value and file shells, but no opt-in/opt-out for commands      |
+| Protocol      |             |           |  X  |         |        | Streaming protocol is serviceable                                    |
+| Plugins       |             |     X     |     |         |        | Plugins work on one row at a time, lack batching and expression eval |
+| Errors        |             |           |  X  |         |        | Error reporting works, but could use usability polish                |
+| Documentation |             |     X     |     |         |        | Book and related are barebones and lack task-based lessons           |
+| Paging        |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables                 |
+| Functions     |             |     X     |     |         |        | No functions, yet, only aliases                                      |
+| Variables     |             |     X     |     |         |        | Nu doesn't yet support variables                                     |
+| Completions   |             |     X     |     |         |        | Completions are currently barebones, at best                         |
+| Type-checking |             |     X     |     |         |        | Commands check basic types, but input/output isn't checked           |
 
 ## 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
 
 See [Contributing](CONTRIBUTING.md) for details.
 
+Thanks to all the people who already contributed!
+
+<a href="https://github.com/nushell/nushell/graphs/contributors">
+  <img src="https://contributors-img.web.app/image?repo=nushell/nushell" />
+</a>
+
 ## License
 
 The project is made available under the MIT license. See the `LICENSE` file for more information.

build.rs

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

crates/nu-ansi-term/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

crates/nu-ansi-term/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+authors = [
+    "ogham@bsago.me",
+    "Ryan Scheel (Havvy) <ryan.havvy@gmail.com>",
+    "Josh Triplett <josh@joshtriplett.org>",
+    "The Nu Project Contributors",
+]
+description = "Library for ANSI terminal colors and styles (bold, underline)"
+edition = "2018"
+license = "MIT"
+name = "nu-ansi-term"
+version = "0.28.0"
+
+[lib]
+doctest = false
+# name = "nu-ansi-term"
+
+[features]
+derive_serde_style = ["serde"]
+
+[dependencies.serde]
+version = "1.0.90"
+features = ["derive"]
+optional = true
+
+[target.'cfg(target_os="windows")'.dependencies.winapi]
+version = "0.3.4"
+features = ["consoleapi", "errhandlingapi", "fileapi", "handleapi", "processenv"]
+
+[dev-dependencies]
+doc-comment = "0.3"
+regex = "1.1.9"
+
+[dev-dependencies.serde_json]
+version = "1.0.39"

crates/nu-ansi-term/LICENCE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Benjamin Sago
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crates/nu-ansi-term/README.md

@@ -0,0 +1,182 @@
+# nu-ansi-term
+
+> This is a copy of rust-ansi-term but with Color change to Color and light foreground colors added (90-97) as well as light background colors added (100-107).
+
+This is a library for controlling colors and formatting, such as red bold text or blue underlined text, on ANSI terminals.
+
+### [View the Rustdoc](https://docs.rs/nu_ansi_term/)
+
+# Installation
+
+This crate works with [Cargo](http://crates.io). Add the following to your `Cargo.toml` dependencies section:
+
+```toml
+[dependencies]
+nu_ansi_term = "0.13"
+```
+
+## Basic usage
+
+There are three main types in this crate that you need to be concerned with: `ANSIString`, `Style`, and `Color`.
+
+A `Style` holds stylistic information: foreground and background colors, whether the text should be bold, or blinking, or other properties.
+The `Color` enum represents the available colors.
+And an `ANSIString` is a string paired with a `Style`.
+
+`Color` is also available as an alias to `Color`.
+
+To format a string, call the `paint` method on a `Style` or a `Color`, passing in the string you want to format as the argument.
+For example, here’s how to get some red text:
+
+```rust
+use nu_ansi_term::Color::Red;
+
+println!("This is in red: {}", Red.paint("a red string"));
+```
+
+It’s important to note that the `paint` method does _not_ actually return a string with the ANSI control characters surrounding it.
+Instead, it returns an `ANSIString` value that has a `Display` implementation that, when formatted, returns the characters.
+This allows strings to be printed with a minimum of `String` allocations being performed behind the scenes.
+
+If you _do_ want to get at the escape codes, then you can convert the `ANSIString` to a string as you would any other `Display` value:
+
+```rust
+use nu_ansi_term::Color::Red;
+
+let red_string = Red.paint("a red string").to_string();
+```
+
+**Note for Windows 10 users:** On Windows 10, the application must enable ANSI support first:
+
+```rust,ignore
+let enabled = nu_ansi_term::enable_ansi_support();
+```
+
+## Bold, underline, background, and other styles
+
+For anything more complex than plain foreground color changes, you need to construct `Style` values themselves, rather than beginning with a `Color`.
+You can do this by chaining methods based on a new `Style`, created with `Style::new()`.
+Each method creates a new style that has that specific property set.
+For example:
+
+```rust
+use nu_ansi_term::Style;
+
+println!("How about some {} and {}?",
+         Style::new().bold().paint("bold"),
+         Style::new().underline().paint("underline"));
+```
+
+For brevity, these methods have also been implemented for `Color` values, so you can give your styles a foreground color without having to begin with an empty `Style` value:
+
+```rust
+use nu_ansi_term::Color::{Blue, Yellow};
+
+println!("Demonstrating {} and {}!",
+         Blue.bold().paint("blue bold"),
+         Yellow.underline().paint("yellow underline"));
+
+println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
+```
+
+The complete list of styles you can use are:
+`bold`, `dimmed`, `italic`, `underline`, `blink`, `reverse`, `hidden`, and `on` for background colors.
+
+In some cases, you may find it easier to change the foreground on an existing `Style` rather than starting from the appropriate `Color`.
+You can do this using the `fg` method:
+
+```rust
+use nu_ansi_term::Style;
+use nu_ansi_term::Color::{Blue, Cyan, Yellow};
+
+println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
+println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
+```
+
+You can turn a `Color` into a `Style` with the `normal` method.
+This will produce the exact same `ANSIString` as if you just used the `paint` method on the `Color` directly, but it’s useful in certain cases: for example, you may have a method that returns `Styles`, and need to represent both the “red bold” and “red, but not bold” styles with values of the same type. The `Style` struct also has a `Default` implementation if you want to have a style with _nothing_ set.
+
+```rust
+use nu_ansi_term::Style;
+use nu_ansi_term::Color::Red;
+
+Red.normal().paint("yet another red string");
+Style::default().paint("a completely regular string");
+```
+
+## Extended colors
+
+You can access the extended range of 256 colors by using the `Color::Fixed` variant, which takes an argument of the color number to use.
+This can be included wherever you would use a `Color`:
+
+```rust
+use nu_ansi_term::Color::Fixed;
+
+Fixed(134).paint("A sort of light purple");
+Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
+```
+
+The first sixteen of these values are the same as the normal and bold standard color variants.
+There’s nothing stopping you from using these as `Fixed` colors instead, but there’s nothing to be gained by doing so either.
+
+You can also access full 24-bit color by using the `Color::RGB` variant, which takes separate `u8` arguments for red, green, and blue:
+
+```rust
+use nu_ansi_term::Color::RGB;
+
+RGB(70, 130, 180).paint("Steel blue");
+```
+
+## Combining successive coloured strings
+
+The benefit of writing ANSI escape codes to the terminal is that they _stack_: you do not need to end every coloured string with a reset code if the text that follows it is of a similar style.
+For example, if you want to have some blue text followed by some blue bold text, it’s possible to send the ANSI code for blue, followed by the ANSI code for bold, and finishing with a reset code without having to have an extra one between the two strings.
+
+This crate can optimise the ANSI codes that get printed in situations like this, making life easier for your terminal renderer.
+The `ANSIStrings` struct takes a slice of several `ANSIString` values, and will iterate over each of them, printing only the codes for the styles that need to be updated as part of its formatting routine.
+
+The following code snippet uses this to enclose a binary number displayed in red bold text inside some red, but not bold, brackets:
+
+```rust
+use nu_ansi_term::Color::Red;
+use nu_ansi_term::{ANSIString, ANSIStrings};
+
+let some_value = format!("{:b}", 42);
+let strings: &[ANSIString<'static>] = &[
+    Red.paint("["),
+    Red.bold().paint(some_value),
+    Red.paint("]"),
+];
+
+println!("Value: {}", ANSIStrings(strings));
+```
+
+There are several things to note here.
+Firstly, the `paint` method can take _either_ an owned `String` or a borrowed `&str`.
+Internally, an `ANSIString` holds a copy-on-write (`Cow`) string value to deal with both owned and borrowed strings at the same time.
+This is used here to display a `String`, the result of the `format!` call, using the same mechanism as some statically-available `&str` slices.
+Secondly, that the `ANSIStrings` value works in the same way as its singular counterpart, with a `Display` implementation that only performs the formatting when required.
+
+## Byte strings
+
+This library also supports formatting `[u8]` byte strings; this supports applications working with text in an unknown encoding.
+`Style` and `Color` support painting `[u8]` values, resulting in an `ANSIByteString`.
+This type does not implement `Display`, as it may not contain UTF-8, but it does provide a method `write_to` to write the result to any value that implements `Write`:
+
+```rust
+use nu_ansi_term::Color::Green;
+
+Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
+```
+
+Similarly, the type `ANSIByteStrings` supports writing a list of `ANSIByteString` values with minimal escape sequences:
+
+```rust
+use nu_ansi_term::Color::Green;
+use nu_ansi_term::ANSIByteStrings;
+
+ANSIByteStrings(&[
+    Green.paint("user data 1\n".as_bytes()),
+    Green.bold().paint("user data 2\n".as_bytes()),
+]).write_to(&mut std::io::stdout()).unwrap();
+```

crates/nu-ansi-term/examples/256_colors.rs

@@ -0,0 +1,72 @@
+extern crate nu_ansi_term;
+use nu_ansi_term::Color;
+
+// This example prints out the 256 colors.
+// They're arranged like this:
+//
+// - 0 to 8 are the eight standard colors.
+// - 9 to 15 are the eight bold colors.
+// - 16 to 231 are six blocks of six-by-six color squares.
+// - 232 to 255 are shades of grey.
+
+fn main() {
+    // First two lines
+    for c in 0..8 {
+        glow(c, c != 0);
+        print!(" ");
+    }
+    println!();
+    for c in 8..16 {
+        glow(c, c != 8);
+        print!(" ");
+    }
+    println!("\n");
+
+    // Six lines of the first three squares
+    for row in 0..6 {
+        for square in 0..3 {
+            for column in 0..6 {
+                glow(16 + square * 36 + row * 6 + column, row >= 3);
+                print!(" ");
+            }
+
+            print!("  ");
+        }
+
+        println!();
+    }
+    println!();
+
+    // Six more lines of the other three squares
+    for row in 0..6 {
+        for square in 0..3 {
+            for column in 0..6 {
+                glow(124 + square * 36 + row * 6 + column, row >= 3);
+                print!(" ");
+            }
+
+            print!("  ");
+        }
+
+        println!();
+    }
+    println!();
+
+    // The last greyscale lines
+    for c in 232..=243 {
+        glow(c, false);
+        print!(" ");
+    }
+    println!();
+    for c in 244..=255 {
+        glow(c, true);
+        print!(" ");
+    }
+    println!();
+}
+
+fn glow(c: u8, light_bg: bool) {
+    let base = if light_bg { Color::Black } else { Color::White };
+    let style = base.on(Color::Fixed(c));
+    print!("{}", style.paint(&format!(" {:3} ", c)));
+}

crates/nu-ansi-term/examples/basic_colors.rs

@@ -0,0 +1,18 @@
+extern crate nu_ansi_term;
+use nu_ansi_term::{Color::*, Style};
+
+// This example prints out the 16 basic colors.
+
+fn main() {
+    let normal = Style::default();
+
+    println!("{} {}", normal.paint("Normal"), normal.bold().paint("bold"));
+    println!("{} {}", Black.paint("Black"), Black.bold().paint("bold"));
+    println!("{} {}", Red.paint("Red"), Red.bold().paint("bold"));
+    println!("{} {}", Green.paint("Green"), Green.bold().paint("bold"));
+    println!("{} {}", Yellow.paint("Yellow"), Yellow.bold().paint("bold"));
+    println!("{} {}", Blue.paint("Blue"), Blue.bold().paint("bold"));
+    println!("{} {}", Purple.paint("Purple"), Purple.bold().paint("bold"));
+    println!("{} {}", Cyan.paint("Cyan"), Cyan.bold().paint("bold"));
+    println!("{} {}", White.paint("White"), White.bold().paint("bold"));
+}

crates/nu-ansi-term/examples/rgb_colors.rs

@@ -0,0 +1,23 @@
+extern crate nu_ansi_term;
+use nu_ansi_term::{Color, Style};
+
+// This example prints out a color gradient in a grid by calculating each
+// character’s red, green, and blue components, and using 24-bit color codes
+// to display them.
+
+const WIDTH: i32 = 80;
+const HEIGHT: i32 = 24;
+
+fn main() {
+    for row in 0..HEIGHT {
+        for col in 0..WIDTH {
+            let r = (row * 255 / HEIGHT) as u8;
+            let g = (col * 255 / WIDTH) as u8;
+            let b = 128;
+
+            print!("{}", Style::default().on(Color::RGB(r, g, b)).paint(" "));
+        }
+
+        println!();
+    }
+}

crates/nu-ansi-term/src/ansi.rs

@@ -0,0 +1,404 @@
+use crate::style::{Color, Style};
+use crate::write::AnyWrite;
+use std::fmt;
+
+impl Style {
+    /// Write any bytes that go *before* a piece of text to the given writer.
+    fn write_prefix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        // If there are actually no styles here, then don’t write *any* codes
+        // as the prefix. An empty ANSI code may not affect the terminal
+        // output at all, but a user may just want a code-free string.
+        if self.is_plain() {
+            return Ok(());
+        }
+
+        // Write the codes’ prefix, then write numbers, separated by
+        // semicolons, for each text style we want to apply.
+        write!(f, "\x1B[")?;
+        let mut written_anything = false;
+
+        {
+            let mut write_char = |c| {
+                if written_anything {
+                    write!(f, ";")?;
+                }
+                written_anything = true;
+                write!(f, "{}", c)?;
+                Ok(())
+            };
+
+            if self.is_bold {
+                write_char('1')?
+            }
+            if self.is_dimmed {
+                write_char('2')?
+            }
+            if self.is_italic {
+                write_char('3')?
+            }
+            if self.is_underline {
+                write_char('4')?
+            }
+            if self.is_blink {
+                write_char('5')?
+            }
+            if self.is_reverse {
+                write_char('7')?
+            }
+            if self.is_hidden {
+                write_char('8')?
+            }
+            if self.is_strikethrough {
+                write_char('9')?
+            }
+        }
+
+        // The foreground and background colors, if specified, need to be
+        // handled specially because the number codes are more complicated.
+        // (see `write_background_code` and `write_foreground_code`)
+        if let Some(bg) = self.background {
+            if written_anything {
+                write!(f, ";")?;
+            }
+            written_anything = true;
+            bg.write_background_code(f)?;
+        }
+
+        if let Some(fg) = self.foreground {
+            if written_anything {
+                write!(f, ";")?;
+            }
+            fg.write_foreground_code(f)?;
+        }
+
+        // All the codes end with an `m`, because reasons.
+        write!(f, "m")?;
+
+        Ok(())
+    }
+
+    /// Write any bytes that go *after* a piece of text to the given writer.
+    fn write_suffix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        if self.is_plain() {
+            Ok(())
+        } else {
+            write!(f, "{}", RESET)
+        }
+    }
+}
+
+/// The code to send to reset all styles and return to `Style::default()`.
+pub static RESET: &str = "\x1B[0m";
+
+impl Color {
+    fn write_foreground_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        match *self {
+            Color::Black => write!(f, "30"),
+            Color::Red => write!(f, "31"),
+            Color::Green => write!(f, "32"),
+            Color::Yellow => write!(f, "33"),
+            Color::Blue => write!(f, "34"),
+            Color::Purple => write!(f, "35"),
+            Color::Magenta => write!(f, "35"),
+            Color::Cyan => write!(f, "36"),
+            Color::White => write!(f, "37"),
+            Color::Fixed(num) => write!(f, "38;5;{}", &num),
+            Color::RGB(r, g, b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
+            Color::DarkGray => write!(f, "90"),
+            Color::LightRed => write!(f, "91"),
+            Color::LightGreen => write!(f, "92"),
+            Color::LightYellow => write!(f, "93"),
+            Color::LightBlue => write!(f, "94"),
+            Color::LightPurple => write!(f, "95"),
+            Color::LightMagenta => write!(f, "95"),
+            Color::LightCyan => write!(f, "96"),
+            Color::LightGray => write!(f, "97"),
+        }
+    }
+
+    fn write_background_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
+        match *self {
+            Color::Black => write!(f, "40"),
+            Color::Red => write!(f, "41"),
+            Color::Green => write!(f, "42"),
+            Color::Yellow => write!(f, "43"),
+            Color::Blue => write!(f, "44"),
+            Color::Purple => write!(f, "45"),
+            Color::Magenta => write!(f, "45"),
+            Color::Cyan => write!(f, "46"),
+            Color::White => write!(f, "47"),
+            Color::Fixed(num) => write!(f, "48;5;{}", &num),
+            Color::RGB(r, g, b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
+            Color::DarkGray => write!(f, "100"),
+            Color::LightRed => write!(f, "101"),
+            Color::LightGreen => write!(f, "102"),
+            Color::LightYellow => write!(f, "103"),
+            Color::LightBlue => write!(f, "104"),
+            Color::LightPurple => write!(f, "105"),
+            Color::LightMagenta => write!(f, "105"),
+            Color::LightCyan => write!(f, "106"),
+            Color::LightGray => write!(f, "107"),
+        }
+    }
+}
+
+/// Like `ANSIString`, but only displays the style prefix.
+///
+/// This type implements the `Display` trait, meaning it can be written to a
+/// `std::fmt` formatting without doing any extra allocation, and written to a
+/// string with the `.to_string()` method. For examples, see
+/// [`Style::prefix`](struct.Style.html#method.prefix).
+#[derive(Clone, Copy, Debug)]
+pub struct Prefix(Style);
+
+/// Like `ANSIString`, but only displays the difference between two
+/// styles.
+///
+/// This type implements the `Display` trait, meaning it can be written to a
+/// `std::fmt` formatting without doing any extra allocation, and written to a
+/// string with the `.to_string()` method. For examples, see
+/// [`Style::infix`](struct.Style.html#method.infix).
+#[derive(Clone, Copy, Debug)]
+pub struct Infix(Style, Style);
+
+/// Like `ANSIString`, but only displays the style suffix.
+///
+/// This type implements the `Display` trait, meaning it can be written to a
+/// `std::fmt` formatting without doing any extra allocation, and written to a
+/// string with the `.to_string()` method. For examples, see
+/// [`Style::suffix`](struct.Style.html#method.suffix).
+#[derive(Clone, Copy, Debug)]
+pub struct Suffix(Style);
+
+impl Style {
+    /// The prefix bytes for this style. These are the bytes that tell the
+    /// terminal to use a different color or font style.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color::Blue};
+    ///
+    /// let style = Style::default().bold();
+    /// assert_eq!("\x1b[1m",
+    ///            style.prefix().to_string());
+    ///
+    /// let style = Blue.bold();
+    /// assert_eq!("\x1b[1;34m",
+    ///            style.prefix().to_string());
+    ///
+    /// let style = Style::default();
+    /// assert_eq!("",
+    ///            style.prefix().to_string());
+    /// ```
+    pub fn prefix(self) -> Prefix {
+        Prefix(self)
+    }
+
+    /// The infix bytes between this style and `next` style. These are the bytes
+    /// that tell the terminal to change the style to `next`. These may include
+    /// a reset followed by the next color and style, depending on the two styles.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color::Green};
+    ///
+    /// let style = Style::default().bold();
+    /// assert_eq!("\x1b[32m",
+    ///            style.infix(Green.bold()).to_string());
+    ///
+    /// let style = Green.normal();
+    /// assert_eq!("\x1b[1m",
+    ///            style.infix(Green.bold()).to_string());
+    ///
+    /// let style = Style::default();
+    /// assert_eq!("",
+    ///            style.infix(style).to_string());
+    /// ```
+    pub fn infix(self, next: Style) -> Infix {
+        Infix(self, next)
+    }
+
+    /// The suffix for this style. These are the bytes that tell the terminal
+    /// to reset back to its normal color and font style.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color::Green};
+    ///
+    /// let style = Style::default().bold();
+    /// assert_eq!("\x1b[0m",
+    ///            style.suffix().to_string());
+    ///
+    /// let style = Green.normal().bold();
+    /// assert_eq!("\x1b[0m",
+    ///            style.suffix().to_string());
+    ///
+    /// let style = Style::default();
+    /// assert_eq!("",
+    ///            style.suffix().to_string());
+    /// ```
+    pub fn suffix(self) -> Suffix {
+        Suffix(self)
+    }
+}
+
+impl Color {
+    /// The prefix bytes for this color as a `Style`. These are the bytes
+    /// that tell the terminal to use a different color or font style.
+    ///
+    /// See also [`Style::prefix`](struct.Style.html#method.prefix).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::Green;
+    ///
+    /// assert_eq!("\x1b[0m",
+    ///            Green.suffix().to_string());
+    /// ```
+    pub fn prefix(self) -> Prefix {
+        Prefix(self.normal())
+    }
+
+    /// The infix bytes between this color and `next` color. These are the bytes
+    /// that tell the terminal to use the `next` color, or to do nothing if
+    /// the two colors are equal.
+    ///
+    /// See also [`Style::infix`](struct.Style.html#method.infix).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::{Red, Yellow};
+    ///
+    /// assert_eq!("\x1b[33m",
+    ///            Red.infix(Yellow).to_string());
+    /// ```
+    pub fn infix(self, next: Color) -> Infix {
+        Infix(self.normal(), next.normal())
+    }
+
+    /// The suffix for this color as a `Style`. These are the bytes that
+    /// tell the terminal to reset back to its normal color and font style.
+    ///
+    /// See also [`Style::suffix`](struct.Style.html#method.suffix).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::Purple;
+    ///
+    /// assert_eq!("\x1b[0m",
+    ///            Purple.suffix().to_string());
+    /// ```
+    pub fn suffix(self) -> Suffix {
+        Suffix(self.normal())
+    }
+}
+
+impl fmt::Display for Prefix {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let f: &mut dyn fmt::Write = f;
+        self.0.write_prefix(f)
+    }
+}
+
+impl fmt::Display for Infix {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use crate::difference::Difference;
+
+        match Difference::between(&self.0, &self.1) {
+            Difference::ExtraStyles(style) => {
+                let f: &mut dyn fmt::Write = f;
+                style.write_prefix(f)
+            }
+            Difference::Reset => {
+                let f: &mut dyn fmt::Write = f;
+                write!(f, "{}{}", RESET, self.1.prefix())
+            }
+            Difference::NoDifference => {
+                Ok(()) // nothing to write
+            }
+        }
+    }
+}
+
+impl fmt::Display for Suffix {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let f: &mut dyn fmt::Write = f;
+        self.0.write_suffix(f)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::style::Color::*;
+    use crate::style::Style;
+
+    macro_rules! test {
+        ($name: ident: $style: expr; $input: expr => $result: expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!($style.paint($input).to_string(), $result.to_string());
+
+                let mut v = Vec::new();
+                $style.paint($input.as_bytes()).write_to(&mut v).unwrap();
+                assert_eq!(v.as_slice(), $result.as_bytes());
+            }
+        };
+    }
+
+    test!(plain:                 Style::default();                  "text/plain" => "text/plain");
+    test!(red:                   Red;                               "hi" => "\x1B[31mhi\x1B[0m");
+    test!(black:                 Black.normal();                    "hi" => "\x1B[30mhi\x1B[0m");
+    test!(yellow_bold:           Yellow.bold();                     "hi" => "\x1B[1;33mhi\x1B[0m");
+    test!(yellow_bold_2:         Yellow.normal().bold();            "hi" => "\x1B[1;33mhi\x1B[0m");
+    test!(blue_underline:        Blue.underline();                  "hi" => "\x1B[4;34mhi\x1B[0m");
+    test!(green_bold_ul:         Green.bold().underline();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
+    test!(green_bold_ul_2:       Green.underline().bold();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
+    test!(purple_on_white:       Purple.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(purple_on_white_2:     Purple.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(yellow_on_blue:        Style::new().on(Blue).fg(Yellow);  "hi" => "\x1B[44;33mhi\x1B[0m");
+    test!(magenta_on_white:      Magenta.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(magenta_on_white_2:    Magenta.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
+    test!(yellow_on_blue_2:      Cyan.on(Blue).fg(Yellow);          "hi" => "\x1B[44;33mhi\x1B[0m");
+    test!(cyan_bold_on_white:    Cyan.bold().on(White);             "hi" => "\x1B[1;47;36mhi\x1B[0m");
+    test!(cyan_ul_on_white:      Cyan.underline().on(White);        "hi" => "\x1B[4;47;36mhi\x1B[0m");
+    test!(cyan_bold_ul_on_white: Cyan.bold().underline().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
+    test!(cyan_ul_bold_on_white: Cyan.underline().bold().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
+    test!(fixed:                 Fixed(100);                        "hi" => "\x1B[38;5;100mhi\x1B[0m");
+    test!(fixed_on_purple:       Fixed(100).on(Purple);             "hi" => "\x1B[45;38;5;100mhi\x1B[0m");
+    test!(fixed_on_fixed:        Fixed(100).on(Fixed(200));         "hi" => "\x1B[48;5;200;38;5;100mhi\x1B[0m");
+    test!(rgb:                   RGB(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
+    test!(rgb_on_blue:           RGB(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
+    test!(blue_on_rgb:           Blue.on(RGB(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
+    test!(rgb_on_rgb:            RGB(70,130,180).on(RGB(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
+    test!(bold:                  Style::new().bold();               "hi" => "\x1B[1mhi\x1B[0m");
+    test!(underline:             Style::new().underline();          "hi" => "\x1B[4mhi\x1B[0m");
+    test!(bunderline:            Style::new().bold().underline();   "hi" => "\x1B[1;4mhi\x1B[0m");
+    test!(dimmed:                Style::new().dimmed();             "hi" => "\x1B[2mhi\x1B[0m");
+    test!(italic:                Style::new().italic();             "hi" => "\x1B[3mhi\x1B[0m");
+    test!(blink:                 Style::new().blink();              "hi" => "\x1B[5mhi\x1B[0m");
+    test!(reverse:               Style::new().reverse();            "hi" => "\x1B[7mhi\x1B[0m");
+    test!(hidden:                Style::new().hidden();             "hi" => "\x1B[8mhi\x1B[0m");
+    test!(stricken:              Style::new().strikethrough();      "hi" => "\x1B[9mhi\x1B[0m");
+    test!(lr_on_lr:              LightRed.on(LightRed);             "hi" => "\x1B[101;91mhi\x1B[0m");
+
+    #[test]
+    fn test_infix() {
+        assert_eq!(
+            Style::new().dimmed().infix(Style::new()).to_string(),
+            "\x1B[0m"
+        );
+        assert_eq!(
+            White.dimmed().infix(White.normal()).to_string(),
+            "\x1B[0m\x1B[37m"
+        );
+        assert_eq!(White.normal().infix(White.bold()).to_string(), "\x1B[1m");
+        assert_eq!(White.normal().infix(Blue.normal()).to_string(), "\x1B[34m");
+        assert_eq!(Blue.bold().infix(Blue.bold()).to_string(), "");
+    }
+}

crates/nu-ansi-term/src/debug.rs

@@ -0,0 +1,152 @@
+use crate::style::Style;
+use std::fmt;
+
+/// Styles have a special `Debug` implementation that only shows the fields that
+/// are set. Fields that haven’t been touched aren’t included in the output.
+///
+/// This behaviour gets bypassed when using the alternate formatting mode
+/// `format!("{:#?}")`.
+///
+///     use nu_ansi_term::Color::{Red, Blue};
+///     assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
+///                format!("{:?}", Red.on(Blue).bold().italic()));
+impl fmt::Debug for Style {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        if fmt.alternate() {
+            fmt.debug_struct("Style")
+                .field("foreground", &self.foreground)
+                .field("background", &self.background)
+                .field("blink", &self.is_blink)
+                .field("bold", &self.is_bold)
+                .field("dimmed", &self.is_dimmed)
+                .field("hidden", &self.is_hidden)
+                .field("italic", &self.is_italic)
+                .field("reverse", &self.is_reverse)
+                .field("strikethrough", &self.is_strikethrough)
+                .field("underline", &self.is_underline)
+                .finish()
+        } else if self.is_plain() {
+            fmt.write_str("Style {}")
+        } else {
+            fmt.write_str("Style { ")?;
+
+            let mut written_anything = false;
+
+            if let Some(fg) = self.foreground {
+                if written_anything {
+                    fmt.write_str(", ")?
+                }
+                written_anything = true;
+                write!(fmt, "fg({:?})", fg)?
+            }
+
+            if let Some(bg) = self.background {
+                if written_anything {
+                    fmt.write_str(", ")?
+                }
+                written_anything = true;
+                write!(fmt, "on({:?})", bg)?
+            }
+
+            {
+                let mut write_flag = |name| {
+                    if written_anything {
+                        fmt.write_str(", ")?
+                    }
+                    written_anything = true;
+                    fmt.write_str(name)
+                };
+
+                if self.is_blink {
+                    write_flag("blink")?
+                }
+                if self.is_bold {
+                    write_flag("bold")?
+                }
+                if self.is_dimmed {
+                    write_flag("dimmed")?
+                }
+                if self.is_hidden {
+                    write_flag("hidden")?
+                }
+                if self.is_italic {
+                    write_flag("italic")?
+                }
+                if self.is_reverse {
+                    write_flag("reverse")?
+                }
+                if self.is_strikethrough {
+                    write_flag("strikethrough")?
+                }
+                if self.is_underline {
+                    write_flag("underline")?
+                }
+            }
+
+            write!(fmt, " }}")
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::style::Color::*;
+    use crate::style::Style;
+
+    fn style() -> Style {
+        Style::new()
+    }
+
+    macro_rules! test {
+        ($name: ident: $obj: expr => $result: expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!($result, format!("{:?}", $obj));
+            }
+        };
+    }
+
+    test!(empty:   style()                  => "Style {}");
+    test!(bold:    style().bold()           => "Style { bold }");
+    test!(italic:  style().italic()         => "Style { italic }");
+    test!(both:    style().bold().italic()  => "Style { bold, italic }");
+
+    test!(red:     Red.normal()                     => "Style { fg(Red) }");
+    test!(redblue: Red.normal().on(RGB(3, 2, 4))    => "Style { fg(Red), on(RGB(3, 2, 4)) }");
+
+    test!(everything:
+            Red.on(Blue).blink().bold().dimmed().hidden().italic().reverse().strikethrough().underline() =>
+            "Style { fg(Red), on(Blue), blink, bold, dimmed, hidden, italic, reverse, strikethrough, underline }");
+
+    #[test]
+    fn long_and_detailed() {
+        extern crate regex;
+        let expected_debug = "Style { fg(Blue), bold }";
+        let expected_pretty_repat = r##"(?x)
+        Style\s+\{\s+
+            foreground:\s+Some\(\s+
+                Blue,?\s+
+            \),\s+
+            background:\s+None,\s+
+            blink:\s+false,\s+
+            bold:\s+true,\s+
+            dimmed:\s+false,\s+
+            hidden:\s+false,\s+
+            italic:\s+false,\s+
+            reverse:\s+false,\s+
+            strikethrough:\s+
+            false,\s+
+            underline:\s+false,?\s+
+            \}"##;
+        let re = regex::Regex::new(expected_pretty_repat).unwrap();
+
+        let style = Blue.bold();
+        let style_fmt_debug = format!("{:?}", style);
+        let style_fmt_pretty = format!("{:#?}", style);
+        println!("style_fmt_debug:\n{}", style_fmt_debug);
+        println!("style_fmt_pretty:\n{}", style_fmt_pretty);
+
+        assert_eq!(expected_debug, style_fmt_debug);
+        assert!(re.is_match(&style_fmt_pretty));
+    }
+}

crates/nu-ansi-term/src/difference.rs

@@ -0,0 +1,174 @@
+use super::Style;
+
+/// When printing out one colored string followed by another, use one of
+/// these rules to figure out which *extra* control codes need to be sent.
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Difference {
+    /// Print out the control codes specified by this style to end up looking
+    /// like the second string's styles.
+    ExtraStyles(Style),
+
+    /// Converting between these two is impossible, so just send a reset
+    /// command and then the second string's styles.
+    Reset,
+
+    /// The before style is exactly the same as the after style, so no further
+    /// control codes need to be printed.
+    NoDifference,
+}
+
+impl Difference {
+    /// Compute the 'style difference' required to turn an existing style into
+    /// the given, second style.
+    ///
+    /// For example, to turn green text into green bold text, it's redundant
+    /// to write a reset command then a second green+bold command, instead of
+    /// just writing one bold command. This method should see that both styles
+    /// use the foreground color green, and reduce it to a single command.
+    ///
+    /// This method returns an enum value because it's not actually always
+    /// possible to turn one style into another: for example, text could be
+    /// made bold and underlined, but you can't remove the bold property
+    /// without also removing the underline property. So when this has to
+    /// happen, this function returns None, meaning that the entire set of
+    /// styles should be reset and begun again.
+    pub fn between(first: &Style, next: &Style) -> Difference {
+        use self::Difference::*;
+
+        // XXX(Havvy): This algorithm is kind of hard to replicate without
+        // having the Plain/Foreground enum variants, so I'm just leaving
+        // it commented out for now, and defaulting to Reset.
+
+        if first == next {
+            return NoDifference;
+        }
+
+        // Cannot un-bold, so must Reset.
+        if first.is_bold && !next.is_bold {
+            return Reset;
+        }
+
+        if first.is_dimmed && !next.is_dimmed {
+            return Reset;
+        }
+
+        if first.is_italic && !next.is_italic {
+            return Reset;
+        }
+
+        // Cannot un-underline, so must Reset.
+        if first.is_underline && !next.is_underline {
+            return Reset;
+        }
+
+        if first.is_blink && !next.is_blink {
+            return Reset;
+        }
+
+        if first.is_reverse && !next.is_reverse {
+            return Reset;
+        }
+
+        if first.is_hidden && !next.is_hidden {
+            return Reset;
+        }
+
+        if first.is_strikethrough && !next.is_strikethrough {
+            return Reset;
+        }
+
+        // Cannot go from foreground to no foreground, so must Reset.
+        if first.foreground.is_some() && next.foreground.is_none() {
+            return Reset;
+        }
+
+        // Cannot go from background to no background, so must Reset.
+        if first.background.is_some() && next.background.is_none() {
+            return Reset;
+        }
+
+        let mut extra_styles = Style::default();
+
+        if first.is_bold != next.is_bold {
+            extra_styles.is_bold = true;
+        }
+
+        if first.is_dimmed != next.is_dimmed {
+            extra_styles.is_dimmed = true;
+        }
+
+        if first.is_italic != next.is_italic {
+            extra_styles.is_italic = true;
+        }
+
+        if first.is_underline != next.is_underline {
+            extra_styles.is_underline = true;
+        }
+
+        if first.is_blink != next.is_blink {
+            extra_styles.is_blink = true;
+        }
+
+        if first.is_reverse != next.is_reverse {
+            extra_styles.is_reverse = true;
+        }
+
+        if first.is_hidden != next.is_hidden {
+            extra_styles.is_hidden = true;
+        }
+
+        if first.is_strikethrough != next.is_strikethrough {
+            extra_styles.is_strikethrough = true;
+        }
+
+        if first.foreground != next.foreground {
+            extra_styles.foreground = next.foreground;
+        }
+
+        if first.background != next.background {
+            extra_styles.background = next.background;
+        }
+
+        ExtraStyles(extra_styles)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Difference::*;
+    use super::*;
+    use crate::style::Color::*;
+    use crate::style::Style;
+
+    fn style() -> Style {
+        Style::new()
+    }
+
+    macro_rules! test {
+        ($name: ident: $first: expr; $next: expr => $result: expr) => {
+            #[test]
+            fn $name() {
+                assert_eq!($result, Difference::between(&$first, &$next));
+            }
+        };
+    }
+
+    test!(nothing:    Green.normal(); Green.normal()  => NoDifference);
+    test!(uppercase:  Green.normal(); Green.bold()    => ExtraStyles(style().bold()));
+    test!(lowercase:  Green.bold();   Green.normal()  => Reset);
+    test!(nothing2:   Green.bold();   Green.bold()    => NoDifference);
+
+    test!(color_change: Red.normal(); Blue.normal() => ExtraStyles(Blue.normal()));
+
+    test!(addition_of_blink:          style(); style().blink()          => ExtraStyles(style().blink()));
+    test!(addition_of_dimmed:         style(); style().dimmed()         => ExtraStyles(style().dimmed()));
+    test!(addition_of_hidden:         style(); style().hidden()         => ExtraStyles(style().hidden()));
+    test!(addition_of_reverse:        style(); style().reverse()        => ExtraStyles(style().reverse()));
+    test!(addition_of_strikethrough:  style(); style().strikethrough()  => ExtraStyles(style().strikethrough()));
+
+    test!(removal_of_strikethrough:   style().strikethrough(); style()  => Reset);
+    test!(removal_of_reverse:         style().reverse();       style()  => Reset);
+    test!(removal_of_hidden:          style().hidden();        style()  => Reset);
+    test!(removal_of_dimmed:          style().dimmed();        style()  => Reset);
+    test!(removal_of_blink:           style().blink();         style()  => Reset);
+}

crates/nu-ansi-term/src/display.rs

@@ -0,0 +1,303 @@
+use crate::ansi::RESET;
+use crate::difference::Difference;
+use crate::style::{Color, Style};
+use crate::write::AnyWrite;
+use std::borrow::Cow;
+use std::fmt;
+use std::io;
+use std::ops::Deref;
+
+/// An `ANSIGenericString` includes a generic string type and a `Style` to
+/// display that string.  `ANSIString` and `ANSIByteString` are aliases for
+/// this type on `str` and `\[u8]`, respectively.
+#[derive(PartialEq, Debug)]
+pub struct ANSIGenericString<'a, S: 'a + ToOwned + ?Sized>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    style: Style,
+    string: Cow<'a, S>,
+}
+
+/// Cloning an `ANSIGenericString` will clone its underlying string.
+///
+/// # Examples
+///
+/// ```
+/// use nu_ansi_term::ANSIString;
+///
+/// let plain_string = ANSIString::from("a plain string");
+/// let clone_string = plain_string.clone();
+/// assert_eq!(clone_string, plain_string);
+/// ```
+impl<'a, S: 'a + ToOwned + ?Sized> Clone for ANSIGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    fn clone(&self) -> ANSIGenericString<'a, S> {
+        ANSIGenericString {
+            style: self.style,
+            string: self.string.clone(),
+        }
+    }
+}
+
+// You might think that the hand-written Clone impl above is the same as the
+// one that gets generated with #[derive]. But it’s not *quite* the same!
+//
+// `str` is not Clone, and the derived Clone implementation puts a Clone
+// constraint on the S type parameter (generated using --pretty=expanded):
+//
+//                  ↓_________________↓
+//     impl <'a, S: ::std::clone::Clone + 'a + ToOwned + ?Sized> ::std::clone::Clone
+//     for ANSIGenericString<'a, S> where
+//     <S as ToOwned>::Owned: fmt::Debug { ... }
+//
+// This resulted in compile errors when you tried to derive Clone on a type
+// that used it:
+//
+//     #[derive(PartialEq, Debug, Clone, Default)]
+//     pub struct TextCellContents(Vec<ANSIString<'static>>);
+//                                 ^^^^^^^^^^^^^^^^^^^^^^^^^
+//     error[E0277]: the trait `std::clone::Clone` is not implemented for `str`
+//
+// The hand-written impl above can ignore that constraint and still compile.
+
+/// An ANSI String is a string coupled with the `Style` to display it
+/// in a terminal.
+///
+/// Although not technically a string itself, it can be turned into
+/// one with the `to_string` method.
+///
+/// # Examples
+///
+/// ```
+/// use nu_ansi_term::ANSIString;
+/// use nu_ansi_term::Color::Red;
+///
+/// let red_string = Red.paint("a red string");
+/// println!("{}", red_string);
+/// ```
+///
+/// ```
+/// use nu_ansi_term::ANSIString;
+///
+/// let plain_string = ANSIString::from("a plain string");
+/// assert_eq!(&*plain_string, "a plain string");
+/// ```
+pub type ANSIString<'a> = ANSIGenericString<'a, str>;
+
+/// An `ANSIByteString` represents a formatted series of bytes.  Use
+/// `ANSIByteString` when styling text with an unknown encoding.
+pub type ANSIByteString<'a> = ANSIGenericString<'a, [u8]>;
+
+impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for ANSIGenericString<'a, S>
+where
+    I: Into<Cow<'a, S>>,
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    fn from(input: I) -> ANSIGenericString<'a, S> {
+        ANSIGenericString {
+            string: input.into(),
+            style: Style::default(),
+        }
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    /// Directly access the style
+    pub fn style_ref(&self) -> &Style {
+        &self.style
+    }
+
+    /// Directly access the style mutably
+    pub fn style_ref_mut(&mut self) -> &mut Style {
+        &mut self.style
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized> Deref for ANSIGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+{
+    type Target = S;
+
+    fn deref(&self) -> &S {
+        self.string.deref()
+    }
+}
+
+/// A set of `ANSIGenericString`s collected together, in order to be
+/// written with a minimum of control characters.
+#[derive(Debug, PartialEq)]
+pub struct ANSIGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [ANSIGenericString<'a, S>])
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+    S: PartialEq;
+
+/// A set of `ANSIString`s collected together, in order to be written with a
+/// minimum of control characters.
+pub type ANSIStrings<'a> = ANSIGenericStrings<'a, str>;
+
+/// A function to construct an `ANSIStrings` instance.
+#[allow(non_snake_case)]
+pub fn ANSIStrings<'a>(arg: &'a [ANSIString<'a>]) -> ANSIStrings<'a> {
+    ANSIGenericStrings(arg)
+}
+
+/// A set of `ANSIByteString`s collected together, in order to be
+/// written with a minimum of control characters.
+pub type ANSIByteStrings<'a> = ANSIGenericStrings<'a, [u8]>;
+
+/// A function to construct an `ANSIByteStrings` instance.
+#[allow(non_snake_case)]
+pub fn ANSIByteStrings<'a>(arg: &'a [ANSIByteString<'a>]) -> ANSIByteStrings<'a> {
+    ANSIGenericStrings(arg)
+}
+
+// ---- paint functions ----
+
+impl Style {
+    /// Paints the given text with this color, returning an ANSI string.
+    #[must_use]
+    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S>
+    where
+        I: Into<Cow<'a, S>>,
+        <S as ToOwned>::Owned: fmt::Debug,
+    {
+        ANSIGenericString {
+            string: input.into(),
+            style: self,
+        }
+    }
+}
+
+impl Color {
+    /// Paints the given text with this color, returning an ANSI string.
+    /// This is a short-cut so you don’t have to use `Blue.normal()` just
+    /// to get blue text.
+    ///
+    /// ```
+    /// use nu_ansi_term::Color::Blue;
+    /// println!("{}", Blue.paint("da ba dee"));
+    /// ```
+    #[must_use]
+    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S>
+    where
+        I: Into<Cow<'a, S>>,
+        <S as ToOwned>::Owned: fmt::Debug,
+    {
+        ANSIGenericString {
+            string: input.into(),
+            style: self.normal(),
+        }
+    }
+}
+
+// ---- writers for individual ANSI strings ----
+
+impl<'a> fmt::Display for ANSIString<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let w: &mut dyn fmt::Write = f;
+        self.write_to_any(w)
+    }
+}
+
+impl<'a> ANSIByteString<'a> {
+    /// Write an `ANSIByteString` to an `io::Write`.  This writes the escape
+    /// sequences for the associated `Style` around the bytes.
+    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
+        let w: &mut dyn io::Write = w;
+        self.write_to_any(w)
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+    &'a S: AsRef<[u8]>,
+{
+    fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
+        write!(w, "{}", self.style.prefix())?;
+        w.write_str(self.string.as_ref())?;
+        write!(w, "{}", self.style.suffix())
+    }
+}
+
+// ---- writers for combined ANSI strings ----
+
+impl<'a> fmt::Display for ANSIStrings<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let f: &mut dyn fmt::Write = f;
+        self.write_to_any(f)
+    }
+}
+
+impl<'a> ANSIByteStrings<'a> {
+    /// Write `ANSIByteStrings` to an `io::Write`.  This writes the minimal
+    /// escape sequences for the associated `Style`s around each set of
+    /// bytes.
+    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
+        let w: &mut dyn io::Write = w;
+        self.write_to_any(w)
+    }
+}
+
+impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> ANSIGenericStrings<'a, S>
+where
+    <S as ToOwned>::Owned: fmt::Debug,
+    &'a S: AsRef<[u8]>,
+{
+    fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
+        use self::Difference::*;
+
+        let first = match self.0.first() {
+            None => return Ok(()),
+            Some(f) => f,
+        };
+
+        write!(w, "{}", first.style.prefix())?;
+        w.write_str(first.string.as_ref())?;
+
+        for window in self.0.windows(2) {
+            match Difference::between(&window[0].style, &window[1].style) {
+                ExtraStyles(style) => write!(w, "{}", style.prefix())?,
+                Reset => write!(w, "{}{}", RESET, window[1].style.prefix())?,
+                NoDifference => { /* Do nothing! */ }
+            }
+
+            w.write_str(&window[1].string)?;
+        }
+
+        // Write the final reset string after all of the ANSIStrings have been
+        // written, *except* if the last one has no styles, because it would
+        // have already been written by this point.
+        if let Some(last) = self.0.last() {
+            if !last.style.is_plain() {
+                write!(w, "{}", RESET)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+// ---- tests ----
+
+#[cfg(test)]
+mod tests {
+    pub use super::super::ANSIStrings;
+    pub use crate::style::Color::*;
+    pub use crate::style::Style;
+
+    #[test]
+    fn no_control_codes_for_plain() {
+        let one = Style::default().paint("one");
+        let two = Style::default().paint("two");
+        let output = format!("{}", ANSIStrings(&[one, two]));
+        assert_eq!(&*output, "onetwo");
+    }
+}

crates/nu-ansi-term/src/lib.rs

@@ -0,0 +1,267 @@
+//! This is a library for controlling colors and formatting, such as
+//! red bold text or blue underlined text, on ANSI terminals.
+//!
+//!
+//! ## Basic usage
+//!
+//! There are three main types in this crate that you need to be
+//! concerned with: [`ANSIString`], [`Style`], and [`Color`].
+//!
+//! A `Style` holds stylistic information: foreground and background colors,
+//! whether the text should be bold, or blinking, or other properties. The
+//! [`Color`] enum represents the available colors. And an [`ANSIString`] is a
+//! string paired with a [`Style`].
+//!
+//! [`Color`] is also available as an alias to `Color`.
+//!
+//! To format a string, call the `paint` method on a `Style` or a `Color`,
+//! passing in the string you want to format as the argument. For example,
+//! here’s how to get some red text:
+//!
+//! ```
+//! use nu_ansi_term::Color::Red;
+//!
+//! println!("This is in red: {}", Red.paint("a red string"));
+//! ```
+//!
+//! It’s important to note that the `paint` method does *not* actually return a
+//! string with the ANSI control characters surrounding it. Instead, it returns
+//! an [`ANSIString`] value that has a [`Display`] implementation that, when
+//! formatted, returns the characters. This allows strings to be printed with a
+//! minimum of [`String`] allocations being performed behind the scenes.
+//!
+//! If you *do* want to get at the escape codes, then you can convert the
+//! [`ANSIString`] to a string as you would any other `Display` value:
+//!
+//! ```
+//! use nu_ansi_term::Color::Red;
+//!
+//! let red_string = Red.paint("a red string").to_string();
+//! ```
+//!
+//!
+//! ## Bold, underline, background, and other styles
+//!
+//! For anything more complex than plain foreground color changes, you need to
+//! construct `Style` values themselves, rather than beginning with a `Color`.
+//! You can do this by chaining methods based on a new `Style`, created with
+//! [`Style::new()`]. Each method creates a new style that has that specific
+//! property set. For example:
+//!
+//! ```
+//! use nu_ansi_term::Style;
+//!
+//! println!("How about some {} and {}?",
+//!          Style::new().bold().paint("bold"),
+//!          Style::new().underline().paint("underline"));
+//! ```
+//!
+//! For brevity, these methods have also been implemented for `Color` values,
+//! so you can give your styles a foreground color without having to begin with
+//! an empty `Style` value:
+//!
+//! ```
+//! use nu_ansi_term::Color::{Blue, Yellow};
+//!
+//! println!("Demonstrating {} and {}!",
+//!          Blue.bold().paint("blue bold"),
+//!          Yellow.underline().paint("yellow underline"));
+//!
+//! println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
+//! ```
+//!
+//! The complete list of styles you can use are: [`bold`], [`dimmed`], [`italic`],
+//! [`underline`], [`blink`], [`reverse`], [`hidden`], [`strikethrough`], and [`on`] for
+//! background colors.
+//!
+//! In some cases, you may find it easier to change the foreground on an
+//! existing `Style` rather than starting from the appropriate `Color`.
+//! You can do this using the [`fg`] method:
+//!
+//! ```
+//! use nu_ansi_term::Style;
+//! use nu_ansi_term::Color::{Blue, Cyan, Yellow};
+//!
+//! println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
+//! println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
+//! ```
+//!
+//! You can turn a `Color` into a `Style` with the [`normal`] method.
+//! This will produce the exact same `ANSIString` as if you just used the
+//! `paint` method on the `Color` directly, but it’s useful in certain cases:
+//! for example, you may have a method that returns `Styles`, and need to
+//! represent both the “red bold” and “red, but not bold” styles with values of
+//! the same type. The `Style` struct also has a [`Default`] implementation if you
+//! want to have a style with *nothing* set.
+//!
+//! ```
+//! use nu_ansi_term::Style;
+//! use nu_ansi_term::Color::Red;
+//!
+//! Red.normal().paint("yet another red string");
+//! Style::default().paint("a completely regular string");
+//! ```
+//!
+//!
+//! ## Extended colors
+//!
+//! You can access the extended range of 256 colors by using the `Color::Fixed`
+//! variant, which takes an argument of the color number to use. This can be
+//! included wherever you would use a `Color`:
+//!
+//! ```
+//! use nu_ansi_term::Color::Fixed;
+//!
+//! Fixed(134).paint("A sort of light purple");
+//! Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
+//! ```
+//!
+//! The first sixteen of these values are the same as the normal and bold
+//! standard color variants. There’s nothing stopping you from using these as
+//! `Fixed` colors instead, but there’s nothing to be gained by doing so
+//! either.
+//!
+//! You can also access full 24-bit color by using the `Color::RGB` variant,
+//! which takes separate `u8` arguments for red, green, and blue:
+//!
+//! ```
+//! use nu_ansi_term::Color::RGB;
+//!
+//! RGB(70, 130, 180).paint("Steel blue");
+//! ```
+//!
+//! ## Combining successive colored strings
+//!
+//! The benefit of writing ANSI escape codes to the terminal is that they
+//! *stack*: you do not need to end every colored string with a reset code if
+//! the text that follows it is of a similar style. For example, if you want to
+//! have some blue text followed by some blue bold text, it’s possible to send
+//! the ANSI code for blue, followed by the ANSI code for bold, and finishing
+//! with a reset code without having to have an extra one between the two
+//! strings.
+//!
+//! This crate can optimise the ANSI codes that get printed in situations like
+//! this, making life easier for your terminal renderer. The [`ANSIStrings`]
+//! type takes a slice of several [`ANSIString`] values, and will iterate over
+//! each of them, printing only the codes for the styles that need to be updated
+//! as part of its formatting routine.
+//!
+//! The following code snippet uses this to enclose a binary number displayed in
+//! red bold text inside some red, but not bold, brackets:
+//!
+//! ```
+//! use nu_ansi_term::Color::Red;
+//! use nu_ansi_term::{ANSIString, ANSIStrings};
+//!
+//! let some_value = format!("{:b}", 42);
+//! let strings: &[ANSIString<'static>] = &[
+//!     Red.paint("["),
+//!     Red.bold().paint(some_value),
+//!     Red.paint("]"),
+//! ];
+//!
+//! println!("Value: {}", ANSIStrings(strings));
+//! ```
+//!
+//! There are several things to note here. Firstly, the [`paint`] method can take
+//! *either* an owned [`String`] or a borrowed [`&str`]. Internally, an [`ANSIString`]
+//! holds a copy-on-write ([`Cow`]) string value to deal with both owned and
+//! borrowed strings at the same time. This is used here to display a `String`,
+//! the result of the `format!` call, using the same mechanism as some
+//! statically-available `&str` slices. Secondly, that the [`ANSIStrings`] value
+//! works in the same way as its singular counterpart, with a [`Display`]
+//! implementation that only performs the formatting when required.
+//!
+//! ## Byte strings
+//!
+//! This library also supports formatting `\[u8]` byte strings; this supports
+//! applications working with text in an unknown encoding.  [`Style`] and
+//! [`Color`] support painting `\[u8]` values, resulting in an [`ANSIByteString`].
+//! This type does not implement [`Display`], as it may not contain UTF-8, but
+//! it does provide a method [`write_to`] to write the result to any value that
+//! implements [`Write`]:
+//!
+//! ```
+//! use nu_ansi_term::Color::Green;
+//!
+//! Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
+//! ```
+//!
+//! Similarly, the type [`ANSIByteStrings`] supports writing a list of
+//! [`ANSIByteString`] values with minimal escape sequences:
+//!
+//! ```
+//! use nu_ansi_term::Color::Green;
+//! use nu_ansi_term::ANSIByteStrings;
+//!
+//! ANSIByteStrings(&[
+//!     Green.paint("user data 1\n".as_bytes()),
+//!     Green.bold().paint("user data 2\n".as_bytes()),
+//! ]).write_to(&mut std::io::stdout()).unwrap();
+//! ```
+//!
+//! [`Cow`]: https://doc.rust-lang.org/std/borrow/enum.Cow.html
+//! [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
+//! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html
+//! [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
+//! [`&str`]: https://doc.rust-lang.org/std/primitive.str.html
+//! [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+//! [`Style`]: struct.Style.html
+//! [`Style::new()`]: struct.Style.html#method.new
+//! [`Color`]: enum.Color.html
+//! [`Color`]: enum.Color.html
+//! [`ANSIString`]: type.ANSIString.html
+//! [`ANSIStrings`]: type.ANSIStrings.html
+//! [`ANSIByteString`]: type.ANSIByteString.html
+//! [`ANSIByteStrings`]: type.ANSIByteStrings.html
+//! [`write_to`]: type.ANSIByteString.html#method.write_to
+//! [`paint`]: type.ANSIByteString.html#method.write_to
+//! [`normal`]: enum.Color.html#method.normal
+//!
+//! [`bold`]: struct.Style.html#method.bold
+//! [`dimmed`]: struct.Style.html#method.dimmed
+//! [`italic`]: struct.Style.html#method.italic
+//! [`underline`]: struct.Style.html#method.underline
+//! [`blink`]: struct.Style.html#method.blink
+//! [`reverse`]: struct.Style.html#method.reverse
+//! [`hidden`]: struct.Style.html#method.hidden
+//! [`strikethrough`]: struct.Style.html#method.strikethrough
+//! [`fg`]: struct.Style.html#method.fg
+//! [`on`]: struct.Style.html#method.on
+
+#![crate_name = "nu_ansi_term"]
+#![crate_type = "rlib"]
+#![crate_type = "dylib"]
+#![warn(missing_copy_implementations)]
+#![warn(missing_docs)]
+#![warn(trivial_casts, trivial_numeric_casts)]
+// #![warn(unused_extern_crates, unused_qualifications)]
+
+#[cfg(target_os = "windows")]
+extern crate winapi;
+#[cfg(test)]
+#[macro_use]
+extern crate doc_comment;
+
+#[cfg(test)]
+doctest!("../README.md");
+
+mod ansi;
+pub use ansi::{Infix, Prefix, Suffix};
+
+mod style;
+pub use style::{Color, Style};
+
+mod difference;
+mod display;
+pub use display::*;
+
+mod write;
+
+mod windows;
+pub use windows::*;
+
+mod util;
+pub use util::*;
+
+mod debug;

crates/nu-ansi-term/src/style.rs

@@ -0,0 +1,620 @@
+/// A style is a collection of properties that can format a string
+/// using ANSI escape codes.
+///
+/// # Examples
+///
+/// ```
+/// use nu_ansi_term::{Style, Color};
+///
+/// let style = Style::new().bold().on(Color::Black);
+/// println!("{}", style.paint("Bold on black"));
+/// ```
+#[derive(PartialEq, Clone, Copy)]
+#[cfg_attr(
+    feature = "derive_serde_style",
+    derive(serde::Deserialize, serde::Serialize)
+)]
+pub struct Style {
+    /// The style's foreground color, if it has one.
+    pub foreground: Option<Color>,
+
+    /// The style's background color, if it has one.
+    pub background: Option<Color>,
+
+    /// Whether this style is bold.
+    pub is_bold: bool,
+
+    /// Whether this style is dimmed.
+    pub is_dimmed: bool,
+
+    /// Whether this style is italic.
+    pub is_italic: bool,
+
+    /// Whether this style is underlined.
+    pub is_underline: bool,
+
+    /// Whether this style is blinking.
+    pub is_blink: bool,
+
+    /// Whether this style has reverse colors.
+    pub is_reverse: bool,
+
+    /// Whether this style is hidden.
+    pub is_hidden: bool,
+
+    /// Whether this style is struckthrough.
+    pub is_strikethrough: bool,
+}
+
+impl Style {
+    /// Creates a new Style with no properties set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new();
+    /// println!("{}", style.paint("hi"));
+    /// ```
+    pub fn new() -> Style {
+        Style::default()
+    }
+
+    /// Returns a `Style` with the bold property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().bold();
+    /// println!("{}", style.paint("hey"));
+    /// ```
+    pub fn bold(&self) -> Style {
+        Style {
+            is_bold: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the dimmed property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().dimmed();
+    /// println!("{}", style.paint("sup"));
+    /// ```
+    pub fn dimmed(&self) -> Style {
+        Style {
+            is_dimmed: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the italic property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().italic();
+    /// println!("{}", style.paint("greetings"));
+    /// ```
+    pub fn italic(&self) -> Style {
+        Style {
+            is_italic: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the underline property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().underline();
+    /// println!("{}", style.paint("salutations"));
+    /// ```
+    pub fn underline(&self) -> Style {
+        Style {
+            is_underline: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the blink property set.
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().blink();
+    /// println!("{}", style.paint("wazzup"));
+    /// ```
+    pub fn blink(&self) -> Style {
+        Style {
+            is_blink: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the reverse property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().reverse();
+    /// println!("{}", style.paint("aloha"));
+    /// ```
+    pub fn reverse(&self) -> Style {
+        Style {
+            is_reverse: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the hidden property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().hidden();
+    /// println!("{}", style.paint("ahoy"));
+    /// ```
+    pub fn hidden(&self) -> Style {
+        Style {
+            is_hidden: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the strikethrough property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// let style = Style::new().strikethrough();
+    /// println!("{}", style.paint("yo"));
+    /// ```
+    pub fn strikethrough(&self) -> Style {
+        Style {
+            is_strikethrough: true,
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the foreground color property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color};
+    ///
+    /// let style = Style::new().fg(Color::Yellow);
+    /// println!("{}", style.paint("hi"));
+    /// ```
+    pub fn fg(&self, foreground: Color) -> Style {
+        Style {
+            foreground: Some(foreground),
+            ..*self
+        }
+    }
+
+    /// Returns a `Style` with the background color property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color};
+    ///
+    /// let style = Style::new().on(Color::Blue);
+    /// println!("{}", style.paint("eyyyy"));
+    /// ```
+    pub fn on(&self, background: Color) -> Style {
+        Style {
+            background: Some(background),
+            ..*self
+        }
+    }
+
+    /// Return true if this `Style` has no actual styles, and can be written
+    /// without any control characters.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    ///
+    /// assert_eq!(true,  Style::default().is_plain());
+    /// assert_eq!(false, Style::default().bold().is_plain());
+    /// ```
+    pub fn is_plain(self) -> bool {
+        self == Style::default()
+    }
+}
+
+impl Default for Style {
+    /// Returns a style with *no* properties set. Formatting text using this
+    /// style returns the exact same text.
+    ///
+    /// ```
+    /// use nu_ansi_term::Style;
+    /// assert_eq!(None,  Style::default().foreground);
+    /// assert_eq!(None,  Style::default().background);
+    /// assert_eq!(false, Style::default().is_bold);
+    /// assert_eq!("txt", Style::default().paint("txt").to_string());
+    /// ```
+    fn default() -> Style {
+        Style {
+            foreground: None,
+            background: None,
+            is_bold: false,
+            is_dimmed: false,
+            is_italic: false,
+            is_underline: false,
+            is_blink: false,
+            is_reverse: false,
+            is_hidden: false,
+            is_strikethrough: false,
+        }
+    }
+}
+
+// ---- colors ----
+
+/// A color is one specific type of ANSI escape code, and can refer
+/// to either the foreground or background color.
+///
+/// These use the standard numeric sequences.
+/// See <http://invisible-island.net/xterm/ctlseqs/ctlseqs.html>
+#[derive(PartialEq, Clone, Copy, Debug)]
+#[cfg_attr(
+    feature = "derive_serde_style",
+    derive(serde::Deserialize, serde::Serialize)
+)]
+pub enum Color {
+    /// Color #0 (foreground code `30`, background code `40`).
+    ///
+    /// This is not necessarily the background color, and using it as one may
+    /// render the text hard to read on terminals with dark backgrounds.
+    Black,
+
+    /// Color #0 (foreground code `90`, background code `100`).
+    DarkGray,
+
+    /// Color #1 (foreground code `31`, background code `41`).
+    Red,
+
+    /// Color #1 (foreground code `91`, background code `101`).
+    LightRed,
+
+    /// Color #2 (foreground code `32`, background code `42`).
+    Green,
+
+    /// Color #2 (foreground code `92`, background code `102`).
+    LightGreen,
+
+    /// Color #3 (foreground code `33`, background code `43`).
+    Yellow,
+
+    /// Color #3 (foreground code `93`, background code `103`).
+    LightYellow,
+
+    /// Color #4 (foreground code `34`, background code `44`).
+    Blue,
+
+    /// Color #4 (foreground code `94`, background code `104`).
+    LightBlue,
+
+    /// Color #5 (foreground code `35`, background code `45`).
+    Purple,
+
+    /// Color #5 (foreground code `95`, background code `105`).
+    LightPurple,
+
+    /// Color #5 (foreground code `35`, background code `45`).
+    Magenta,
+
+    /// Color #5 (foreground code `95`, background code `105`).
+    LightMagenta,
+
+    /// Color #6 (foreground code `36`, background code `46`).
+    Cyan,
+
+    /// Color #6 (foreground code `96`, background code `106`).
+    LightCyan,
+
+    /// Color #7 (foreground code `37`, background code `47`).
+    ///
+    /// As above, this is not necessarily the foreground color, and may be
+    /// hard to read on terminals with light backgrounds.
+    White,
+
+    /// Color #7 (foreground code `97`, background code `107`).
+    LightGray,
+
+    /// A color number from 0 to 255, for use in 256-color terminal
+    /// environments.
+    ///
+    /// - colors 0 to 7 are the `Black` to `White` variants respectively.
+    ///   These colors can usually be changed in the terminal emulator.
+    /// - colors 8 to 15 are brighter versions of the eight colors above.
+    ///   These can also usually be changed in the terminal emulator, or it
+    ///   could be configured to use the original colors and show the text in
+    ///   bold instead. It varies depending on the program.
+    /// - colors 16 to 231 contain several palettes of bright colors,
+    ///   arranged in six squares measuring six by six each.
+    /// - colors 232 to 255 are shades of grey from black to white.
+    ///
+    /// It might make more sense to look at a [color chart][cc].
+    ///
+    /// [cc]: https://upload.wikimedia.org/wikipedia/commons/1/15/Xterm_256color_chart.svg
+    Fixed(u8),
+
+    /// A 24-bit RGB color, as specified by ISO-8613-3.
+    RGB(u8, u8, u8),
+}
+
+impl Color {
+    /// Returns a `Style` with the foreground color set to this color.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Red.normal();
+    /// println!("{}", style.paint("hi"));
+    /// ```
+    pub fn normal(self) -> Style {
+        Style {
+            foreground: Some(self),
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// bold property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Green.bold();
+    /// println!("{}", style.paint("hey"));
+    /// ```
+    pub fn bold(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_bold: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// dimmed property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Yellow.dimmed();
+    /// println!("{}", style.paint("sup"));
+    /// ```
+    pub fn dimmed(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_dimmed: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// italic property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Blue.italic();
+    /// println!("{}", style.paint("greetings"));
+    /// ```
+    pub fn italic(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_italic: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// underline property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Purple.underline();
+    /// println!("{}", style.paint("salutations"));
+    /// ```
+    pub fn underline(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_underline: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// blink property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Cyan.blink();
+    /// println!("{}", style.paint("wazzup"));
+    /// ```
+    pub fn blink(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_blink: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// reverse property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Black.reverse();
+    /// println!("{}", style.paint("aloha"));
+    /// ```
+    pub fn reverse(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_reverse: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// hidden property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::White.hidden();
+    /// println!("{}", style.paint("ahoy"));
+    /// ```
+    pub fn hidden(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_hidden: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// strikethrough property set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::Fixed(244).strikethrough();
+    /// println!("{}", style.paint("yo"));
+    /// ```
+    pub fn strikethrough(self) -> Style {
+        Style {
+            foreground: Some(self),
+            is_strikethrough: true,
+            ..Style::default()
+        }
+    }
+
+    /// Returns a `Style` with the foreground color set to this color and the
+    /// background color property set to the given color.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use nu_ansi_term::Color;
+    ///
+    /// let style = Color::RGB(31, 31, 31).on(Color::White);
+    /// println!("{}", style.paint("eyyyy"));
+    /// ```
+    pub fn on(self, background: Color) -> Style {
+        Style {
+            foreground: Some(self),
+            background: Some(background),
+            ..Style::default()
+        }
+    }
+}
+
+impl From<Color> for Style {
+    /// You can turn a `Color` into a `Style` with the foreground color set
+    /// with the `From` trait.
+    ///
+    /// ```
+    /// use nu_ansi_term::{Style, Color};
+    /// let green_foreground = Style::default().fg(Color::Green);
+    /// assert_eq!(green_foreground, Color::Green.normal());
+    /// assert_eq!(green_foreground, Color::Green.into());
+    /// assert_eq!(green_foreground, Style::from(Color::Green));
+    /// ```
+    fn from(color: Color) -> Style {
+        color.normal()
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "derive_serde_style")]
+mod serde_json_tests {
+    use super::{Color, Style};
+
+    #[test]
+    fn color_serialization() {
+        let colors = &[
+            Color::Red,
+            Color::Blue,
+            Color::RGB(123, 123, 123),
+            Color::Fixed(255),
+        ];
+
+        assert_eq!(
+            serde_json::to_string(&colors).unwrap(),
+            String::from("[\"Red\",\"Blue\",{\"RGB\":[123,123,123]},{\"Fixed\":255}]")
+        );
+    }
+
+    #[test]
+    fn color_deserialization() {
+        let colors = &[
+            Color::Red,
+            Color::Blue,
+            Color::RGB(123, 123, 123),
+            Color::Fixed(255),
+        ];
+
+        for color in colors.into_iter() {
+            let serialized = serde_json::to_string(&color).unwrap();
+            let deserialized: Color = serde_json::from_str(&serialized).unwrap();
+
+            assert_eq!(color, &deserialized);
+        }
+    }
+
+    #[test]
+    fn style_serialization() {
+        let style = Style::default();
+
+        assert_eq!(serde_json::to_string(&style).unwrap(), "{\"foreground\":null,\"background\":null,\"is_bold\":false,\"is_dimmed\":false,\"is_italic\":false,\"is_underline\":false,\"is_blink\":false,\"is_reverse\":false,\"is_hidden\":false,\"is_strikethrough\":false}".to_string());
+    }
+}

crates/nu-ansi-term/src/util.rs

@@ -0,0 +1,80 @@
+use crate::display::{ANSIString, ANSIStrings};
+use std::ops::Deref;
+
+/// Return a substring of the given ANSIStrings sequence, while keeping the formatting.
+pub fn sub_string<'a>(
+    start: usize,
+    len: usize,
+    strs: &ANSIStrings<'a>,
+) -> Vec<ANSIString<'static>> {
+    let mut vec = Vec::new();
+    let mut pos = start;
+    let mut len_rem = len;
+
+    for i in strs.0.iter() {
+        let fragment = i.deref();
+        let frag_len = fragment.len();
+        if pos >= frag_len {
+            pos -= frag_len;
+            continue;
+        }
+        if len_rem == 0 {
+            break;
+        }
+
+        let end = pos + len_rem;
+        let pos_end = if end >= frag_len { frag_len } else { end };
+
+        vec.push(i.style_ref().paint(String::from(&fragment[pos..pos_end])));
+
+        if end <= frag_len {
+            break;
+        }
+
+        len_rem -= pos_end - pos;
+        pos = 0;
+    }
+
+    vec
+}
+
+/// Return a concatenated copy of `strs` without the formatting, as an allocated `String`.
+pub fn unstyle(strs: &ANSIStrings) -> String {
+    let mut s = String::new();
+
+    for i in strs.0.iter() {
+        s += &i.deref();
+    }
+
+    s
+}
+
+/// Return the unstyled length of ANSIStrings. This is equaivalent to `unstyle(strs).len()`.
+pub fn unstyled_len(strs: &ANSIStrings) -> usize {
+    let mut l = 0;
+    for i in strs.0.iter() {
+        l += i.deref().len();
+    }
+    l
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::Color::*;
+
+    #[test]
+    fn test() {
+        let l = [
+            Black.paint("first"),
+            Red.paint("-second"),
+            White.paint("-third"),
+        ];
+        let a = ANSIStrings(&l);
+        assert_eq!(unstyle(&a), "first-second-third");
+        assert_eq!(unstyled_len(&a), 18);
+
+        let l2 = [Black.paint("st"), Red.paint("-second"), White.paint("-t")];
+        assert_eq!(sub_string(3, 11, &a).as_slice(), &l2);
+    }
+}

crates/nu-ansi-term/src/windows.rs

@@ -0,0 +1,62 @@
+/// Enables ANSI code support on Windows 10.
+///
+/// This uses Windows API calls to alter the properties of the console that
+/// the program is running in.
+///
+/// https://msdn.microsoft.com/en-us/library/windows/desktop/mt638032(v=vs.85).aspx
+///
+/// Returns a `Result` with the Windows error code if unsuccessful.
+#[cfg(windows)]
+pub fn enable_ansi_support() -> Result<(), u32> {
+    // ref: https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#EXAMPLE_OF_ENABLING_VIRTUAL_TERMINAL_PROCESSING @@ https://archive.is/L7wRJ#76%
+
+    use std::ffi::OsStr;
+    use std::iter::once;
+    use std::os::windows::ffi::OsStrExt;
+    use std::ptr::null_mut;
+    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
+    use winapi::um::errhandlingapi::GetLastError;
+    use winapi::um::fileapi::{CreateFileW, OPEN_EXISTING};
+    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
+    use winapi::um::winnt::{FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE};
+
+    const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
+
+    unsafe {
+        // ref: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+        // Using `CreateFileW("CONOUT$", ...)` to retrieve the console handle works correctly even if STDOUT and/or STDERR are redirected
+        let console_out_name: Vec<u16> =
+            OsStr::new("CONOUT$").encode_wide().chain(once(0)).collect();
+        let console_handle = CreateFileW(
+            console_out_name.as_ptr(),
+            GENERIC_READ | GENERIC_WRITE,
+            FILE_SHARE_WRITE,
+            null_mut(),
+            OPEN_EXISTING,
+            0,
+            null_mut(),
+        );
+        if console_handle == INVALID_HANDLE_VALUE {
+            return Err(GetLastError());
+        }
+
+        // ref: https://docs.microsoft.com/en-us/windows/console/getconsolemode
+        let mut console_mode: u32 = 0;
+        if 0 == GetConsoleMode(console_handle, &mut console_mode) {
+            return Err(GetLastError());
+        }
+
+        // VT processing not already enabled?
+        if console_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0 {
+            // https://docs.microsoft.com/en-us/windows/console/setconsolemode
+            if 0 == SetConsoleMode(
+                console_handle,
+                console_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+            ) {
+                return Err(GetLastError());
+            }
+        }
+    }
+
+    Ok(())
+}

crates/nu-ansi-term/src/write.rs

@@ -0,0 +1,37 @@
+use std::fmt;
+use std::io;
+
+pub trait AnyWrite {
+    type Wstr: ?Sized;
+    type Error;
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error>;
+
+    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error>;
+}
+
+impl<'a> AnyWrite for dyn fmt::Write + 'a {
+    type Wstr = str;
+    type Error = fmt::Error;
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
+        fmt::Write::write_fmt(self, fmt)
+    }
+
+    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error> {
+        fmt::Write::write_str(self, s)
+    }
+}
+
+impl<'a> AnyWrite for dyn io::Write + 'a {
+    type Wstr = [u8];
+    type Error = io::Error;
+
+    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
+        io::Write::write_fmt(self, fmt)
+    }
+
+    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error> {
+        io::Write::write_all(self, s)
+    }
+}

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,101 +1,111 @@
 [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.28.0"
 
 [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-command = { version = "0.28.0", path = "../nu-command" }
+nu-data = { version = "0.28.0", path = "../nu-data" }
+nu-engine = { version = "0.28.0", path = "../nu-engine" }
+nu-errors = { version = "0.28.0", path = "../nu-errors" }
+nu-json = { version = "0.28.0", path = "../nu-json" }
+nu-parser = { version = "0.28.0", path = "../nu-parser" }
+nu-plugin = { version = "0.28.0", path = "../nu-plugin" }
+nu-protocol = { version = "0.28.0", path = "../nu-protocol" }
+nu-source = { version = "0.28.0", path = "../nu-source" }
+nu-stream = { version = "0.28.0", path = "../nu-stream" }
+nu-table = { version = "0.28.0", path = "../nu-table" }
+nu-test-support = { version = "0.28.0", path = "../nu-test-support" }
+nu-value-ext = { version = "0.28.0", path = "../nu-value-ext" }
+nu-ansi-term = { version = "0.28.0", path = "../nu-ansi-term" }
 
-ansi_term = "0.12.1"
-app_dirs = "1.2.1"
-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"
-codespan-reporting = "0.9.5"
-csv = "1.1"
-ctrlc = {version = "3.1.4", optional = true}
+Inflector = "0.11"
+arboard = { version = "1.1.0", optional = true }
+async-recursion = "0.3.2"
+async-trait = "0.1.42"
+base64 = "0.13.0"
+bigdecimal = { version = "0.2.0", features = ["serde"] }
+byte-unit = "4.0.9"
+bytes = "1.0.1"
+calamine = "0.17.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+chrono-tz = "0.5.3"
+clap = "2.33.3"
+codespan-reporting = "0.11.0"
+csv = "1.1.5"
+ctrlc = { version = "3.1.7", optional = true }
 derive-new = "0.5.8"
-directories = {version = "2.0.2", optional = true}
-dirs = {version = "2.0.2", optional = true}
+directories-next = { version = "2.0.0", optional = true }
+dirs-next = { version = "2.0.0", optional = true }
+dtparse = "1.2.0"
 dunce = "1.0.1"
 eml-parser = "0.1.0"
+encoding_rs = "0.8.28"
 filesize = "0.2.0"
-futures = {version = "0.3", features = ["compat", "io-compat"]}
-futures-util = "0.3.5"
-futures_codec = "0.4"
+fs_extra = "1.2.0"
+futures = { version = "0.3.12", features = ["compat", "io-compat"] }
+futures-util = "0.3.12"
+futures_codec = "0.4.1"
 getset = "0.1.1"
-git2 = {version = "0.13.6", default_features = false, optional = true}
 glob = "0.3.0"
-hex = "0.4"
 htmlescape = "0.3.1"
-ical = "0.6.*"
-ichwh = {version = "0.3.4", optional = true}
-indexmap = {version = "1.4.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"
-parking_lot = "0.11.0"
+ical = "0.7.0"
+ichwh = { version = "0.3.4", optional = true }
+indexmap = { version = "1.6.1", features = ["serde-1"] }
+itertools = "0.10.0"
+lazy_static = "1.*"
+log = "0.4.14"
+meval = "0.2.0"
+num-bigint = { version = "0.3.1", features = ["serde"] }
+num-format = { version = "0.4.0", features = ["with-num-bigint"] }
+num-traits = "0.2.14"
+parking_lot = "0.11.1"
 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.1"
+ptree = { version = "0.3.1", optional = true }
 query_interface = "0.3.5"
-rand = "0.7"
-regex = "1"
-roxmltree = "0.13.0"
-rustyline = "6.2.0"
-serde = {version = "1.0.114", features = ["derive"]}
-serde-hjson = "0.9.1"
+quick-xml = "0.21.0"
+rand = "0.8.3"
+rayon = "1.5.0"
+regex = "1.4.3"
+roxmltree = "0.14.0"
+rust-embed = "5.9.0"
+rustyline = { version = "6.3.0", optional = true }
+serde = { version = "1.0.123", 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"
-sha2 = "0.9.1"
-shellexpand = "2.0.0"
+serde_json = "1.0.61"
+serde_urlencoded = "0.7.0"
+serde_yaml = "0.8.16"
+sha2 = "0.9.3"
+shellexpand = "2.1.0"
 strip-ansi-escapes = "0.1.0"
-tempfile = "3.1.0"
-term = {version = "0.5.2", optional = true}
+sxd-document = "0.3.2"
+sxd-xpath = "0.4.2"
+tempfile = "3.2.0"
+term = { version = "0.7.0", optional = true }
 term_size = "0.3.2"
-termcolor = "1.1.0"
-toml = "0.5.6"
-typetag = "0.1.5"
-umask = "1.0.0"
-unicode-xid = "0.2.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}
+termcolor = "1.1.2"
+titlecase = "1.1.0"
+toml = "0.5.8"
+trash = { version = "1.3.0", optional = true }
+unicode-segmentation = "1.7.1"
+url = "2.1.1"
+uuid_crate = { package = "uuid", version = "0.8.2", features = ["v4"], optional = true }
+which = { version = "4.0.2", optional = true }
+zip = { version = "0.5.9", optional = true }
+shadow-rs = { version = "0.5", default-features = false, optional = true }
 
 [target.'cfg(unix)'.dependencies]
-users = "0.10.0"
+umask = "1.0.0"
+users = "0.11.0"
 
 # TODO this will be possible with new dependency resolver
 #   (currently on nightly behind -Zfeatures=itarget):
@@ -106,17 +116,20 @@ 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 = "1.0.3"
+quickcheck_macros = "1.0.0"
 
 [features]
-clipboard-cli = ["clipboard"]
+default = ["shadow-rs"]
+clipboard-cli = ["arboard"]
+rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
 stable = []
-starship-prompt = ["starship"]
 trash-support = ["trash"]
+dirs = ["dirs-next"]
+directories = ["directories-next"]

crates/nu-cli/build.rs

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

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,148 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-
-pub struct Ansi;
-
-#[derive(Deserialize)]
-struct AnsiArgs {
-    color: Value,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Ansi {
-    fn name(&self) -> &str {
-        "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",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Output ANSI codes to change color"
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Change color to green",
-                example: r#"ansi green"#,
-                result: Some(vec![Value::from("\u{1b}[32m")]),
-            },
-            Example {
-                description: "Reset the color",
-                example: r#"ansi reset"#,
-                result: Some(vec![Value::from("\u{1b}[0m")]),
-            },
-            Example {
-                description:
-                    "Use ansi to color text (rb = red bold, gb = green bold, pb = purple bold)",
-                example: r#"echo [$(ansi rb) Hello " " $(ansi gb) Nu " " $(ansi pb) World] | str collect"#,
-                result: Some(vec![Value::from(
-                    "\u{1b}[1;31mHello \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?;
-
-        let color_string = color.as_string()?;
-
-        let ansi_code = str_to_ansi_color(color_string);
-
-        if let Some(output) = ansi_code {
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::string(output).into_value(color.tag()),
-            )))
-        } else {
-            Err(ShellError::labeled_error(
-                "Unknown color",
-                "unknown color",
-                color.tag(),
-            ))
-        }
-    }
-}
-
-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()),
-        "reset" => Some("\x1b[0m".to_owned()),
-        _ => None,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Ansi;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Ansi {})
-    }
-}

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

@@ -1,68 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
-
-#[derive(Deserialize)]
-struct AppendArgs {
-    row: Value,
-}
-
-pub struct Append;
-
-#[async_trait]
-impl WholeStreamCommand for Append {
-    fn name(&self) -> &str {
-        "append"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("append").required(
-            "row value",
-            SyntaxShape::Any,
-            "the value of the row to append to the table",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Append the given row to the table"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let (AppendArgs { row }, input) = args.process(registry).await?;
-
-        let eos = futures::stream::iter(vec![row]);
-
-        Ok(input.chain(eos).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 {})
-    }
-}

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

@@ -1,80 +0,0 @@
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{
-    hir::Block, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
-
-use chrono::prelude::*;
-
-pub struct Benchmark;
-
-#[derive(Deserialize, Debug)]
-struct BenchmarkArgs {
-    block: Block,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Benchmark {
-    fn name(&self) -> &str {
-        "benchmark"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("benchmark").required(
-            "block",
-            SyntaxShape::Block,
-            "the block to run and benchmark",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Runs a block and return the time it took to do execute it. Eg) benchmark { echo $nu.env.NAME }"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        benchmark(args, registry).await
-    }
-}
-
-async fn benchmark(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    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 start_time: chrono::DateTime<_> = Utc::now();
-
-    let result = run_block(
-        &block,
-        &mut context,
-        input,
-        &scope.it,
-        &scope.vars,
-        &scope.env,
-    )
-    .await;
-
-    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),
-            }))
-        }
-        Err(e) => Err(e),
-    };
-    Ok(OutputStream::from(vec![output]))
-}

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

@@ -1,98 +0,0 @@
-use crate::commands::classified::expr::run_expression_block;
-use crate::commands::classified::internal::run_internal_command;
-use crate::context::Context;
-use crate::prelude::*;
-use crate::stream::InputStream;
-use futures::stream::TryStreamExt;
-use nu_errors::ShellError;
-use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
-use nu_protocol::{ReturnSuccess, UntaggedValue, Value};
-use std::sync::atomic::Ordering;
-
-pub(crate) async fn run_block(
-    block: &Block,
-    ctx: &mut Context,
-    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 {
-        match output {
-            Ok(inp) if inp.is_empty() => {}
-            Ok(inp) => {
-                let mut output_stream = inp.to_output_stream();
-
-                loop {
-                    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) {
-                                break;
-                            }
-                        }
-                        Ok(None) => {
-                            if let Some(err) = ctx.get_errors().get(0) {
-                                ctx.clear_errors();
-                                return Err(err.clone());
-                            }
-                            break;
-                        }
-                        Err(e) => return Err(e),
-                    }
-                }
-            }
-            Err(e) => {
-                return Err(e);
-            }
-        }
-        output = run_pipeline(pipeline, ctx, input, it, vars, env).await;
-
-        input = InputStream::empty();
-    }
-
-    output
-}
-
-async fn run_pipeline(
-    commands: &Commands,
-    ctx: &mut Context,
-    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();
-
-        input = match (item, next) {
-            (Some(ClassifiedCommand::Dynamic(_)), _) | (_, Some(ClassifiedCommand::Dynamic(_))) => {
-                return Err(ShellError::unimplemented("Dynamic commands"))
-            }
-
-            (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()),
-
-            (Some(ClassifiedCommand::Internal(left)), _) => {
-                run_internal_command(left, ctx, input, it, vars, env).await?
-            }
-
-            (None, _) => break,
-        };
-    }
-
-    Ok(input)
-}

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

@@ -1,440 +0,0 @@
-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 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 parking_lot::Mutex;
-use serde::{Deserialize, Serialize};
-use std::ops::Deref;
-use std::sync::atomic::AtomicBool;
-
-#[derive(Deserialize, Serialize, 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?;
-
-        Ok(CallInfo {
-            args,
-            name_tag: self.name_tag,
-        })
-    }
-
-    pub fn switch_present(&self, switch: &str) -> bool {
-        self.args.switch_preset(switch)
-    }
-}
-
-#[derive(Getters)]
-#[get = "pub(crate)"]
-pub struct CommandArgs {
-    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
-    pub ctrl_c: Arc<AtomicBool>,
-    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
-    pub shell_manager: ShellManager,
-    pub call_info: UnevaluatedCallInfo,
-    pub input: InputStream,
-    pub raw_input: String,
-}
-
-#[derive(Getters, Clone)]
-#[get = "pub(crate)"]
-pub struct RawCommandArgs {
-    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
-    pub ctrl_c: Arc<AtomicBool>,
-    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
-    pub shell_manager: ShellManager,
-    pub call_info: UnevaluatedCallInfo,
-}
-
-impl RawCommandArgs {
-    pub fn with_input(self, input: impl Into<InputStream>) -> CommandArgs {
-        CommandArgs {
-            host: self.host,
-            ctrl_c: self.ctrl_c,
-            current_errors: self.current_errors,
-            shell_manager: self.shell_manager,
-            call_info: self.call_info,
-            input: input.into(),
-            raw_input: String::default(),
-        }
-    }
-}
-
-impl std::fmt::Debug for CommandArgs {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.call_info.fmt(f)
-    }
-}
-
-impl CommandArgs {
-    pub async fn evaluate_once(
-        self,
-        registry: &CommandRegistry,
-    ) -> 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 = self.call_info.evaluate(registry).await?;
-
-        Ok(EvaluatedWholeStreamCommandArgs::new(
-            host,
-            ctrl_c,
-            shell_manager,
-            call_info,
-            input,
-        ))
-    }
-
-    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?;
-        let call_info = args.call_info.clone();
-
-        let mut deserializer = ConfigDeserializer::from_call_info(call_info);
-
-        Ok((T::deserialize(&mut deserializer)?, args.input))
-    }
-}
-
-pub struct RunnableContext {
-    pub input: InputStream,
-    pub shell_manager: ShellManager,
-    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 name: Tag,
-    pub raw_input: String,
-}
-
-impl RunnableContext {
-    pub fn get_command(&self, name: &str) -> Option<Command> {
-        self.registry.get_command(name)
-    }
-}
-
-pub struct EvaluatedWholeStreamCommandArgs {
-    pub args: EvaluatedCommandArgs,
-    pub input: InputStream,
-}
-
-impl Deref for EvaluatedWholeStreamCommandArgs {
-    type Target = EvaluatedCommandArgs;
-    fn deref(&self) -> &Self::Target {
-        &self.args
-    }
-}
-
-impl EvaluatedWholeStreamCommandArgs {
-    pub fn new(
-        host: Arc<parking_lot::Mutex<dyn Host>>,
-        ctrl_c: Arc<AtomicBool>,
-        shell_manager: ShellManager,
-        call_info: CallInfo,
-        input: impl Into<InputStream>,
-    ) -> EvaluatedWholeStreamCommandArgs {
-        EvaluatedWholeStreamCommandArgs {
-            args: EvaluatedCommandArgs {
-                host,
-                ctrl_c,
-                shell_manager,
-                call_info,
-            },
-            input: input.into(),
-        }
-    }
-
-    pub fn name_tag(&self) -> Tag {
-        self.args.call_info.name_tag.clone()
-    }
-
-    pub fn parts(self) -> (InputStream, EvaluatedArgs) {
-        let EvaluatedWholeStreamCommandArgs { args, input } = self;
-
-        (input, args.call_info.args)
-    }
-
-    pub fn split(self) -> (InputStream, EvaluatedCommandArgs) {
-        let EvaluatedWholeStreamCommandArgs { args, input } = self;
-
-        (input, args)
-    }
-}
-
-#[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 {
-    pub host: Arc<parking_lot::Mutex<dyn Host>>,
-    pub ctrl_c: Arc<AtomicBool>,
-    pub shell_manager: ShellManager,
-    pub call_info: CallInfo,
-}
-
-impl EvaluatedCommandArgs {
-    pub fn nth(&self, pos: usize) -> Option<&Value> {
-        self.call_info.args.nth(pos)
-    }
-
-    /// 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),
-        }
-    }
-
-    pub fn get(&self, name: &str) -> Option<&Value> {
-        self.call_info.args.get(name)
-    }
-
-    pub fn has(&self, name: &str) -> bool {
-        self.call_info.args.has(name)
-    }
-}
-
-pub struct Example {
-    pub example: &'static str,
-    pub description: &'static str,
-    pub result: Option<Vec<Value>>,
-}
-
-#[async_trait]
-pub trait WholeStreamCommand: Send + Sync {
-    fn name(&self) -> &str;
-
-    fn signature(&self) -> Signature {
-        Signature::new(self.name()).desc(self.usage()).filter()
-    }
-
-    fn usage(&self) -> &str;
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError>;
-
-    fn is_binary(&self) -> bool {
-        false
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        Vec::new()
-    }
-}
-
-#[derive(Clone)]
-pub struct Command(Arc<dyn WholeStreamCommand>);
-
-impl PrettyDebugWithSource for Command {
-    fn pretty_debug(&self, source: &str) -> DebugDocBuilder {
-        b::typed(
-            "whole stream command",
-            b::description(self.name())
-                + b::space()
-                + b::equals()
-                + b::space()
-                + self.signature().pretty_debug(source),
-        )
-    }
-}
-
-impl std::fmt::Debug for Command {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Command({})", self.name())
-    }
-}
-
-impl Command {
-    pub fn name(&self) -> &str {
-        self.0.name()
-    }
-
-    pub fn signature(&self) -> Signature {
-        self.0.signature()
-    }
-
-    pub fn usage(&self) -> &str {
-        self.0.usage()
-    }
-
-    pub fn examples(&self) -> Vec<Example> {
-        self.0.examples()
-    }
-
-    pub async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> 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()),
-            ))))
-        } else {
-            self.0.run(args, registry).await
-        }
-    }
-
-    pub fn is_binary(&self) -> bool {
-        self.0.is_binary()
-    }
-
-    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/config/set.rs

@@ -1,67 +0,0 @@
-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;
-
-pub struct SubCommand;
-
-#[derive(Deserialize)]
-pub struct SetArgs {
-    key: Tagged<String>,
-    value: Value,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "config set"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config set")
-            .required("key", SyntaxShape::String, "variable name to set")
-            .required("value", SyntaxShape::Any, "value to use")
-    }
-
-    fn usage(&self) -> &str {
-        "Sets a value in the config"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        set(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Set completion_mode to circular",
-            example: "config set [completion_mode circular]",
-            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?;
-
-    // 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)?;
-
-    result.insert(key.to_string(), value.clone());
-
-    config::write(&result, &None)?;
-
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::Row(result.into()).into_value(&value.tag),
-    )))
-}

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

@@ -1,56 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::prelude::*;
-use futures::stream::StreamExt;
-use nu_errors::ShellError;
-use nu_protocol::{Signature, UntaggedValue, Value};
-
-pub struct Count;
-
-#[async_trait]
-impl WholeStreamCommand for Count {
-    fn name(&self) -> &str {
-        "count"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("count")
-    }
-
-    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;
-
-        Ok(OutputStream::one(
-            UntaggedValue::int(rows.len()).into_value(name),
-        ))
-    }
-
-    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()]),
-        }]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Count;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Count {})
-    }
-}

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/get.rs

@@ -1,263 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use indexmap::set::IndexSet;
-use log::trace;
-use nu_errors::ShellError;
-use nu_protocol::{
-    did_you_mean, ColumnPath, PathMember, Primitive, ReturnSuccess, Signature, SyntaxShape,
-    UnspannedPathMember, UntaggedValue, Value,
-};
-use nu_source::span_for_spanned_list;
-use nu_value_ext::get_data_by_column_path;
-
-pub struct Get;
-
-#[derive(Deserialize)]
-pub struct GetArgs {
-    rest: Vec<ColumnPath>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Get {
-    fn name(&self) -> &str {
-        "get"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("get").rest(
-            SyntaxShape::ColumnPath,
-            "optionally return additional data by path",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Open given cells as text."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        get(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Extract the name of files as a list",
-                example: "ls | get name",
-                result: None,
-            },
-            Example {
-                description: "Extract the cpu list from the sys information",
-                example: "sys | get cpu",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub fn get_column_path(path: &ColumnPath, obj: &Value) -> Result<Value, ShellError> {
-    let fields = path.clone();
-
-    get_data_by_column_path(
-        obj,
-        path,
-        Box::new(move |(obj_source, column_path_tried, error)| {
-            let path_members_span = span_for_spanned_list(fields.members().iter().map(|p| p.span));
-
-            match &obj_source.value {
-                UntaggedValue::Table(rows) => match column_path_tried {
-                    PathMember {
-                        unspanned: UnspannedPathMember::String(column),
-                        ..
-                    } => {
-                        let primary_label = format!("There isn't a column named '{}'", &column);
-
-                        let suggestions: IndexSet<_> = rows
-                            .iter()
-                            .filter_map(|r| did_you_mean(&r, &column_path_tried))
-                            .map(|s| s[0].1.to_owned())
-                            .collect();
-                        let mut existing_columns: IndexSet<_> = IndexSet::default();
-                        let mut names: Vec<String> = vec![];
-
-                        for row in rows {
-                            for field in row.data_descriptors() {
-                                if !existing_columns.contains(&field[..]) {
-                                    existing_columns.insert(field.clone());
-                                    names.push(field);
-                                }
-                            }
-                        }
-
-                        if names.is_empty() {
-                            return ShellError::labeled_error_with_secondary(
-                                "Unknown column",
-                                primary_label,
-                                column_path_tried.span,
-                                "Appears to contain rows. Try indexing instead.",
-                                column_path_tried.span.since(path_members_span),
-                            );
-                        } else {
-                            return ShellError::labeled_error_with_secondary(
-                                "Unknown column",
-                                primary_label,
-                                column_path_tried.span,
-                                format!(
-                                    "Perhaps you meant '{}'? Columns available: {}",
-                                    suggestions
-                                        .iter()
-                                        .map(|x| x.to_owned())
-                                        .collect::<Vec<String>>()
-                                        .join(","),
-                                    names.join(",")
-                                ),
-                                column_path_tried.span.since(path_members_span),
-                            );
-                        };
-                    }
-                    PathMember {
-                        unspanned: UnspannedPathMember::Int(idx),
-                        ..
-                    } => {
-                        let total = rows.len();
-
-                        let secondary_label = if total == 1 {
-                            "The table only has 1 row".to_owned()
-                        } else {
-                            format!("The table only has {} rows (0 to {})", total, total - 1)
-                        };
-
-                        return ShellError::labeled_error_with_secondary(
-                            "Row not found",
-                            format!("There isn't a row indexed at {}", idx),
-                            column_path_tried.span,
-                            secondary_label,
-                            column_path_tried.span.since(path_members_span),
-                        );
-                    }
-                },
-                UntaggedValue::Row(columns) => match column_path_tried {
-                    PathMember {
-                        unspanned: UnspannedPathMember::String(column),
-                        ..
-                    } => {
-                        let primary_label = format!("There isn't a column named '{}'", &column);
-
-                        if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried) {
-                            return ShellError::labeled_error_with_secondary(
-                                "Unknown column",
-                                primary_label,
-                                column_path_tried.span,
-                                format!(
-                                    "Perhaps you meant '{}'? Columns available: {}",
-                                    suggestions[0].1,
-                                    &obj_source.data_descriptors().join(",")
-                                ),
-                                column_path_tried.span.since(path_members_span),
-                            );
-                        }
-                    }
-                    PathMember {
-                        unspanned: UnspannedPathMember::Int(idx),
-                        ..
-                    } => {
-                        return ShellError::labeled_error_with_secondary(
-                            "No rows available",
-                            format!("A row at '{}' can't be indexed.", &idx),
-                            column_path_tried.span,
-                            format!(
-                                "Appears to contain columns. Columns available: {}",
-                                columns.keys().join(",")
-                            ),
-                            column_path_tried.span.since(path_members_span),
-                        )
-                    }
-                },
-                _ => {}
-            }
-
-            if let Some(suggestions) = did_you_mean(&obj_source, column_path_tried) {
-                return ShellError::labeled_error(
-                    "Unknown column",
-                    format!("did you mean '{}'?", suggestions[0].1),
-                    column_path_tried.span.since(path_members_span),
-                );
-            }
-
-            error
-        }),
-    )
-}
-
-pub async fn get(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (GetArgs { rest: mut fields }, mut input) = args.process(&registry).await?;
-    if fields.is_empty() {
-        let vec = input.drain_vec().await;
-
-        let descs = nu_protocol::merge_descriptors(&vec);
-
-        Ok(futures::stream::iter(descs.into_iter().map(ReturnSuccess::value)).to_output_stream())
-    } else {
-        let member = fields.remove(0);
-        trace!("get {:?} {:?}", member, fields);
-
-        Ok(input
-            .map(move |item| {
-                let member = vec![member.clone()];
-
-                let column_paths = vec![&member, &fields]
-                    .into_iter()
-                    .flatten()
-                    .collect::<Vec<&ColumnPath>>();
-
-                let mut output = vec![];
-                for path in column_paths {
-                    let res = get_column_path(&path, &item);
-
-                    match res {
-                        Ok(got) => match got {
-                            Value {
-                                value: UntaggedValue::Table(rows),
-                                ..
-                            } => {
-                                for item in rows {
-                                    output.push(ReturnSuccess::value(item.clone()));
-                                }
-                            }
-                            Value {
-                                value: UntaggedValue::Primitive(Primitive::Nothing),
-                                ..
-                            } => {}
-                            other => output.push(ReturnSuccess::value(other.clone())),
-                        },
-                        Err(reason) => output.push(ReturnSuccess::value(
-                            UntaggedValue::Error(reason).into_untagged_value(),
-                        )),
-                    }
-                }
-
-                futures::stream::iter(output)
-            })
-            .flatten()
-            .to_output_stream())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Get;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Get {})
-    }
-}

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

@@ -1,169 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::data::command_dict;
-use crate::documentation::{generate_docs, get_documentation, DocumentationConfig};
-
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue};
-use nu_source::{SpannedItem, Tagged};
-use nu_value_ext::get_data_by_key;
-
-pub struct Help;
-
-#[derive(Deserialize)]
-pub struct HelpArgs {
-    rest: Vec<Tagged<String>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Help {
-    fn name(&self) -> &str {
-        "help"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("help").rest(SyntaxShape::String, "the name of command to get help on")
-    }
-
-    fn usage(&self) -> &str {
-        "Display help information about commands."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        help(args, registry).await
-    }
-}
-
-async fn help(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let name = args.call_info.name_tag.clone();
-    let (HelpArgs { rest }, ..) = args.process(&registry).await?;
-
-    if !rest.is_empty() {
-        if rest[0].item == "commands" {
-            let mut sorted_names = registry.names();
-            sorted_names.sort();
-
-            Ok(
-                futures::stream::iter(sorted_names.into_iter().filter_map(move |cmd| {
-                    // If it's a subcommand, don't list it during the commands list
-                    if cmd.contains(' ') {
-                        return None;
-                    }
-                    let mut short_desc = TaggedDictBuilder::new(name.clone());
-                    let document_tag = rest[0].tag.clone();
-                    let value = command_dict(
-                        match registry.get_command(&cmd).ok_or_else(|| {
-                            ShellError::labeled_error(
-                                format!("Could not load {}", cmd),
-                                "could not load command",
-                                document_tag,
-                            )
-                        }) {
-                            Ok(ok) => ok,
-                            Err(err) => return Some(Err(err)),
-                        },
-                        name.clone(),
-                    );
-
-                    short_desc.insert_untagged("name", cmd);
-                    short_desc.insert_untagged(
-                        "description",
-                        match match get_data_by_key(&value, "usage".spanned_unknown()).ok_or_else(
-                            || {
-                                ShellError::labeled_error(
-                                    "Expected a usage key",
-                                    "expected a 'usage' key",
-                                    &value.tag,
-                                )
-                            },
-                        ) {
-                            Ok(ok) => ok,
-                            Err(err) => return Some(Err(err)),
-                        }
-                        .as_string()
-                        {
-                            Ok(ok) => ok,
-                            Err(err) => return Some(Err(err)),
-                        },
-                    );
-
-                    Some(ReturnSuccess::value(short_desc.into_value()))
-                }))
-                .to_output_stream(),
-            )
-        } else if rest[0].item == "generate_docs" {
-            Ok(OutputStream::one(ReturnSuccess::value(generate_docs(
-                &registry,
-            ))))
-        } else if rest.len() == 2 {
-            // Check for a subcommand
-            let command_name = format!("{} {}", rest[0].item, rest[1].item);
-            if let Some(command) = registry.get_command(&command_name) {
-                Ok(OutputStream::one(ReturnSuccess::value(
-                    UntaggedValue::string(get_help(command.stream_command(), &registry))
-                        .into_value(Tag::unknown()),
-                )))
-            } else {
-                Ok(OutputStream::empty())
-            }
-        } else if let Some(command) = registry.get_command(&rest[0].item) {
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::string(get_help(command.stream_command(), &registry))
-                    .into_value(Tag::unknown()),
-            )))
-        } else {
-            Err(ShellError::labeled_error(
-                "Can't find command (use 'help commands' for full list)",
-                "can't find command",
-                rest[0].tag.span,
-            ))
-        }
-    } else {
-        let msg = r#"Welcome to Nushell.
-
-Here are some tips to help you get started.
-  * help commands - list all available commands
-  * help <command name> - display help about a particular command
-
-Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character.
-Each stage in the pipeline works together to load, parse, and display information to you.
-
-[Examples]
-
-List the files in the current directory, sorted by size:
-    ls | sort-by size
-
-Get information about the current system:
-    sys | get host
-
-Get the processes on your system actively using CPU:
-    ps | where cpu > 0
-
-You can also learn more at https://www.nushell.sh/book/"#;
-
-        Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(msg).into_value(Tag::unknown()),
-        )))
-    }
-}
-
-pub fn get_help(cmd: &dyn WholeStreamCommand, registry: &CommandRegistry) -> String {
-    get_documentation(cmd, registry, &DocumentationConfig::default())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Help;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Help {})
-    }
-}

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

@@ -1,266 +0,0 @@
-use crate::commands::group_by::group;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use crate::utils::data_processing::{columns_sorted, evaluate, map_max, reduce, t_sort};
-use nu_errors::ShellError;
-use nu_protocol::{
-    Primitive, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
-};
-use nu_source::Tagged;
-use num_traits::{ToPrimitive, Zero};
-
-pub struct Histogram;
-
-#[derive(Deserialize)]
-pub struct HistogramArgs {
-    column_name: Tagged<String>,
-    rest: Vec<Tagged<String>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Histogram {
-    fn name(&self) -> &str {
-        "histogram"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("histogram")
-            .required(
-                "column_name",
-                SyntaxShape::String,
-                "the name of the column to graph by",
-            )
-            .rest(
-                SyntaxShape::String,
-                "column name to give the histogram's frequency column",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Creates a new table with a histogram based on the column name passed in."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        histogram(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Get a histogram for the types of files",
-                example: "ls | histogram type",
-                result: None,
-            },
-            Example {
-                description:
-                    "Get a histogram for the types of files, with frequency column named count",
-                example: "ls | histogram type count",
-                result: None,
-            },
-            Example {
-                description: "Get a histogram for a list of numbers",
-                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub async fn histogram(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let name = args.call_info.name_tag.clone();
-
-    let (HistogramArgs { column_name, rest }, input) = args.process(&registry).await?;
-    let values: Vec<Value> = input.collect().await;
-    let values = UntaggedValue::table(&values).into_value(&name);
-
-    let groups = group(&Some(column_name.clone()), &values, &name)?;
-    let group_labels = columns_sorted(Some(column_name.clone()), &groups, &name);
-    let sorted = t_sort(Some(column_name.clone()), None, &groups, &name)?;
-    let evaled = evaluate(&sorted, None, &name)?;
-    let reduced = reduce(&evaled, None, &name)?;
-    let maxima = map_max(&reduced, None, &name)?;
-    let percents = percentages(&reduced, maxima, &name)?;
-
-    match percents {
-        Value {
-            value: UntaggedValue::Table(datasets),
-            ..
-        } => {
-            let mut idx = 0;
-
-            let column_names_supplied: Vec<_> = rest.iter().map(|f| f.item.clone()).collect();
-
-            let frequency_column_name = if column_names_supplied.is_empty() {
-                "frequency".to_string()
-            } else {
-                column_names_supplied[0].clone()
-            };
-
-            let column = (*column_name).clone();
-
-            let count_column_name = "count".to_string();
-            let count_shell_error = ShellError::labeled_error(
-                "Unable to load group count",
-                "unabled to load group count",
-                &name,
-            );
-            let mut count_values: Vec<u64> = Vec::new();
-
-            for table_entry in reduced.table_entries() {
-                match table_entry {
-                    Value {
-                        value: UntaggedValue::Table(list),
-                        ..
-                    } => {
-                        for i in list {
-                            if let Ok(count) = i.value.clone().into_value(&name).as_u64() {
-                                count_values.push(count);
-                            } else {
-                                return Err(count_shell_error);
-                            }
-                        }
-                    }
-                    _ => {
-                        return Err(count_shell_error);
-                    }
-                }
-            }
-
-            if let Value {
-                value: UntaggedValue::Table(start),
-                ..
-            } = datasets.get(0).ok_or_else(|| {
-                ShellError::labeled_error(
-                    "Unable to load dataset",
-                    "unabled to load dataset",
-                    &name,
-                )
-            })? {
-                let start = start.clone();
-                Ok(
-                    futures::stream::iter(start.into_iter().map(move |percentage| {
-                        let mut fact = TaggedDictBuilder::new(&name);
-                        let value: Tagged<String> = group_labels
-                            .get(idx)
-                            .ok_or_else(|| {
-                                ShellError::labeled_error(
-                                    "Unable to load group labels",
-                                    "unabled to load group labels",
-                                    &name,
-                                )
-                            })?
-                            .clone();
-                        fact.insert_value(
-                            &column,
-                            UntaggedValue::string(value.item).into_value(value.tag),
-                        );
-
-                        fact.insert_untagged(
-                            &count_column_name,
-                            UntaggedValue::int(count_values[idx]),
-                        );
-
-                        if let Value {
-                            value: UntaggedValue::Primitive(Primitive::Int(ref num)),
-                            ref tag,
-                        } = percentage
-                        {
-                            let string = std::iter::repeat("*")
-                                .take(num.to_i32().ok_or_else(|| {
-                                    ShellError::labeled_error(
-                                        "Expected a number",
-                                        "expected a number",
-                                        tag,
-                                    )
-                                })? as usize)
-                                .collect::<String>();
-                            fact.insert_untagged(
-                                &frequency_column_name,
-                                UntaggedValue::string(string),
-                            );
-                        }
-
-                        idx += 1;
-
-                        ReturnSuccess::value(fact.into_value())
-                    }))
-                    .to_output_stream(),
-                )
-            } else {
-                Ok(OutputStream::empty())
-            }
-        }
-        _ => Ok(OutputStream::empty()),
-    }
-}
-
-fn percentages(values: &Value, max: Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
-    let tag = tag.into();
-
-    let results: Value = match values {
-        Value {
-            value: UntaggedValue::Table(datasets),
-            ..
-        } => {
-            let datasets: Vec<_> = datasets
-                .iter()
-                .map(|subsets| match subsets {
-                    Value {
-                        value: UntaggedValue::Table(data),
-                        ..
-                    } => {
-                        let data = data
-                            .iter()
-                            .map(|d| match d {
-                                Value {
-                                    value: UntaggedValue::Primitive(Primitive::Int(n)),
-                                    ..
-                                } => {
-                                    let max = match &max {
-                                        Value {
-                                            value: UntaggedValue::Primitive(Primitive::Int(maxima)),
-                                            ..
-                                        } => maxima.clone(),
-                                        _ => Zero::zero(),
-                                    };
-
-                                    let n = (n * 100) / max;
-
-                                    UntaggedValue::int(n).into_value(&tag)
-                                }
-                                _ => UntaggedValue::int(0).into_value(&tag),
-                            })
-                            .collect::<Vec<_>>();
-                        UntaggedValue::Table(data).into_value(&tag)
-                    }
-                    _ => UntaggedValue::Table(vec![]).into_value(&tag),
-                })
-                .collect();
-
-            UntaggedValue::Table(datasets).into_value(&tag)
-        }
-        other => other.clone(),
-    };
-
-    Ok(results)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Histogram;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Histogram {})
-    }
-}

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

@@ -1,67 +0,0 @@
-use crate::cli::History as HistoryFile;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-use std::fs::File;
-use std::io::{BufRead, BufReader};
-
-pub struct History;
-
-#[async_trait]
-impl WholeStreamCommand for History {
-    fn name(&self) -> &str {
-        "history"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("history")
-    }
-
-    fn usage(&self) -> &str {
-        "Display command history."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        history(args, registry)
-    }
-}
-
-fn history(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let tag = args.call_info.name_tag;
-    let history_path = HistoryFile::path();
-    let file = File::open(history_path);
-    if let Ok(file) = file {
-        let reader = BufReader::new(file);
-        let output = reader.lines().filter_map(move |line| match line {
-            Ok(line) => Some(ReturnSuccess::value(
-                UntaggedValue::string(line).into_value(tag.clone()),
-            )),
-            Err(_) => None,
-        });
-
-        Ok(futures::stream::iter(output).to_output_stream())
-    } else {
-        Err(ShellError::labeled_error(
-            "Could not open history",
-            "history file could not be opened",
-            tag,
-        ))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::History;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(History {})
-    }
-}

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

@@ -1,188 +0,0 @@
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::evaluate::evaluate_baseline_expr;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{hir::Block, hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue};
-
-pub struct If;
-
-#[derive(Deserialize)]
-pub struct IfArgs {
-    condition: Block,
-    then_case: Block,
-    else_case: Block,
-}
-
-#[async_trait]
-impl WholeStreamCommand for If {
-    fn name(&self) -> &str {
-        "if"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("if")
-            .required(
-                "condition",
-                SyntaxShape::Math,
-                "the condition that must match",
-            )
-            .required(
-                "then_case",
-                SyntaxShape::Block,
-                "block to run if condition is true",
-            )
-            .required(
-                "else_case",
-                SyntaxShape::Block,
-                "block to run if condition is false",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Run blocks if a condition is true or false."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        if_command(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Run a block if a condition is true",
-                example: "echo 10 | if $it > 5 { echo 'greater than 5' } { echo 'less than or equal to 5' }",
-                result: Some(vec![UntaggedValue::string("greater than 5").into()]),
-            },
-            Example {
-                description: "Run a block if a condition is false",
-                example: "echo 1 | if $it > 5 { echo 'greater than 5' } { echo 'less than or equal to 5' }",
-                result: Some(vec![UntaggedValue::string("less than or equal to 5").into()]),
-            },
-        ]
-    }
-}
-async fn if_command(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = Arc::new(registry.clone());
-    let scope = Arc::new(raw_args.call_info.scope.clone());
-    let tag = raw_args.call_info.name_tag.clone();
-    let context = Arc::new(Context::from_raw(&raw_args, &registry));
-
-    let (
-        IfArgs {
-            condition,
-            then_case,
-            else_case,
-        },
-        input,
-    ) = raw_args.process(&registry).await?;
-    let condition = {
-        if condition.block.len() != 1 {
-            return Err(ShellError::labeled_error(
-                "Expected a condition",
-                "expected a condition",
-                tag,
-            ));
-        }
-        match condition.block[0].list.get(0) {
-            Some(item) => match item {
-                ClassifiedCommand::Expr(expr) => expr.clone(),
-                _ => {
-                    return Err(ShellError::labeled_error(
-                        "Expected a condition",
-                        "expected a condition",
-                        tag,
-                    ));
-                }
-            },
-            None => {
-                return Err(ShellError::labeled_error(
-                    "Expected a condition",
-                    "expected a condition",
-                    tag,
-                ));
-            }
-        }
-    };
-
-    Ok(input
-        .then(move |input| {
-            let condition = condition.clone();
-            let then_case = then_case.clone();
-            let else_case = else_case.clone();
-            let registry = registry.clone();
-            let scope = scope.clone();
-            let mut context = context.clone();
-
-            async move {
-                //FIXME: should we use the scope that's brought in as well?
-                let condition =
-                    evaluate_baseline_expr(&condition, &*registry, &input, &scope.vars, &scope.env)
-                        .await;
-
-                match condition {
-                    Ok(condition) => match condition.as_bool() {
-                        Ok(b) => {
-                            if b {
-                                match run_block(
-                                    &then_case,
-                                    Arc::make_mut(&mut context),
-                                    InputStream::empty(),
-                                    &input,
-                                    &scope.vars,
-                                    &scope.env,
-                                )
-                                .await
-                                {
-                                    Ok(stream) => stream.to_output_stream(),
-                                    Err(e) => futures::stream::iter(vec![Err(e)].into_iter())
-                                        .to_output_stream(),
-                                }
-                            } else {
-                                match run_block(
-                                    &else_case,
-                                    Arc::make_mut(&mut context),
-                                    InputStream::empty(),
-                                    &input,
-                                    &scope.vars,
-                                    &scope.env,
-                                )
-                                .await
-                                {
-                                    Ok(stream) => stream.to_output_stream(),
-                                    Err(e) => futures::stream::iter(vec![Err(e)].into_iter())
-                                        .to_output_stream(),
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            futures::stream::iter(vec![Err(e)].into_iter()).to_output_stream()
-                        }
-                    },
-                    Err(e) => futures::stream::iter(vec![Err(e)].into_iter()).to_output_stream(),
-                }
-            }
-        })
-        .flatten()
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::If;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(If {})
-    }
-}

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

@@ -1,82 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_value_ext::ValueExt;
-
-pub struct Insert;
-
-#[derive(Deserialize)]
-pub struct InsertArgs {
-    column: ColumnPath,
-    value: Value,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Insert {
-    fn name(&self) -> &str {
-        "insert"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("insert")
-            .required(
-                "column",
-                SyntaxShape::ColumnPath,
-                "the column name to insert",
-            )
-            .required(
-                "value",
-                SyntaxShape::String,
-                "the value to give the cell(s)",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Insert a new column with a given value."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        insert(args, registry).await
-    }
-}
-
-async fn insert(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    let (InsertArgs { column, value }, input) = args.process(&registry).await?;
-
-    Ok(input
-        .map(move |row| match row {
-            Value {
-                value: UntaggedValue::Row(_),
-                ..
-            } => Ok(ReturnSuccess::Value(
-                row.insert_data_at_column_path(&column, value.clone())?,
-            )),
-
-            Value { tag, .. } => Err(ShellError::labeled_error(
-                "Unrecognized type in stream",
-                "original value",
-                tag,
-            )),
-        })
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Insert;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Insert {})
-    }
-}

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

@@ -1,211 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
-use nu_value_ext::ValueExt;
-
-enum IsEmptyFor {
-    Value,
-    RowWithFieldsAndFallback(Vec<Tagged<ColumnPath>>, Value),
-    RowWithField(Tagged<ColumnPath>),
-    RowWithFieldAndFallback(Box<Tagged<ColumnPath>>, Value),
-}
-
-pub struct IsEmpty;
-
-#[derive(Deserialize)]
-pub struct IsEmptyArgs {
-    rest: Vec<Value>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for IsEmpty {
-    fn name(&self) -> &str {
-        "empty?"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("empty?").rest(
-            SyntaxShape::Any,
-            "the names of the columns to check emptiness followed by the replacement value.",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Checks emptiness. The last value is the replacement value for any empty column(s) given to check against the table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        is_empty(args, registry).await
-    }
-}
-
-async fn is_empty(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (IsEmptyArgs { rest }, input) = args.process(&registry).await?;
-
-    Ok(input
-        .map(move |value| {
-            let value_tag = value.tag();
-
-            let action = if rest.len() <= 2 {
-                let field = rest.get(0);
-                let replacement_if_true = rest.get(1);
-
-                match (field, replacement_if_true) {
-                    (Some(field), Some(replacement_if_true)) => {
-                        IsEmptyFor::RowWithFieldAndFallback(
-                            Box::new(field.as_column_path()?),
-                            replacement_if_true.clone(),
-                        )
-                    }
-                    (Some(field), None) => IsEmptyFor::RowWithField(field.as_column_path()?),
-                    (_, _) => IsEmptyFor::Value,
-                }
-            } else {
-                // let no_args = vec![];
-                let mut arguments = rest.iter().rev();
-                let replacement_if_true = match arguments.next() {
-                    Some(arg) => arg.clone(),
-                    None => UntaggedValue::boolean(value.is_empty()).into_value(&value_tag),
-                };
-
-                IsEmptyFor::RowWithFieldsAndFallback(
-                    arguments
-                        .map(|a| a.as_column_path())
-                        .filter_map(Result::ok)
-                        .collect(),
-                    replacement_if_true,
-                )
-            };
-
-            match action {
-                IsEmptyFor::Value => Ok(ReturnSuccess::Value(
-                    UntaggedValue::boolean(value.is_empty()).into_value(value_tag),
-                )),
-                IsEmptyFor::RowWithFieldsAndFallback(fields, default) => {
-                    let mut out = value;
-
-                    for field in fields.iter() {
-                        let val = crate::commands::get::get_column_path(&field, &out)?;
-
-                        let emptiness_value = match out {
-                            obj
-                            @
-                            Value {
-                                value: UntaggedValue::Row(_),
-                                ..
-                            } => {
-                                if val.is_empty() {
-                                    match obj.replace_data_at_column_path(&field, default.clone()) {
-                                        Some(v) => Ok(v),
-                                        None => Err(ShellError::labeled_error(
-                                            "empty? could not find place to check emptiness",
-                                            "column name",
-                                            &field.tag,
-                                        )),
-                                    }
-                                } else {
-                                    Ok(obj)
-                                }
-                            }
-                            _ => Err(ShellError::labeled_error(
-                                "Unrecognized type in stream",
-                                "original value",
-                                &value_tag,
-                            )),
-                        };
-
-                        out = emptiness_value?;
-                    }
-
-                    Ok(ReturnSuccess::Value(out))
-                }
-                IsEmptyFor::RowWithField(field) => {
-                    let val = crate::commands::get::get_column_path(&field, &value)?;
-
-                    match &value {
-                        obj
-                        @
-                        Value {
-                            value: UntaggedValue::Row(_),
-                            ..
-                        } => {
-                            if val.is_empty() {
-                                match obj.replace_data_at_column_path(
-                                    &field,
-                                    UntaggedValue::boolean(true).into_value(&value_tag),
-                                ) {
-                                    Some(v) => Ok(ReturnSuccess::Value(v)),
-                                    None => Err(ShellError::labeled_error(
-                                        "empty? could not find place to check emptiness",
-                                        "column name",
-                                        &field.tag,
-                                    )),
-                                }
-                            } else {
-                                Ok(ReturnSuccess::Value(value))
-                            }
-                        }
-                        _ => Err(ShellError::labeled_error(
-                            "Unrecognized type in stream",
-                            "original value",
-                            &value_tag,
-                        )),
-                    }
-                }
-                IsEmptyFor::RowWithFieldAndFallback(field, default) => {
-                    let val = crate::commands::get::get_column_path(&field, &value)?;
-
-                    match &value {
-                        obj
-                        @
-                        Value {
-                            value: UntaggedValue::Row(_),
-                            ..
-                        } => {
-                            if val.is_empty() {
-                                match obj.replace_data_at_column_path(&field, default) {
-                                    Some(v) => Ok(ReturnSuccess::Value(v)),
-                                    None => Err(ShellError::labeled_error(
-                                        "empty? could not find place to check emptiness",
-                                        "column name",
-                                        &field.tag,
-                                    )),
-                                }
-                            } else {
-                                Ok(ReturnSuccess::Value(value))
-                            }
-                        }
-                        _ => Err(ShellError::labeled_error(
-                            "Unrecognized type in stream",
-                            "original value",
-                            &value_tag,
-                        )),
-                    }
-                }
-            }
-        })
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::IsEmpty;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(IsEmpty {})
-    }
-}

crates/nu-cli/src/commands/math/avg.rs

@@ -1,130 +0,0 @@
-use crate::commands::math::utils::run_with_function;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use crate::utils::data_processing::{reducer_for, Reduce};
-use bigdecimal::{FromPrimitive, Zero};
-use nu_errors::ShellError;
-use nu_protocol::{
-    hir::{convert_number_to_u64, Number, Operator},
-    Primitive, Signature, UntaggedValue, Value,
-};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "math avg"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("math avg")
-    }
-
-    fn usage(&self) -> &str {
-        "Finds the average of a list of numbers or tables"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        run_with_function(
-            RunnableContext {
-                input: args.input,
-                registry: registry.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,
-            },
-            average,
-        )
-        .await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get the average of a list of numbers",
-            example: "echo [-50 100.0 25] | math avg",
-            result: Some(vec![UntaggedValue::decimal(25).into()]),
-        }]
-    }
-}
-
-pub fn average(values: &[Value], name: &Tag) -> Result<Value, ShellError> {
-    let sum = reducer_for(Reduce::Summation);
-
-    let number = BigDecimal::from_usize(values.len()).ok_or_else(|| {
-        ShellError::labeled_error(
-            "could not convert to big decimal",
-            "could not convert to big decimal",
-            &name.span,
-        )
-    })?;
-
-    let total_rows = UntaggedValue::decimal(number);
-    let total = sum(Value::zero(), values.to_vec())?;
-
-    match total {
-        Value {
-            value: UntaggedValue::Primitive(Primitive::Filesize(num)),
-            ..
-        } => {
-            let left = UntaggedValue::from(Primitive::Int(num.into()));
-            let result = crate::data::value::compute_values(Operator::Divide, &left, &total_rows);
-
-            match result {
-                Ok(UntaggedValue::Primitive(Primitive::Decimal(result))) => {
-                    let number = Number::Decimal(result);
-                    let number = convert_number_to_u64(&number);
-                    Ok(UntaggedValue::filesize(number).into_value(name))
-                }
-                Ok(_) => Err(ShellError::labeled_error(
-                    "could not calculate average of non-integer or unrelated types",
-                    "source",
-                    name,
-                )),
-                Err((left_type, right_type)) => Err(ShellError::coerce_error(
-                    left_type.spanned(name.span),
-                    right_type.spanned(name.span),
-                )),
-            }
-        }
-        Value {
-            value: UntaggedValue::Primitive(other),
-            ..
-        } => {
-            let left = UntaggedValue::from(other);
-            let result = crate::data::value::compute_values(Operator::Divide, &left, &total_rows);
-
-            match result {
-                Ok(value) => Ok(value.into_value(name)),
-                Err((left_type, right_type)) => Err(ShellError::coerce_error(
-                    left_type.spanned(name.span),
-                    right_type.spanned(name.span),
-                )),
-            }
-        }
-        _ => Err(ShellError::labeled_error(
-            "could not calculate average of non-integer or unrelated types",
-            "source",
-            name,
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-cli/src/commands/math/eval.rs

@@ -1,107 +0,0 @@
-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 SubCommand;
-
-#[derive(Deserialize)]
-pub struct SubCommandArgs {
-    expression: Option<Tagged<String>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "math eval"
-    }
-
-    fn usage(&self) -> &str {
-        "Evaluate a math expression into a number"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("math eval").desc(self.usage()).optional(
-            "math expression",
-            SyntaxShape::String,
-            "the math expression to evaluate",
-        )
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        eval(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Evalulate math in the pipeline",
-            example: "echo '10 / 4' | math eval",
-            result: Some(vec![UntaggedValue::decimal(2.5).into()]),
-        }]
-    }
-}
-
-pub async fn eval(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name = args.call_info.name_tag.span;
-    let (SubCommandArgs { expression }, input) = args.process(registry).await?;
-
-    Ok(input
-        .map(move |x| {
-            if let Some(Tagged {
-                tag,
-                item: expression,
-            }) = &expression
-            {
-                UntaggedValue::string(expression).into_value(tag)
-            } else {
-                x
-            }
-        })
-        .map(move |input| {
-            if let Ok(string) = input.as_string() {
-                match parse(&string, &input.tag) {
-                    Ok(value) => ReturnSuccess::value(value),
-                    Err(err) => Err(ShellError::labeled_error(
-                        "Math evaluation error",
-                        err,
-                        &input.tag.span,
-                    )),
-                }
-            } else {
-                Err(ShellError::labeled_error(
-                    "Expected a string from pipeline",
-                    "requires string input",
-                    name,
-                ))
-            }
-        })
-        .to_output_stream())
-}
-
-pub fn parse<T: Into<Tag>>(math_expression: &str, tag: T) -> Result<Value, String> {
-    match meval::eval_str(math_expression) {
-        Ok(num) if num.is_infinite() || num.is_nan() => Err("cannot represent result".to_string()),
-        Ok(num) => Ok(UntaggedValue::from(Primitive::from(num)).into_value(tag)),
-        Err(error) => Err(error.to_string().to_lowercase()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-cli/src/commands/math/stddev.rs

@@ -1,87 +0,0 @@
-use super::variance::variance;
-use crate::commands::math::utils::run_with_function;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, Signature, UntaggedValue, Value};
-use std::str::FromStr;
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "math stddev"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("math stddev")
-    }
-
-    fn usage(&self) -> &str {
-        "Finds the stddev of a list of numbers or tables"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        run_with_function(
-            RunnableContext {
-                input: args.input,
-                registry: registry.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,
-            },
-            stddev,
-        )
-        .await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get the stddev of a list of numbers",
-            example: "echo [1 2 3 4 5] | math stddev",
-            result: Some(vec![UntaggedValue::decimal(BigDecimal::from_str("1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573").expect("Could not convert to decimal from string")).into()]),
-        }]
-    }
-}
-
-pub fn stddev(values: &[Value], name: &Tag) -> Result<Value, ShellError> {
-    let variance = variance(values, name)?.as_primitive()?;
-    let sqrt_var = match variance {
-        Primitive::Decimal(var) => var.sqrt(),
-        _ => {
-            return Err(ShellError::labeled_error(
-                "Could not take square root of variance",
-                "error occured here",
-                name.span,
-            ))
-        }
-    };
-    match sqrt_var {
-        Some(stddev) => Ok(UntaggedValue::from(Primitive::Decimal(stddev)).into_value(name)),
-        None => Err(ShellError::labeled_error(
-            "Could not calculate stddev",
-            "error occured here",
-            name.span,
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-cli/src/commands/math/sum.rs

@@ -1,106 +0,0 @@
-use crate::commands::math::utils::run_with_function;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use crate::utils::data_processing::{reducer_for, Reduce};
-use nu_errors::ShellError;
-use nu_protocol::{Dictionary, Signature, UntaggedValue, Value};
-use num_traits::identities::Zero;
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "math sum"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("math sum")
-    }
-
-    fn usage(&self) -> &str {
-        "Finds the sum of a list of numbers or tables"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        run_with_function(
-            RunnableContext {
-                input: args.input,
-                registry: registry.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,
-            },
-            summation,
-        )
-        .await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Sum a list of numbers",
-                example: "echo [1 2 3] | math sum",
-                result: Some(vec![UntaggedValue::int(6).into()]),
-            },
-            Example {
-                description: "Get the disk usage for the current directory",
-                example: "ls --all --du | get size | math sum",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub fn summation(values: &[Value], name: &Tag) -> Result<Value, ShellError> {
-    let sum = reducer_for(Reduce::Summation);
-
-    if values.iter().all(|v| v.is_primitive()) {
-        Ok(sum(Value::zero(), values.to_vec())?)
-    } else {
-        let mut column_values = IndexMap::new();
-
-        for value in values {
-            if let UntaggedValue::Row(row_dict) = value.value.clone() {
-                for (key, value) in row_dict.entries.iter() {
-                    column_values
-                        .entry(key.clone())
-                        .and_modify(|v: &mut Vec<Value>| v.push(value.clone()))
-                        .or_insert(vec![value.clone()]);
-                }
-            };
-        }
-
-        let mut column_totals = IndexMap::new();
-
-        for (col_name, col_vals) in column_values {
-            let sum = sum(Value::zero(), col_vals)?;
-
-            column_totals.insert(col_name, sum);
-        }
-
-        Ok(UntaggedValue::Row(Dictionary {
-            entries: column_totals,
-        })
-        .into_value(name))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-cli/src/commands/math/variance.rs

@@ -1,162 +0,0 @@
-use crate::commands::math::utils::run_with_function;
-use crate::commands::WholeStreamCommand;
-use crate::data::value::compute_values;
-use crate::prelude::*;
-use bigdecimal::{FromPrimitive, Zero};
-use nu_errors::ShellError;
-use nu_protocol::{hir::Operator, Primitive, Signature, UntaggedValue, Value};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "math variance"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("math variance")
-    }
-
-    fn usage(&self) -> &str {
-        "Finds the variance of a list of numbers or tables"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        run_with_function(
-            RunnableContext {
-                input: args.input,
-                registry: registry.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,
-            },
-            variance,
-        )
-        .await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get the variance of a list of numbers",
-            example: "echo [1 2 3 4 5] | math variance",
-            result: Some(vec![UntaggedValue::decimal(2).into()]),
-        }]
-    }
-}
-
-fn sum_of_squares(values: &[Value], name: &Tag) -> Result<Value, ShellError> {
-    let n = BigDecimal::from_usize(values.len()).ok_or_else(|| {
-        ShellError::labeled_error(
-            "could not convert to big decimal",
-            "could not convert to big decimal",
-            &name.span,
-        )
-    })?;
-    let mut sum_x = Value::zero();
-    let mut sum_x2 = Value::zero();
-    for value in values {
-        let v = match value {
-            Value {
-                value: UntaggedValue::Primitive(Primitive::Filesize(num)),
-                ..
-            } => {
-                UntaggedValue::from(Primitive::Int(num.clone().into()))
-            },
-            Value {
-                value: UntaggedValue::Primitive(num),
-                ..
-            } => {
-                UntaggedValue::from(num.clone())
-            },
-            _ => {
-                return Err(ShellError::labeled_error(
-                    "Attempted to compute the sum of squared values of a value that cannot be summed or squared.",
-                    "value appears here",
-                    value.tag.span,
-                ))
-            }
-        };
-        let v_squared = compute_values(Operator::Multiply, &v, &v);
-        match v_squared {
-            // X^2
-            Ok(x2) => sum_x2 = sum_x2 + x2.into_untagged_value(),
-            Err((left_type, right_type)) => {
-                return Err(ShellError::coerce_error(
-                    left_type.spanned(value.tag.span),
-                    right_type.spanned(value.tag.span),
-                ))
-            }
-        };
-        sum_x = sum_x + v.into_untagged_value();
-    }
-
-    let sum_x_squared = match compute_values(Operator::Multiply, &sum_x, &sum_x) {
-        Ok(v) => v.into_untagged_value(),
-        Err((left_type, right_type)) => {
-            return Err(ShellError::coerce_error(
-                left_type.spanned(name.span),
-                right_type.spanned(name.span),
-            ))
-        }
-    };
-    let sum_x_squared_div_n = match compute_values(Operator::Divide, &sum_x_squared, &n.into()) {
-        Ok(v) => v.into_untagged_value(),
-        Err((left_type, right_type)) => {
-            return Err(ShellError::coerce_error(
-                left_type.spanned(name.span),
-                right_type.spanned(name.span),
-            ))
-        }
-    };
-    let ss = match compute_values(Operator::Minus, &sum_x2, &sum_x_squared_div_n) {
-        Ok(v) => v.into_untagged_value(),
-        Err((left_type, right_type)) => {
-            return Err(ShellError::coerce_error(
-                left_type.spanned(name.span),
-                right_type.spanned(name.span),
-            ))
-        }
-    };
-
-    Ok(ss)
-}
-
-pub fn variance(values: &[Value], name: &Tag) -> Result<Value, ShellError> {
-    let ss = sum_of_squares(values, name)?;
-    let n = BigDecimal::from_usize(values.len()).ok_or_else(|| {
-        ShellError::labeled_error(
-            "could not convert to big decimal",
-            "could not convert to big decimal",
-            &name.span,
-        )
-    })?;
-    let variance = compute_values(Operator::Divide, &ss, &n.into());
-    match variance {
-        Ok(value) => Ok(value.into_value(name)),
-        Err((_, _)) => Err(ShellError::labeled_error(
-            "could not calculate variance of non-integer or unrelated types",
-            "source",
-            name,
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

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

@@ -1,46 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-
-#[derive(Clone)]
-pub struct Command;
-
-#[async_trait]
-impl WholeStreamCommand for Command {
-    fn name(&self) -> &str {
-        "move"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("move")
-    }
-
-    fn usage(&self) -> &str {
-        "moves across desired subcommand."
-    }
-
-    async fn run(
-        &self,
-        _args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = registry.clone();
-        Ok(OutputStream::one(Ok(ReturnSuccess::Value(
-            UntaggedValue::string(crate::commands::help::get_help(&Command, &registry))
-                .into_value(Tag::unknown()),
-        ))))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Command;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Command {})
-    }
-}

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

@@ -1,70 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::deserializer::NumericRange;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape};
-use nu_source::Tagged;
-
-#[derive(Deserialize)]
-struct RangeArgs {
-    area: Tagged<NumericRange>,
-}
-
-pub struct Range;
-
-#[async_trait]
-impl WholeStreamCommand for Range {
-    fn name(&self) -> &str {
-        "range"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("range").required(
-            "rows ",
-            SyntaxShape::Range,
-            "range of rows to return: Eg) 4..7 (=> from 4 to 7)",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Return only the selected rows"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        range(args, registry).await
-    }
-}
-
-async fn range(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (RangeArgs { area }, input) = args.process(&registry).await?;
-    let range = area.item;
-    let (from, _) = range.from;
-    let (to, _) = range.to;
-
-    let from = *from as usize;
-    let to = *to as usize;
-
-    Ok(input
-        .skip(from)
-        .take(to - from + 1)
-        .map(ReturnSuccess::value)
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Range;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Range {})
-    }
-}

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

@@ -1,72 +0,0 @@
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-
-use derive_new::new;
-use nu_errors::ShellError;
-use nu_protocol::{hir::Block, Signature, SyntaxShape};
-
-#[derive(new, Clone)]
-pub struct AliasCommand {
-    name: String,
-    args: Vec<String>,
-    block: Block,
-}
-
-#[async_trait]
-impl WholeStreamCommand for AliasCommand {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn signature(&self) -> Signature {
-        let mut alias = Signature::build(&self.name);
-
-        for arg in &self.args {
-            alias = alias.optional(arg, SyntaxShape::Any, "");
-        }
-
-        alias
-    }
-
-    fn usage(&self) -> &str {
-        ""
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let call_info = args.call_info.clone();
-        let registry = registry.clone();
-        let mut block = self.block.clone();
-        block.set_is_last(call_info.args.is_last);
-
-        let alias_command = self.clone();
-        let mut context = Context::from_args(&args, &registry);
-        let input = args.input;
-
-        let mut scope = call_info.scope.clone();
-        let evaluated = call_info.evaluate(&registry).await?;
-        if let Some(positional) = &evaluated.args.positional {
-            for (pos, arg) in positional.iter().enumerate() {
-                scope
-                    .vars
-                    .insert(alias_command.args[pos].to_string(), arg.clone());
-            }
-        }
-
-        // FIXME: we need to patch up the spans to point at the top-level error
-        Ok(run_block(
-            &block,
-            &mut context,
-            input,
-            &scope.it,
-            &scope.vars,
-            &scope.env,
-        )
-        .await?
-        .to_output_stream())
-    }
-}

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

@@ -1,260 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, Value};
-use nu_source::Tagged;
-use nu_value_ext::as_string;
-
-pub struct SplitBy;
-
-#[derive(Deserialize)]
-pub struct SplitByArgs {
-    column_name: Option<Tagged<String>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SplitBy {
-    fn name(&self) -> &str {
-        "split-by"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("split-by").optional(
-            "column_name",
-            SyntaxShape::String,
-            "the name of the column within the nested table to split by",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Creates a new table with the data from the inner tables split by the column given."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        split_by(args, registry).await
-    }
-}
-
-pub async fn split_by(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let name = args.call_info.name_tag.clone();
-    let (SplitByArgs { column_name }, input) = args.process(&registry).await?;
-    let values: Vec<Value> = input.collect().await;
-
-    if values.len() > 1 || values.is_empty() {
-        return Err(ShellError::labeled_error(
-            "Expected table from pipeline",
-            "requires a table input",
-            name,
-        ));
-    }
-
-    match split(&column_name, &values[0], &name) {
-        Ok(splits) => Ok(OutputStream::one(ReturnSuccess::value(splits))),
-        Err(err) => Err(err),
-    }
-}
-
-enum Grouper {
-    ByColumn(Option<Tagged<String>>),
-}
-
-pub fn split(
-    column_name: &Option<Tagged<String>>,
-    values: &Value,
-    tag: impl Into<Tag>,
-) -> Result<Value, ShellError> {
-    let name = tag.into();
-
-    let grouper = if let Some(column_name) = column_name {
-        Grouper::ByColumn(Some(column_name.clone()))
-    } else {
-        Grouper::ByColumn(None)
-    };
-
-    match grouper {
-        Grouper::ByColumn(Some(column_name)) => {
-            let block = Box::new(move |_, row: &Value| {
-                match row.get_data_by_key(column_name.borrow_spanned()) {
-                    Some(group_key) => Ok(as_string(&group_key)?),
-                    None => Err(suggestions(column_name.borrow_tagged(), &row)),
-                }
-            });
-
-            crate::utils::data::split(&values, &Some(block), &name)
-        }
-        Grouper::ByColumn(None) => {
-            let block = Box::new(move |_, row: &Value| match as_string(row) {
-                Ok(group_key) => Ok(group_key),
-                Err(reason) => Err(reason),
-            });
-
-            crate::utils::data::split(&values, &Some(block), &name)
-        }
-    }
-}
-
-pub fn suggestions(tried: Tagged<&str>, for_value: &Value) -> ShellError {
-    let possibilities = for_value.data_descriptors();
-
-    let mut possible_matches: Vec<_> = possibilities
-        .iter()
-        .map(|x| (natural::distance::levenshtein_distance(x, &tried), x))
-        .collect();
-
-    possible_matches.sort();
-
-    if !possible_matches.is_empty() {
-        ShellError::labeled_error(
-            "Unknown column",
-            format!("did you mean '{}'?", possible_matches[0].1),
-            tried.tag(),
-        )
-    } else {
-        ShellError::labeled_error(
-            "Unknown column",
-            "row does not contain this column",
-            tried.tag(),
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::split;
-    use crate::commands::group_by::group;
-    use indexmap::IndexMap;
-    use nu_errors::ShellError;
-    use nu_protocol::{UntaggedValue, Value};
-    use nu_source::*;
-
-    fn string(input: impl Into<String>) -> Value {
-        UntaggedValue::string(input.into()).into_untagged_value()
-    }
-
-    fn row(entries: IndexMap<String, Value>) -> Value {
-        UntaggedValue::row(entries).into_untagged_value()
-    }
-
-    fn table(list: &[Value]) -> Value {
-        UntaggedValue::table(list).into_untagged_value()
-    }
-
-    fn nu_releases_grouped_by_date() -> Result<Value, ShellError> {
-        let key = Some(String::from("date").tagged_unknown());
-        let sample = table(&nu_releases_committers());
-        group(&key, &sample, Tag::unknown())
-    }
-
-    fn nu_releases_committers() -> Vec<Value> {
-        vec![
-            row(
-                indexmap! {"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("August 23-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => string("August 23-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("October 10-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("Sept 24-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => string("October 10-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("Sept 24-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("October 10-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => string("Sept 24-2019")},
-            ),
-            row(
-                indexmap! {"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("August 23-2019")},
-            ),
-        ]
-    }
-
-    #[test]
-    fn splits_inner_tables_by_key() -> Result<(), ShellError> {
-        let for_key = Some(String::from("country").tagged_unknown());
-
-        assert_eq!(
-            split(&for_key, &nu_releases_grouped_by_date()?, Tag::unknown())?,
-            UntaggedValue::row(indexmap! {
-                "EC".into() => row(indexmap! {
-                    "August 23-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("August 23-2019")})
-                    ]),
-                    "Sept 24-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("Sept 24-2019")})
-                    ]),
-                    "October 10-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("October 10-2019")})
-                    ])
-                }),
-                "NZ".into() => row(indexmap! {
-                    "August 23-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => string("August 23-2019")})
-                    ]),
-                    "Sept 24-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => string("Sept 24-2019")})
-                    ]),
-                    "October 10-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("JT"), "country".into() => string("NZ"), "date".into() => string("October 10-2019")})
-                    ])
-                }),
-                "US".into() => row(indexmap! {
-                    "August 23-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("August 23-2019")})
-                    ]),
-                    "Sept 24-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("Sept 24-2019")})
-                    ]),
-                    "October 10-2019".into() => table(&[
-                        row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("October 10-2019")})
-                    ])
-                })
-            }).into_untagged_value()
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn errors_if_key_within_some_inner_table_is_missing() {
-        let for_key = Some(String::from("country").tagged_unknown());
-
-        let nu_releases = row(indexmap! {
-            "August 23-2019".into() =>  table(&[
-                    row(indexmap!{"name".into() => string("AR"), "country".into() => string("EC"), "date".into() => string("August 23-2019")})
-            ]),
-            "Sept 24-2019".into() =>  table(&[
-                    row(indexmap!{"name".into() => UntaggedValue::string("JT").into_value(Tag::from(Span::new(5,10))), "date".into() => string("Sept 24-2019")})
-            ]),
-            "October 10-2019".into() =>  table(&[
-                    row(indexmap!{"name".into() => string("YK"), "country".into() => string("US"), "date".into() => string("October 10-2019")})
-            ])
-        });
-
-        assert!(split(&for_key, &nu_releases, Tag::from(Span::new(5, 10))).is_err());
-    }
-
-    #[test]
-    fn examples_work_as_expected() {
-        use super::SplitBy;
-        use crate::examples::test as test_examples;
-
-        test_examples(SplitBy {})
-    }
-}

crates/nu-cli/src/commands/str_/collect.rs

@@ -1,56 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue, Value};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "str collect"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("str collect")
-    }
-
-    fn usage(&self) -> &str {
-        "collects a list of strings into a string"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        _registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let output = args
-            .input
-            .collect_string(args.call_info.name_tag.clone())
-            .await?;
-
-        Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(output.item).into_value(output.tag),
-        )))
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Collect a list of string",
-            example: "echo ['a' 'b' 'c'] | str collect",
-            result: Some(vec![Value::from("abc")]),
-        }]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-cli/src/commands/str_/length.rs

@@ -1,65 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "str length"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("str length")
-    }
-
-    fn usage(&self) -> &str {
-        "outputs the lengths of the strings in the pipeline"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        _registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        Ok(args
-            .input
-            .map(move |x| match x.as_string() {
-                Ok(s) => ReturnSuccess::value(UntaggedValue::int(s.len()).into_untagged_value()),
-                Err(err) => Err(err),
-            })
-            .to_output_stream())
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Return the lengths of multiple strings",
-                example: "echo 'hello' | str length",
-                result: Some(vec![UntaggedValue::int(5).into_untagged_value()]),
-            },
-            Example {
-                description: "Return the lengths of multiple strings",
-                example: "echo 'hi' 'there' | str length",
-                result: Some(vec![
-                    UntaggedValue::int(2).into_untagged_value(),
-                    UntaggedValue::int(5).into_untagged_value(),
-                ]),
-            },
-        ]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

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

@@ -1,31 +0,0 @@
-mod capitalize;
-mod collect;
-mod command;
-mod downcase;
-mod find_replace;
-mod from;
-mod length;
-mod reverse;
-mod set;
-mod substring;
-mod to_datetime;
-mod to_decimal;
-mod to_integer;
-mod trim;
-mod upcase;
-
-pub use capitalize::SubCommand as StrCapitalize;
-pub use collect::SubCommand as StrCollect;
-pub use command::Command as Str;
-pub use downcase::SubCommand as StrDowncase;
-pub use find_replace::SubCommand as StrFindReplace;
-pub use from::SubCommand as StrFrom;
-pub use length::SubCommand as StrLength;
-pub use reverse::SubCommand as StrReverse;
-pub use set::SubCommand as StrSet;
-pub use substring::SubCommand as StrSubstring;
-pub use to_datetime::SubCommand as StrToDatetime;
-pub use to_decimal::SubCommand as StrToDecimal;
-pub use to_integer::SubCommand as StrToInteger;
-pub use trim::SubCommand as StrTrim;
-pub use upcase::SubCommand as StrUpcase;

crates/nu-cli/src/commands/str_/reverse.rs

@@ -1,58 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "str reverse"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("str reverse")
-    }
-
-    fn usage(&self) -> &str {
-        "outputs the reversals of the strings in the pipeline"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        _registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        Ok(args
-            .input
-            .map(move |x| match x.as_string() {
-                Ok(s) => ReturnSuccess::value(
-                    UntaggedValue::string(s.chars().rev().collect::<String>())
-                        .into_untagged_value(),
-                ),
-                Err(err) => Err(err),
-            })
-            .to_output_stream())
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Return the reversals of multiple strings",
-            example: "echo 'Nushell' | str reverse",
-            result: Some(vec![UntaggedValue::string("llehsuN").into_untagged_value()]),
-        }]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

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

@@ -1,123 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::{Tag, Tagged};
-use nu_value_ext::ValueExt;
-
-#[derive(Deserialize)]
-struct Arguments {
-    replace: Tagged<String>,
-    rest: Vec<ColumnPath>,
-}
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "str set"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("str set")
-            .required("set", SyntaxShape::String, "the new string to set")
-            .rest(
-                SyntaxShape::ColumnPath,
-                "optionally set text by column paths",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "sets text"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        operate(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Set contents with preferred string",
-                example: "echo 'good day' | str set 'good bye'",
-                result: Some(vec![Value::from("good bye")]),
-            },
-            Example {
-                description: "Set the contents on preferred column paths",
-                example: "open Cargo.toml | str set '255' package.version",
-                result: None,
-            },
-        ]
-    }
-}
-
-#[derive(Clone)]
-struct Replace(String);
-
-async fn operate(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    let (Arguments { replace, rest }, input) = args.process(&registry).await?;
-    let options = Replace(replace.item);
-
-    let column_paths: Vec<_> = rest;
-
-    Ok(input
-        .map(move |v| {
-            if column_paths.is_empty() {
-                ReturnSuccess::value(action(&v, &options, v.tag())?)
-            } else {
-                let mut ret = v;
-
-                for path in &column_paths {
-                    let options = options.clone();
-
-                    ret = ret.swap_data_by_column_path(
-                        path,
-                        Box::new(move |old| action(old, &options, old.tag())),
-                    )?;
-                }
-
-                ReturnSuccess::value(ret)
-            }
-        })
-        .to_output_stream())
-}
-
-fn action(_input: &Value, options: &Replace, tag: impl Into<Tag>) -> Result<Value, ShellError> {
-    let replacement = &options.0;
-    Ok(UntaggedValue::string(replacement.as_str()).into_value(tag))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{action, Replace, SubCommand};
-    use nu_plugin::test_helpers::value::string;
-    use nu_source::Tag;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-
-    #[test]
-    fn sets() {
-        let word = string("andres");
-        let expected = string("robalino");
-
-        let set_options = Replace(String::from("robalino"));
-
-        let actual = action(&word, &set_options, Tag::unknown()).unwrap();
-        assert_eq!(actual, expected);
-    }
-}

crates/nu-cli/src/commands/str_/to_datetime.rs

@@ -1,175 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{
-    ColumnPath, Primitive, ReturnSuccess, ShellTypeName, Signature, SyntaxShape, UntaggedValue,
-    Value,
-};
-use nu_source::{Tag, Tagged};
-use nu_value_ext::ValueExt;
-
-use chrono::DateTime;
-
-#[derive(Deserialize)]
-struct Arguments {
-    format: Option<Tagged<String>>,
-    rest: Vec<ColumnPath>,
-}
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "str to-datetime"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("str to-datetime")
-            .named(
-                "format",
-                SyntaxShape::String,
-                "Specify date and time formatting",
-                Some('f'),
-            )
-            .rest(
-                SyntaxShape::ColumnPath,
-                "optionally convert text into datetime by column paths",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "converts text into datetime"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        operate(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Convert to datetime",
-            example: "echo '16.11.1984 8:00 am +0000' | str to-datetime",
-            result: None,
-        }]
-    }
-}
-
-#[derive(Clone)]
-struct DatetimeFormat(String);
-
-async fn operate(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    let (Arguments { format, rest }, input) = args.process(&registry).await?;
-
-    let column_paths: Vec<_> = rest;
-
-    let options = if let Some(Tagged { item: fmt, .. }) = format {
-        DatetimeFormat(fmt)
-    } else {
-        DatetimeFormat(String::from("%d.%m.%Y %H:%M %P %z"))
-    };
-
-    Ok(input
-        .map(move |v| {
-            if column_paths.is_empty() {
-                ReturnSuccess::value(action(&v, &options, v.tag())?)
-            } else {
-                let mut ret = v;
-
-                for path in &column_paths {
-                    let options = options.clone();
-
-                    ret = ret.swap_data_by_column_path(
-                        path,
-                        Box::new(move |old| action(old, &options, old.tag())),
-                    )?;
-                }
-
-                ReturnSuccess::value(ret)
-            }
-        })
-        .to_output_stream())
-}
-
-fn action(
-    input: &Value,
-    options: &DatetimeFormat,
-    tag: impl Into<Tag>,
-) -> Result<Value, ShellError> {
-    match &input.value {
-        UntaggedValue::Primitive(Primitive::Line(s))
-        | UntaggedValue::Primitive(Primitive::String(s)) => {
-            let dt = &options.0;
-
-            let out = match DateTime::parse_from_str(s, dt) {
-                Ok(d) => UntaggedValue::date(d),
-                Err(reason) => {
-                    return Err(ShellError::labeled_error(
-                        "could not parse as datetime",
-                        reason.to_string(),
-                        tag.into().span,
-                    ))
-                }
-            };
-
-            Ok(out.into_value(tag))
-        }
-        other => {
-            let got = format!("got {}", other.type_name());
-            Err(ShellError::labeled_error(
-                "value is not string",
-                got,
-                tag.into().span,
-            ))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{action, DatetimeFormat, SubCommand};
-    use nu_plugin::test_helpers::value::string;
-    use nu_protocol::{Primitive, UntaggedValue};
-    use nu_source::Tag;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-
-    #[test]
-    fn takes_a_date_format() {
-        let date_str = string("16.11.1984 8:00 am +0000");
-
-        let fmt_options = DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string());
-
-        let actual = action(&date_str, &fmt_options, Tag::unknown()).unwrap();
-
-        match actual.value {
-            UntaggedValue::Primitive(Primitive::Date(_)) => {}
-            _ => panic!("Didn't convert to date"),
-        }
-    }
-
-    #[test]
-    fn communicates_parsing_error_given_an_invalid_datetimelike_string() {
-        let date_str = string("16.11.1984 8:00 am Oops0000");
-
-        let fmt_options = DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string());
-
-        let actual = action(&date_str, &fmt_options, Tag::unknown());
-
-        assert!(actual.is_err());
-    }
-}

crates/nu-cli/src/commands/str_/trim.rs

@@ -1,168 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::ShellTypeName;
-use nu_protocol::{
-    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
-use nu_source::{Tag, Tagged};
-use nu_value_ext::ValueExt;
-
-#[derive(Deserialize)]
-struct Arguments {
-    rest: Vec<ColumnPath>,
-    #[serde(rename(deserialize = "char"))]
-    char_: Option<Tagged<char>>,
-}
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "str trim"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("str trim")
-            .rest(
-                SyntaxShape::ColumnPath,
-                "optionally trim text by column paths",
-            )
-            .named(
-                "char",
-                SyntaxShape::String,
-                "character to trim (default: whitespace)",
-                Some('c'),
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "trims text"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        operate(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Trim whitespace",
-                example: "echo 'Nu shell ' | str trim",
-                result: Some(vec![Value::from("Nu shell")]),
-            },
-            Example {
-                description: "Trim a specific character",
-                example: "echo '=== Nu shell ===' | str trim -c '=' | str trim",
-                result: Some(vec![Value::from("Nu shell")]),
-            },
-        ]
-    }
-}
-
-async fn operate(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    let (Arguments { rest, char_ }, input) = args.process(&registry).await?;
-
-    let column_paths: Vec<_> = rest;
-    let to_trim = char_.map(|tagged| tagged.item);
-
-    Ok(input
-        .map(move |v| {
-            if column_paths.is_empty() {
-                ReturnSuccess::value(action(&v, v.tag(), to_trim)?)
-            } else {
-                let mut ret = v;
-
-                for path in &column_paths {
-                    ret = ret.swap_data_by_column_path(
-                        path,
-                        Box::new(move |old| action(old, old.tag(), to_trim)),
-                    )?;
-                }
-
-                ReturnSuccess::value(ret)
-            }
-        })
-        .to_output_stream())
-}
-
-fn action(input: &Value, tag: impl Into<Tag>, char_: Option<char>) -> Result<Value, ShellError> {
-    match &input.value {
-        UntaggedValue::Primitive(Primitive::Line(s))
-        | UntaggedValue::Primitive(Primitive::String(s)) => {
-            Ok(UntaggedValue::string(match char_ {
-                None => String::from(s.trim()),
-                Some(ch) => trim_char(s, ch, true, true),
-            })
-            .into_value(tag))
-        }
-        other => {
-            let got = format!("got {}", other.type_name());
-            Err(ShellError::labeled_error(
-                "value is not string",
-                got,
-                tag.into().span,
-            ))
-        }
-    }
-}
-
-pub fn trim_char(from: &str, to_trim: char, leading: bool, trailing: bool) -> String {
-    let mut trimmed = String::from("");
-    let mut backlog = String::from("");
-    let mut at_left = true;
-    from.chars().for_each(|ch| match ch {
-        c if c == to_trim => {
-            if !(leading && at_left) {
-                if trailing {
-                    backlog.push(c)
-                } else {
-                    trimmed.push(c)
-                }
-            }
-        }
-        other => {
-            at_left = false;
-            if trailing {
-                trimmed.push_str(backlog.as_str());
-                backlog = String::from("");
-            }
-            trimmed.push(other);
-        }
-    });
-
-    trimmed
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{action, SubCommand};
-    use nu_plugin::test_helpers::value::string;
-    use nu_source::Tag;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(SubCommand {})
-    }
-
-    #[test]
-    fn trims() {
-        let word = string("andres ");
-        let expected = string("andres");
-
-        let actual = action(&word, Tag::unknown(), None).unwrap();
-        assert_eq!(actual, expected);
-    }
-}

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

@@ -1,304 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::data::value::{format_leaf, style_leaf};
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_table::{draw_table, Alignment, StyledString, TextStyle, Theme};
-use std::time::Instant;
-
-const STREAM_PAGE_SIZE: usize = 1000;
-const STREAM_TIMEOUT_CHECK_INTERVAL: usize = 100;
-
-pub struct Table;
-
-#[async_trait]
-impl WholeStreamCommand for Table {
-    fn name(&self) -> &str {
-        "table"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("table").named(
-            "start_number",
-            SyntaxShape::Number,
-            "row number to start viewing from",
-            Some('n'),
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "View the contents of the pipeline as a table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        table(args, registry).await
-    }
-}
-
-fn str_to_color(s: String) -> Option<ansi_term::Color> {
-    match s.as_str() {
-        "g" | "green" => Some(ansi_term::Color::Green),
-        "r" | "red" => Some(ansi_term::Color::Red),
-        "u" | "blue" => Some(ansi_term::Color::Blue),
-        "b" | "black" => Some(ansi_term::Color::Black),
-        "y" | "yellow" => Some(ansi_term::Color::Yellow),
-        "p" | "purple" => Some(ansi_term::Color::Purple),
-        "c" | "cyan" => Some(ansi_term::Color::Cyan),
-        "w" | "white" => Some(ansi_term::Color::White),
-        _ => None,
-    }
-}
-
-pub fn from_list(values: &[Value], starting_idx: usize) -> nu_table::Table {
-    let config = crate::data::config::config(Tag::unknown());
-
-    let header_style = if let Ok(config) = &config {
-        let header_align = config.get("header_align").map_or(Alignment::Left, |a| {
-            a.as_string()
-                .map_or(Alignment::Center, |a| match a.to_lowercase().as_str() {
-                    "center" | "c" => Alignment::Center,
-                    "right" | "r" => Alignment::Right,
-                    _ => Alignment::Center,
-                })
-        });
-
-        let header_color = match config.get("header_color") {
-            Some(c) => match c.as_string() {
-                Ok(color) => str_to_color(color.to_lowercase()).unwrap_or(ansi_term::Color::Green),
-                _ => ansi_term::Color::Green,
-            },
-            _ => ansi_term::Color::Green,
-        };
-
-        let header_bold = match config.get("header_bold") {
-            Some(b) => match b.as_bool() {
-                Ok(b) => b,
-                _ => true,
-            },
-            _ => true,
-        };
-
-        TextStyle {
-            alignment: header_align,
-            color: Some(header_color),
-            is_bold: header_bold,
-        }
-    } else {
-        TextStyle::default_header()
-    };
-
-    let mut headers: Vec<StyledString> = nu_protocol::merge_descriptors(values)
-        .into_iter()
-        .map(|x| StyledString::new(x, header_style.clone()))
-        .collect();
-    let entries = values_to_entries(values, &mut headers, starting_idx);
-
-    if let Ok(config) = config {
-        if let Some(style) = config.get("table_mode") {
-            if let Ok(table_mode) = style.as_string() {
-                if table_mode == "light" {
-                    return nu_table::Table {
-                        headers,
-                        data: entries,
-                        theme: Theme::light(),
-                    };
-                }
-            }
-        }
-    }
-    nu_table::Table {
-        headers,
-        data: entries,
-        theme: Theme::compact(),
-    }
-}
-
-fn are_table_indexes_disabled() -> bool {
-    let config = crate::data::config::config(Tag::unknown());
-    match config {
-        Ok(config) => {
-            let disable_indexes = config.get("disable_table_indexes");
-            disable_indexes.map_or(false, |x| x.as_bool().unwrap_or(false))
-        }
-        _ => false,
-    }
-}
-
-fn values_to_entries(
-    values: &[Value],
-    headers: &mut Vec<StyledString>,
-    starting_idx: usize,
-) -> Vec<Vec<StyledString>> {
-    let disable_indexes = are_table_indexes_disabled();
-    let mut entries = vec![];
-
-    if headers.is_empty() {
-        headers.push(StyledString::new("".to_string(), TextStyle::basic()));
-    }
-
-    for (idx, value) in values.iter().enumerate() {
-        let mut row: Vec<StyledString> = headers
-            .iter()
-            .map(|d: &StyledString| {
-                if d.contents == "" {
-                    match value {
-                        Value {
-                            value: UntaggedValue::Row(..),
-                            ..
-                        } => StyledString::new(
-                            format_leaf(&UntaggedValue::nothing()).plain_string(100_000),
-                            style_leaf(&UntaggedValue::nothing()),
-                        ),
-                        _ => StyledString::new(
-                            format_leaf(value).plain_string(100_000),
-                            style_leaf(value),
-                        ),
-                    }
-                } else {
-                    match value {
-                        Value {
-                            value: UntaggedValue::Row(..),
-                            ..
-                        } => {
-                            let data = value.get_data(&d.contents);
-
-                            StyledString::new(
-                                format_leaf(data.borrow()).plain_string(100_000),
-                                style_leaf(data.borrow()),
-                            )
-                        }
-                        _ => StyledString::new(
-                            format_leaf(&UntaggedValue::nothing()).plain_string(100_000),
-                            style_leaf(&UntaggedValue::nothing()),
-                        ),
-                    }
-                }
-            })
-            .collect();
-
-        // Indices are green, bold, right-aligned:
-        if !disable_indexes {
-            row.insert(
-                0,
-                StyledString::new(
-                    (starting_idx + idx).to_string(),
-                    TextStyle {
-                        alignment: Alignment::Right,
-                        color: Some(ansi_term::Color::Green),
-                        is_bold: true,
-                    },
-                ),
-            );
-        }
-
-        entries.push(row);
-    }
-
-    if !disable_indexes {
-        headers.insert(
-            0,
-            StyledString::new(
-                "#".to_owned(),
-                TextStyle {
-                    alignment: Alignment::Center,
-                    color: Some(ansi_term::Color::Green),
-                    is_bold: true,
-                },
-            ),
-        );
-    }
-
-    entries
-}
-
-async fn table(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let mut args = args.evaluate_once(&registry).await?;
-    let mut finished = false;
-
-    // let host = args.host.clone();
-    let mut start_number = match args.get("start_number") {
-        Some(Value {
-            value: UntaggedValue::Primitive(Primitive::Int(i)),
-            ..
-        }) => {
-            if let Some(num) = i.to_usize() {
-                num
-            } else {
-                return Err(ShellError::labeled_error(
-                    "Expected a row number",
-                    "expected a row number",
-                    &args.args.call_info.name_tag,
-                ));
-            }
-        }
-        _ => 0,
-    };
-
-    let mut delay_slot = None;
-
-    let term_width = args.host.lock().width();
-
-    while !finished {
-        let mut new_input: VecDeque<Value> = VecDeque::new();
-
-        let start_time = Instant::now();
-        for idx in 0..STREAM_PAGE_SIZE {
-            if let Some(val) = delay_slot {
-                new_input.push_back(val);
-                delay_slot = None;
-            } else {
-                match args.input.next().await {
-                    Some(a) => {
-                        if !new_input.is_empty() {
-                            if let Some(descs) = new_input.get(0) {
-                                let descs = descs.data_descriptors();
-                                let compare = a.data_descriptors();
-                                if descs != compare {
-                                    delay_slot = Some(a);
-                                    break;
-                                } else {
-                                    new_input.push_back(a);
-                                }
-                            } else {
-                                new_input.push_back(a);
-                            }
-                        } else {
-                            new_input.push_back(a);
-                        }
-                    }
-                    _ => {
-                        finished = true;
-                        break;
-                    }
-                }
-
-                // Check if we've gone over our buffering threshold
-                if (idx + 1) % STREAM_TIMEOUT_CHECK_INTERVAL == 0 {
-                    let end_time = Instant::now();
-
-                    // If we've been buffering over a second, go ahead and send out what we have so far
-                    if (end_time - start_time).as_secs() >= 1 {
-                        break;
-                    }
-                }
-            }
-        }
-
-        let input: Vec<Value> = new_input.into();
-
-        if !input.is_empty() {
-            let t = from_list(&input, start_number);
-
-            draw_table(&t, term_width);
-        }
-
-        start_number += input.len();
-    }
-
-    Ok(OutputStream::empty())
-}

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

@@ -1,596 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::data::value::format_leaf;
-use crate::prelude::*;
-use futures::StreamExt;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
-use nu_source::AnchorLocation;
-use regex::Regex;
-use std::collections::HashMap;
-
-pub struct ToHTML;
-
-#[derive(Deserialize)]
-pub struct ToHTMLArgs {
-    html_color: bool,
-    no_color: bool,
-    dark_bg: bool,
-    use_campbell: bool,
-}
-
-#[async_trait]
-impl WholeStreamCommand for ToHTML {
-    fn name(&self) -> &str {
-        "to html"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("to html")
-            .switch("html_color", "change ansi colors to html colors", Some('t'))
-            .switch("no_color", "remove all ansi colors in output", Some('n'))
-            .switch(
-                "dark_bg",
-                "indicate your background color is a darker color",
-                Some('d'),
-            )
-            .switch(
-                "use_campbell",
-                "use microsoft's windows terminal color scheme named campell",
-                Some('c'),
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Convert table into simple HTML"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        to_html(args, registry).await
-    }
-}
-
-fn get_campbell_theme(is_dark: bool) -> HashMap<&'static str, String> {
-    // for reference here is Microsoft's Campbell Theme
-    // taken from here
-    // https://docs.microsoft.com/en-us/windows/terminal/customize-settings/color-schemes
-    let mut hm: HashMap<&str, String> = HashMap::new();
-
-    if is_dark {
-        hm.insert("bold_black", "#767676".to_string());
-        hm.insert("bold_red", "#E74856".to_string());
-        hm.insert("bold_green", "#16C60C".to_string());
-        hm.insert("bold_yellow", "#F9F1A5".to_string());
-        hm.insert("bold_blue", "#3B78FF".to_string());
-        hm.insert("bold_magenta", "#B4009E".to_string());
-        hm.insert("bold_cyan", "#61D6D6".to_string());
-        hm.insert("bold_white", "#F2F2F2".to_string());
-
-        hm.insert("black", "#0C0C0C".to_string());
-        hm.insert("red", "#C50F1F".to_string());
-        hm.insert("green", "#13A10E".to_string());
-        hm.insert("yellow", "#C19C00".to_string());
-        hm.insert("blue", "#0037DA".to_string());
-        hm.insert("magenta", "#881798".to_string());
-        hm.insert("cyan", "#3A96DD".to_string());
-        hm.insert("white", "#CCCCCC".to_string());
-
-        hm.insert("background", "#0C0C0C".to_string());
-        hm.insert("foreground", "#CCCCCC".to_string());
-    } else {
-        hm.insert("bold_black", "#767676".to_string());
-        hm.insert("bold_red", "#E74856".to_string());
-        hm.insert("bold_green", "#16C60C".to_string());
-        hm.insert("bold_yellow", "#F9F1A5".to_string());
-        hm.insert("bold_blue", "#3B78FF".to_string());
-        hm.insert("bold_magenta", "#B4009E".to_string());
-        hm.insert("bold_cyan", "#61D6D6".to_string());
-        hm.insert("bold_white", "#F2F2F2".to_string());
-
-        hm.insert("black", "#0C0C0C".to_string());
-        hm.insert("red", "#C50F1F".to_string());
-        hm.insert("green", "#13A10E".to_string());
-        hm.insert("yellow", "#C19C00".to_string());
-        hm.insert("blue", "#0037DA".to_string());
-        hm.insert("magenta", "#881798".to_string());
-        hm.insert("cyan", "#3A96DD".to_string());
-        hm.insert("white", "#CCCCCC".to_string());
-
-        hm.insert("background", "#CCCCCC".to_string());
-        hm.insert("foreground", "#0C0C0C".to_string());
-    }
-
-    hm
-}
-
-fn get_default_theme(is_dark: bool) -> HashMap<&'static str, String> {
-    let mut hm: HashMap<&str, String> = HashMap::new();
-
-    if is_dark {
-        hm.insert("bold_black", "black".to_string());
-        hm.insert("bold_red", "red".to_string());
-        hm.insert("bold_green", "green".to_string());
-        hm.insert("bold_yellow", "yellow".to_string());
-        hm.insert("bold_blue", "blue".to_string());
-        hm.insert("bold_magenta", "magenta".to_string());
-        hm.insert("bold_cyan", "cyan".to_string());
-        hm.insert("bold_white", "white".to_string());
-
-        hm.insert("black", "black".to_string());
-        hm.insert("red", "red".to_string());
-        hm.insert("green", "green".to_string());
-        hm.insert("yellow", "yellow".to_string());
-        hm.insert("blue", "blue".to_string());
-        hm.insert("magenta", "magenta".to_string());
-        hm.insert("cyan", "cyan".to_string());
-        hm.insert("white", "white".to_string());
-
-        hm.insert("background", "black".to_string());
-        hm.insert("foreground", "white".to_string());
-    } else {
-        hm.insert("bold_black", "black".to_string());
-        hm.insert("bold_red", "red".to_string());
-        hm.insert("bold_green", "green".to_string());
-        hm.insert("bold_yellow", "#717100".to_string());
-        hm.insert("bold_blue", "blue".to_string());
-        hm.insert("bold_magenta", "#c800c8".to_string());
-        hm.insert("bold_cyan", "#037979".to_string());
-        hm.insert("bold_white", "white".to_string());
-
-        hm.insert("black", "black".to_string());
-        hm.insert("red", "red".to_string());
-        hm.insert("green", "green".to_string());
-        hm.insert("yellow", "#717100".to_string());
-        hm.insert("blue", "blue".to_string());
-        hm.insert("magenta", "#c800c8".to_string());
-        hm.insert("cyan", "#037979".to_string());
-        hm.insert("white", "white".to_string());
-
-        hm.insert("background", "white".to_string());
-        hm.insert("foreground", "black".to_string());
-    }
-
-    hm
-}
-
-fn get_colors(is_dark: bool, use_campbell: bool) -> HashMap<&'static str, String> {
-    // Currently now using bold_white and bold_black.
-    // This is not theming but it is kind of a start. The intent here is to use the
-    // regular terminal colors which appear on black for most people and are very
-    // high contrast. But when there's a light background, use something that works
-    // better for it.
-
-    if use_campbell {
-        get_campbell_theme(is_dark)
-    } else {
-        get_default_theme(is_dark)
-    }
-}
-
-async fn to_html(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let name_tag = args.call_info.name_tag.clone();
-    let (
-        ToHTMLArgs {
-            html_color,
-            no_color,
-            dark_bg,
-            use_campbell,
-        },
-        input,
-    ) = args.process(&registry).await?;
-    let input: Vec<Value> = input.collect().await;
-    let headers = nu_protocol::merge_descriptors(&input);
-    let mut output_string = "<html>".to_string();
-    let mut regex_hm: HashMap<u32, (&str, String)> = HashMap::new();
-    let color_hm = get_colors(dark_bg, use_campbell);
-
-    // change the color of the page
-    output_string.push_str(&format!(
-        r"<style>body {{ background-color:{};color:{}; }}</style><body>",
-        color_hm
-            .get("background")
-            .expect("Error getting background color"),
-        color_hm
-            .get("foreground")
-            .expect("Error getting foreground color")
-    ));
-
-    // Add grid lines to html
-    // let mut output_string = "<html><head><style>".to_string();
-    // output_string.push_str("table, th, td { border: 2px solid black; border-collapse: collapse; padding: 10px; }");
-    // output_string.push_str("</style></head><body>");
-
-    if !headers.is_empty() && (headers.len() > 1 || headers[0] != "") {
-        // output_string.push_str("<table>");
-
-        // change the color of tables
-        output_string.push_str(&format!(
-            r"<table style='background-color:{};color:{};'>",
-            color_hm
-                .get("background")
-                .expect("Error getting background color"),
-            color_hm
-                .get("foreground")
-                .expect("Error getting foreground color")
-        ));
-
-        output_string.push_str("<tr>");
-
-        for header in &headers {
-            output_string.push_str("<th>");
-            output_string.push_str(&htmlescape::encode_minimal(&header));
-            output_string.push_str("</th>");
-        }
-        output_string.push_str("</tr>");
-    }
-
-    for row in input {
-        match row.value {
-            UntaggedValue::Primitive(Primitive::Binary(b)) => {
-                // This might be a bit much, but it's fun :)
-                match row.tag.anchor {
-                    Some(AnchorLocation::Url(f)) | Some(AnchorLocation::File(f)) => {
-                        let extension = f.split('.').last().map(String::from);
-                        match extension {
-                            Some(s)
-                                if ["png", "jpg", "bmp", "gif", "tiff", "jpeg"]
-                                    .contains(&s.to_lowercase().as_str()) =>
-                            {
-                                output_string.push_str("<img src=\"data:image/");
-                                output_string.push_str(&s);
-                                output_string.push_str(";base64,");
-                                output_string.push_str(&base64::encode(&b));
-                                output_string.push_str("\">");
-                            }
-                            _ => {
-                                let output = pretty_hex::pretty_hex(&b);
-
-                                output_string.push_str("<pre>");
-                                output_string.push_str(&output);
-                                output_string.push_str("</pre>");
-                            }
-                        }
-                    }
-                    _ => {
-                        let output = pretty_hex::pretty_hex(&b);
-
-                        output_string.push_str("<pre>");
-                        output_string.push_str(&output);
-                        output_string.push_str("</pre>");
-                    }
-                }
-            }
-            UntaggedValue::Primitive(Primitive::String(ref b)) => {
-                // This might be a bit much, but it's fun :)
-                match row.tag.anchor {
-                    Some(AnchorLocation::Url(f)) | Some(AnchorLocation::File(f)) => {
-                        let extension = f.split('.').last().map(String::from);
-                        match extension {
-                            Some(s) if s.to_lowercase() == "svg" => {
-                                output_string.push_str("<img src=\"data:image/svg+xml;base64,");
-                                output_string.push_str(&base64::encode(&b.as_bytes()));
-                                output_string.push_str("\">");
-                                continue;
-                            }
-                            _ => {}
-                        }
-                    }
-                    _ => {}
-                }
-                output_string.push_str(
-                    &(htmlescape::encode_minimal(&format_leaf(&row.value).plain_string(100_000))
-                        .replace("\n", "<br>")),
-                );
-            }
-            UntaggedValue::Row(row) => {
-                output_string.push_str("<tr>");
-                for header in &headers {
-                    let data = row.get_data(header);
-                    output_string.push_str("<td>");
-                    output_string.push_str(&format_leaf(data.borrow()).plain_string(100_000));
-                    output_string.push_str("</td>");
-                }
-                output_string.push_str("</tr>");
-            }
-            p => {
-                output_string.push_str(
-                    &(htmlescape::encode_minimal(&format_leaf(&p).plain_string(100_000))
-                        .replace("\n", "<br>")),
-                );
-            }
-        }
-    }
-
-    if !headers.is_empty() && (headers.len() > 1 || headers[0] != "") {
-        output_string.push_str("</table>");
-    }
-    output_string.push_str("</body></html>");
-
-    // Check to see if we want to remove all color or change ansi to html colors
-    if html_color {
-        setup_html_color_regexes(&mut regex_hm, dark_bg, use_campbell);
-        output_string = run_regexes(&regex_hm, &output_string);
-    } else if no_color {
-        setup_no_color_regexes(&mut regex_hm);
-        output_string = run_regexes(&regex_hm, &output_string);
-    }
-
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::string(output_string).into_value(name_tag),
-    )))
-}
-
-fn setup_html_color_regexes(
-    hash: &mut HashMap<u32, (&'static str, String)>,
-    is_dark: bool,
-    use_campbell: bool,
-) {
-    let color_hm = get_colors(is_dark, use_campbell);
-
-    // All the bold colors
-    hash.insert(
-        0,
-        (
-            r"(?P<reset>\[0m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            // Reset the text color, normal weight font
-            format!(
-                r"<span style='color:{};font-weight:normal;'>$word</span>",
-                color_hm
-                    .get("foreground")
-                    .expect("Error getting reset text color")
-            ),
-        ),
-    );
-    hash.insert(
-        1,
-        (
-            // Bold Black
-            r"(?P<bb>\[1;30m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("foreground")
-                    .expect("Error getting bold black text color")
-            ),
-        ),
-    );
-    hash.insert(
-        2,
-        (
-            // Bold Red
-            r"(?P<br>\[1;31m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("bold_red")
-                    .expect("Error getting bold red text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        3,
-        (
-            // Bold Green
-            r"(?P<bg>\[1;32m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("bold_green")
-                    .expect("Error getting bold green text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        4,
-        (
-            // Bold Yellow
-            r"(?P<by>\[1;33m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("bold_yellow")
-                    .expect("Error getting bold yellow text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        5,
-        (
-            // Bold Blue
-            r"(?P<bu>\[1;34m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("bold_blue")
-                    .expect("Error getting bold blue text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        6,
-        (
-            // Bold Magenta
-            r"(?P<bm>\[1;35m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("bold_magenta")
-                    .expect("Error getting bold magenta text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        7,
-        (
-            // Bold Cyan
-            r"(?P<bc>\[1;36m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("bold_cyan")
-                    .expect("Error getting bold cyan text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        8,
-        (
-            // Bold White
-            // Let's change this to black since the html background
-            // is white. White on white = no bueno.
-            r"(?P<bw>\[1;37m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};font-weight:bold;'>$word</span>",
-                color_hm
-                    .get("foreground")
-                    .expect("Error getting bold bold white text color"),
-            ),
-        ),
-    );
-    // All the normal colors
-    hash.insert(
-        9,
-        (
-            // Black
-            r"(?P<b>\[30m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm
-                    .get("foreground")
-                    .expect("Error getting black text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        10,
-        (
-            // Red
-            r"(?P<r>\[31m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm.get("red").expect("Error getting red text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        11,
-        (
-            // Green
-            r"(?P<g>\[32m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm
-                    .get("green")
-                    .expect("Error getting green text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        12,
-        (
-            // Yellow
-            r"(?P<y>\[33m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm
-                    .get("yellow")
-                    .expect("Error getting yellow text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        13,
-        (
-            // Blue
-            r"(?P<u>\[34m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm.get("blue").expect("Error getting blue text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        14,
-        (
-            // Magenta
-            r"(?P<m>\[35m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm
-                    .get("magenta")
-                    .expect("Error getting magenta text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        15,
-        (
-            // Cyan
-            r"(?P<c>\[36m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm.get("cyan").expect("Error getting cyan text color"),
-            ),
-        ),
-    );
-    hash.insert(
-        16,
-        (
-            // White
-            // Let's change this to black since the html background
-            // is white. White on white = no bueno.
-            r"(?P<w>\[37m)(?P<word>[[:alnum:][:space:][:punct:]]*)",
-            format!(
-                r"<span style='color:{};'>$word</span>",
-                color_hm
-                    .get("foreground")
-                    .expect("Error getting white text color"),
-            ),
-        ),
-    );
-}
-
-fn setup_no_color_regexes(hash: &mut HashMap<u32, (&'static str, String)>) {
-    // We can just use one regex here because we're just removing ansi sequences
-    // and not replacing them with html colors.
-    // attribution: https://stackoverflow.com/questions/14693701/how-can-i-remove-the-ansi-escape-sequences-from-a-string-in-python
-    hash.insert(
-        0,
-        (
-            r"(?:\x1B[@-Z\\-_]|[\x80-\x9A\x9C-\x9F]|(?:\x1B\[|\x9B)[0-?]*[ -/]*[@-~])",
-            r"$name_group_doesnt_exist".to_string(),
-        ),
-    );
-}
-
-fn run_regexes(hash: &HashMap<u32, (&'static str, String)>, contents: &str) -> String {
-    let mut working_string = contents.to_owned();
-    let hash_count: u32 = hash.len() as u32;
-    for n in 0..hash_count {
-        let value = hash.get(&n).expect("error getting hash at index");
-        //println!("{},{}", value.0, value.1);
-        let re = Regex::new(value.0).expect("problem with color regex");
-        let after = re.replace_all(&working_string, &value.1[..]).to_string();
-        working_string = after.clone();
-    }
-    working_string
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(ToHTML {})
-    }
-}

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

@@ -1,93 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::data::value::format_leaf;
-use crate::prelude::*;
-use futures::StreamExt;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue, Value};
-
-pub struct ToMarkdown;
-
-#[async_trait]
-impl WholeStreamCommand for ToMarkdown {
-    fn name(&self) -> &str {
-        "to md"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("to md")
-    }
-
-    fn usage(&self) -> &str {
-        "Convert table into simple Markdown"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        to_html(args, registry).await
-    }
-}
-
-async fn to_html(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
-    let name_tag = args.name_tag();
-    let input: Vec<Value> = args.input.collect().await;
-    let headers = nu_protocol::merge_descriptors(&input);
-    let mut output_string = String::new();
-
-    if !headers.is_empty() && (headers.len() > 1 || headers[0] != "") {
-        output_string.push_str("|");
-        for header in &headers {
-            output_string.push_str(&htmlescape::encode_minimal(&header));
-            output_string.push_str("|");
-        }
-        output_string.push_str("\n|");
-        for _ in &headers {
-            output_string.push_str("-");
-            output_string.push_str("|");
-        }
-        output_string.push_str("\n");
-    }
-
-    for row in input {
-        match row.value {
-            UntaggedValue::Row(row) => {
-                output_string.push_str("|");
-                for header in &headers {
-                    let data = row.get_data(header);
-                    output_string.push_str(&format_leaf(data.borrow()).plain_string(100_000));
-                    output_string.push_str("|");
-                }
-                output_string.push_str("\n");
-            }
-            p => {
-                output_string.push_str(
-                    &(htmlescape::encode_minimal(&format_leaf(&p).plain_string(100_000))),
-                );
-                output_string.push_str("\n");
-            }
-        }
-    }
-
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::string(output_string).into_value(name_tag),
-    )))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ToMarkdown;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(ToMarkdown {})
-    }
-}

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

@@ -1,72 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape};
-use nu_source::Tagged;
-use std::fs::OpenOptions;
-use std::path::PathBuf;
-
-pub struct Touch;
-
-#[derive(Deserialize)]
-pub struct TouchArgs {
-    pub target: Tagged<PathBuf>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Touch {
-    fn name(&self) -> &str {
-        "touch"
-    }
-    fn signature(&self) -> Signature {
-        Signature::build("touch").required(
-            "filename",
-            SyntaxShape::Path,
-            "the path of the file you want to create",
-        )
-    }
-    fn usage(&self) -> &str {
-        "creates a file"
-    }
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        touch(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Creates \"fixture.json\"",
-            example: "touch fixture.json",
-            result: None,
-        }]
-    }
-}
-
-async fn touch(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (TouchArgs { target }, _) = args.process(&registry).await?;
-
-    match OpenOptions::new().write(true).create(true).open(&target) {
-        Ok(_) => Ok(OutputStream::empty()),
-        Err(err) => Err(ShellError::labeled_error(
-            "File Error",
-            err.to_string(),
-            &target.tag,
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Touch;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Touch {})
-    }
-}

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

@@ -1,95 +0,0 @@
-use crate::commands::WholeStreamCommand;
-
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Dictionary, Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
-
-pub struct Trim;
-
-#[async_trait]
-impl WholeStreamCommand for Trim {
-    fn name(&self) -> &str {
-        "trim"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("trim")
-    }
-
-    fn usage(&self) -> &str {
-        "Trim leading and following whitespace from text data."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        trim(args, registry)
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Trims surrounding whitespace and outputs \"Hello world\"",
-            example: "echo \"    Hello world\" | trim",
-            result: Some(vec![Value::from("Hello world")]),
-        }]
-    }
-}
-
-fn trim_primitive(p: &mut Primitive) {
-    match p {
-        Primitive::String(s) | Primitive::Line(s) => *p = Primitive::String(s.trim().to_string()),
-        Primitive::Nothing
-        | Primitive::Int(_)
-        | Primitive::Decimal(_)
-        | Primitive::Filesize(_)
-        | Primitive::ColumnPath(_)
-        | Primitive::Pattern(_)
-        | Primitive::Boolean(_)
-        | Primitive::Date(_)
-        | Primitive::Duration(_)
-        | Primitive::Range(_)
-        | Primitive::Path(_)
-        | Primitive::Binary(_)
-        | Primitive::BeginningOfStream
-        | Primitive::EndOfStream => (),
-    }
-}
-
-fn trim_row(d: &mut Dictionary) {
-    for (_, mut value) in d.entries.iter_mut() {
-        trim_value(&mut value);
-    }
-}
-
-fn trim_value(v: &mut Value) {
-    match &mut v.value {
-        UntaggedValue::Primitive(p) => trim_primitive(p),
-        UntaggedValue::Row(row) => trim_row(row),
-        _ => (),
-    };
-}
-
-fn trim(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    Ok(args
-        .input
-        .map(|v| {
-            let mut trimmed = v;
-            trim_value(&mut trimmed);
-            ReturnSuccess::value(trimmed)
-        })
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Trim;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Trim {})
-    }
-}

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

@@ -1,177 +0,0 @@
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::context::CommandRegistry;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_value_ext::ValueExt;
-
-use futures::stream::once;
-pub struct Update;
-
-#[derive(Deserialize)]
-pub struct UpdateArgs {
-    field: ColumnPath,
-    replacement: Value,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Update {
-    fn name(&self) -> &str {
-        "update"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("update")
-            .required(
-                "field",
-                SyntaxShape::ColumnPath,
-                "the name of the column to update",
-            )
-            .required(
-                "replacement value",
-                SyntaxShape::Any,
-                "the new value to give the cell(s)",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Update an existing column to have a new value."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        update(args, registry).await
-    }
-}
-
-async fn process_row(
-    scope: Arc<Scope>,
-    mut context: Arc<Context>,
-    input: Value,
-    mut replacement: Arc<Value>,
-    field: Arc<ColumnPath>,
-) -> Result<OutputStream, ShellError> {
-    let replacement = Arc::make_mut(&mut replacement);
-
-    Ok(match replacement {
-        Value {
-            value: UntaggedValue::Block(block),
-            ..
-        } => {
-            let for_block = input.clone();
-            let input_stream = once(async { Ok(for_block) }).to_input_stream();
-
-            let result = run_block(
-                &block,
-                Arc::make_mut(&mut context),
-                input_stream,
-                &input,
-                &scope.vars,
-                &scope.env,
-            )
-            .await;
-
-            match result {
-                Ok(mut stream) => {
-                    let errors = context.get_errors();
-                    if let Some(error) = errors.first() {
-                        return Err(error.clone());
-                    }
-
-                    match input {
-                        obj
-                        @
-                        Value {
-                            value: UntaggedValue::Row(_),
-                            ..
-                        } => {
-                            if let Some(result) = stream.next().await {
-                                match obj.replace_data_at_column_path(&field, result) {
-                                    Some(v) => OutputStream::one(ReturnSuccess::value(v)),
-                                    None => OutputStream::one(Err(ShellError::labeled_error(
-                                        "update could not find place to insert column",
-                                        "column name",
-                                        obj.tag,
-                                    ))),
-                                }
-                            } else {
-                                OutputStream::empty()
-                            }
-                        }
-                        Value { tag, .. } => OutputStream::one(Err(ShellError::labeled_error(
-                            "Unrecognized type in stream",
-                            "original value",
-                            tag,
-                        ))),
-                    }
-                }
-                Err(e) => OutputStream::one(Err(e)),
-            }
-        }
-        _ => match input {
-            obj
-            @
-            Value {
-                value: UntaggedValue::Row(_),
-                ..
-            } => match obj.replace_data_at_column_path(&field, replacement.clone()) {
-                Some(v) => OutputStream::one(ReturnSuccess::value(v)),
-                None => OutputStream::one(Err(ShellError::labeled_error(
-                    "update could not find place to insert column",
-                    "column name",
-                    obj.tag,
-                ))),
-            },
-            Value { tag, .. } => OutputStream::one(Err(ShellError::labeled_error(
-                "Unrecognized type in stream",
-                "original value",
-                tag,
-            ))),
-        },
-    })
-}
-
-async fn update(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let scope = Arc::new(raw_args.call_info.scope.clone());
-    let context = Arc::new(Context::from_raw(&raw_args, &registry));
-    let (UpdateArgs { field, replacement }, input) = raw_args.process(&registry).await?;
-    let replacement = Arc::new(replacement);
-    let field = Arc::new(field);
-
-    Ok(input
-        .then(move |input| {
-            let replacement = replacement.clone();
-            let scope = scope.clone();
-            let context = context.clone();
-            let field = field.clone();
-
-            async {
-                match process_row(scope, context, input, replacement, field).await {
-                    Ok(s) => s,
-                    Err(e) => OutputStream::one(Err(e)),
-                }
-            }
-        })
-        .flatten()
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Update;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Update {})
-    }
-}

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

@@ -1,63 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use indexmap::IndexMap;
-use nu_errors::ShellError;
-use nu_protocol::{Dictionary, Signature, UntaggedValue};
-
-pub struct Version;
-
-#[async_trait]
-impl WholeStreamCommand for Version {
-    fn name(&self) -> &str {
-        "version"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("version")
-    }
-
-    fn usage(&self) -> &str {
-        "Display Nu version"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        version(args, registry)
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Display Nu version",
-            example: "version",
-            result: None,
-        }]
-    }
-}
-
-pub fn version(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let tag = args.call_info.args.span;
-
-    let mut indexmap = IndexMap::new();
-    indexmap.insert(
-        "version".to_string(),
-        UntaggedValue::string(clap::crate_version!()).into_value(&tag),
-    );
-
-    let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);
-    Ok(OutputStream::one(value))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Version;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Version {})
-    }
-}

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

@@ -1,133 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use indexmap::map::IndexMap;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
-
-pub struct Which;
-
-#[async_trait]
-impl WholeStreamCommand for Which {
-    fn name(&self) -> &str {
-        "which"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("which")
-            .required("application", SyntaxShape::String, "application")
-            .switch("all", "list all executables", Some('a'))
-    }
-
-    fn usage(&self) -> &str {
-        "Finds a program file."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        which(args, registry).await
-    }
-}
-
-/// Shortcuts for creating an entry to the output table
-fn entry(arg: impl Into<String>, path: Value, builtin: bool, tag: Tag) -> Value {
-    let mut map = IndexMap::new();
-    map.insert(
-        "arg".to_string(),
-        UntaggedValue::Primitive(Primitive::String(arg.into())).into_value(tag.clone()),
-    );
-    map.insert("path".to_string(), path);
-    map.insert(
-        "builtin".to_string(),
-        UntaggedValue::Primitive(Primitive::Boolean(builtin)).into_value(tag.clone()),
-    );
-
-    UntaggedValue::row(map).into_value(tag)
-}
-
-macro_rules! entry_builtin {
-    ($arg:expr, $tag:expr) => {
-        entry(
-            $arg.clone(),
-            UntaggedValue::Primitive(Primitive::String("nushell built-in command".to_string()))
-                .into_value($tag.clone()),
-            true,
-            $tag,
-        )
-    };
-}
-
-#[allow(unused)]
-macro_rules! entry_path {
-    ($arg:expr, $path:expr, $tag:expr) => {
-        entry(
-            $arg.clone(),
-            UntaggedValue::Primitive(Primitive::Path($path)).into_value($tag.clone()),
-            false,
-            $tag,
-        )
-    };
-}
-
-#[derive(Deserialize, Debug)]
-struct WhichArgs {
-    application: Tagged<String>,
-    all: bool,
-}
-
-async fn which(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    let mut output = vec![];
-
-    let (WhichArgs { application, all }, _) = args.process(&registry).await?;
-    let external = application.starts_with('^');
-    let item = if external {
-        application.item[1..].to_string()
-    } else {
-        application.item.clone()
-    };
-    if !external {
-        let builtin = registry.has(&item);
-        if builtin {
-            output.push(ReturnSuccess::value(entry_builtin!(
-                item,
-                application.tag.clone()
-            )));
-        }
-    }
-
-    #[cfg(feature = "ichwh")]
-    {
-        if let Ok(paths) = ichwh::which_all(&item).await {
-            for path in paths {
-                output.push(ReturnSuccess::value(entry_path!(
-                    item,
-                    path.into(),
-                    application.tag.clone()
-                )));
-            }
-        }
-    }
-
-    if all {
-        Ok(futures::stream::iter(output.into_iter()).to_output_stream())
-    } else {
-        Ok(futures::stream::iter(output.into_iter().take(1)).to_output_stream())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Which;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(Which {})
-    }
-}

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

@@ -1,92 +0,0 @@
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{hir::Block, Signature, SyntaxShape, Value};
-use nu_source::Tagged;
-
-pub struct WithEnv;
-
-#[derive(Deserialize, Debug)]
-struct WithEnvArgs {
-    variable: (Tagged<String>, Tagged<String>),
-    block: Block,
-}
-
-#[async_trait]
-impl WholeStreamCommand for WithEnv {
-    fn name(&self) -> &str {
-        "with-env"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("with-env")
-            .required(
-                "variable",
-                SyntaxShape::Any,
-                "the environment variable to temporarily set",
-            )
-            .required(
-                "block",
-                SyntaxShape::Block,
-                "the block to run once the variable is set",
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Runs a block with an environment set. Eg) with-env [NAME 'foo'] { echo $nu.env.NAME }"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        with_env(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Set the MYENV environment variable",
-            example: r#"with-env [MYENV "my env value"] { echo $nu.env.MYENV }"#,
-            result: Some(vec![Value::from("my env value")]),
-        }]
-    }
-}
-
-async fn with_env(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-
-    let mut context = Context::from_raw(&raw_args, &registry);
-    let mut scope = raw_args.call_info.scope.clone();
-    let (WithEnvArgs { variable, block }, input) = raw_args.process(&registry).await?;
-
-    scope.env.insert(variable.0.item, variable.1.item);
-
-    let result = run_block(
-        &block,
-        &mut context,
-        input,
-        &scope.it,
-        &scope.vars,
-        &scope.env,
-    )
-    .await;
-
-    result.map(|x| x.to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::WithEnv;
-
-    #[test]
-    fn examples_work_as_expected() {
-        use crate::examples::test as test_examples;
-
-        test_examples(WithEnv {})
-    }
-}

crates/nu-cli/src/completion.rs

@@ -1,26 +0,0 @@
-use nu_errors::ShellError;
-
-#[derive(Debug, Eq, PartialEq)]
-pub struct Suggestion {
-    pub display: String,
-    pub replacement: String,
-}
-
-pub struct Context<'a>(pub &'a rustyline::Context<'a>);
-
-impl<'a> AsRef<rustyline::Context<'a>> for Context<'a> {
-    fn as_ref(&self) -> &rustyline::Context<'a> {
-        self.0
-    }
-}
-
-pub trait Completer {
-    fn complete(
-        &self,
-        line: &str,
-        pos: usize,
-        ctx: &Context<'_>,
-    ) -> Result<(usize, Vec<Suggestion>), ShellError>;
-
-    fn hint(&self, line: &str, pos: usize, ctx: &Context<'_>) -> Option<String>;
-}

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

@@ -0,0 +1,141 @@
+use std::iter::FromIterator;
+use std::path::Path;
+
+use indexmap::set::IndexSet;
+
+use super::matchers::Matcher;
+use crate::completion::{Completer, CompletionContext, Suggestion};
+use nu_engine::EvaluationContext;
+
+pub struct CommandCompleter;
+
+impl Completer for CommandCompleter {
+    fn complete(
+        &self,
+        ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion> {
+        let context: &EvaluationContext = ctx.as_ref();
+        let mut commands: IndexSet<String> = IndexSet::from_iter(context.scope.get_command_names());
+
+        // Command suggestions can come from three possible sets:
+        //   1. internal command names,
+        //   2. external command names relative to PATH env var, and
+        //   3. any other executable (that matches what's been typed so far).
+
+        let path_executables = find_path_executables().unwrap_or_default();
+
+        // TODO quote these, if necessary
+        commands.extend(path_executables.into_iter());
+
+        let mut suggestions: Vec<_> = commands
+            .into_iter()
+            .filter(|v| matcher.matches(partial, v))
+            .map(|v| Suggestion {
+                replacement: v.clone(),
+                display: v,
+            })
+            .collect();
+
+        if !partial.is_empty() {
+            let path_completer = crate::completion::path::PathCompleter;
+            let path_results = path_completer.path_suggestions(partial, matcher);
+            let iter = path_results.into_iter().filter_map(|path_suggestion| {
+                let path = path_suggestion.path;
+                if path.is_dir() || is_executable(&path) {
+                    Some(path_suggestion.suggestion)
+                } else {
+                    None
+                }
+            });
+
+            suggestions.extend(iter);
+        }
+
+        suggestions
+    }
+}
+
+// TODO create a struct for "is executable" and store this information in it so we don't recompute
+//      on every dir entry
+
+#[cfg(windows)]
+fn pathext() -> Option<Vec<String>> {
+    std::env::var_os("PATHEXT").map(|v| {
+        v.to_string_lossy()
+            .split(';')
+            // Filter out empty tokens and ';' at the end
+            .filter(|f| f.len() > 1)
+            // Cut off the leading '.' character
+            .map(|ext| ext[1..].to_string())
+            .collect::<Vec<_>>()
+    })
+}
+
+#[cfg(windows)]
+fn is_executable(path: &Path) -> bool {
+    if let Ok(metadata) = path.metadata() {
+        let file_type = metadata.file_type();
+
+        // If the entry isn't a file, it cannot be executable
+        if !(file_type.is_file() || file_type.is_symlink()) {
+            return false;
+        }
+
+        if let Some(extension) = path.extension() {
+            if let Some(exts) = pathext() {
+                exts.iter()
+                    .any(|ext| extension.to_string_lossy().eq_ignore_ascii_case(ext))
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+fn is_executable(_path: &Path) -> bool {
+    false
+}
+
+#[cfg(unix)]
+fn is_executable(path: &Path) -> bool {
+    use std::os::unix::fs::PermissionsExt;
+
+    if let Ok(metadata) = path.metadata() {
+        let filetype = metadata.file_type();
+        let permissions = metadata.permissions();
+
+        // The file is executable if it is a directory or a symlink and the permissions are set for
+        // owner, group, or other
+        (filetype.is_file() || filetype.is_symlink()) && (permissions.mode() & 0o111 != 0)
+    } else {
+        false
+    }
+}
+
+// TODO cache these, but watch for changes to PATH
+fn find_path_executables() -> Option<IndexSet<String>> {
+    let path_var = std::env::var_os("PATH")?;
+    let paths: Vec<_> = std::env::split_paths(&path_var).collect();
+
+    let mut executables: IndexSet<String> = IndexSet::new();
+    for path in paths {
+        if let Ok(mut contents) = std::fs::read_dir(path) {
+            while let Some(Ok(item)) = contents.next() {
+                if is_executable(&item.path()) {
+                    if let Ok(name) = item.file_name().into_string() {
+                        executables.insert(name);
+                    }
+                }
+            }
+        }
+    }
+
+    Some(executables)
+}

crates/nu-cli/src/completion/engine.rs

@@ -0,0 +1,434 @@
+use nu_protocol::hir::*;
+use nu_source::{Span, Spanned, SpannedItem};
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum LocationType {
+    Command,
+    Flag(String),                             // command name
+    Argument(Option<String>, Option<String>), // command name, argument name
+    Variable,
+}
+
+pub type CompletionLocation = Spanned<LocationType>;
+
+// TODO The below is very similar to shapes / expression_to_flat_shape. Check back October 2020
+//      to see if we're close enough to just make use of those.
+
+struct Flatten<'s> {
+    line: &'s str,
+    command: Option<String>,
+    flag: Option<String>,
+}
+
+impl<'s> Flatten<'s> {
+    /// Converts a SpannedExpression into a completion location for use in NuCompleter
+    fn expression(&self, e: &SpannedExpression) -> Vec<CompletionLocation> {
+        match &e.expr {
+            Expression::Block(block) => self.completion_locations(block),
+            Expression::Invocation(block) => self.completion_locations(block),
+            Expression::List(exprs) => exprs.iter().flat_map(|v| self.expression(v)).collect(),
+            Expression::Table(headers, cells) => headers
+                .iter()
+                .flat_map(|v| self.expression(v))
+                .chain(
+                    cells
+                        .iter()
+                        .flat_map(|v| v.iter().flat_map(|v| self.expression(v))),
+                )
+                .collect(),
+            Expression::Command => vec![LocationType::Command.spanned(e.span)],
+            Expression::Path(path) => self.expression(&path.head),
+            Expression::Variable(_, _) => vec![LocationType::Variable.spanned(e.span)],
+
+            Expression::Boolean(_)
+            | Expression::FilePath(_)
+            | Expression::Literal(Literal::ColumnPath(_))
+            | Expression::Literal(Literal::GlobPattern(_))
+            | Expression::Literal(Literal::Number(_))
+            | Expression::Literal(Literal::Size(_, _))
+            | Expression::Literal(Literal::String(_)) => {
+                vec![
+                    LocationType::Argument(self.command.clone(), self.flag.clone()).spanned(e.span),
+                ]
+            }
+
+            Expression::Binary(binary) => {
+                let mut result = Vec::new();
+                result.append(&mut self.expression(&binary.left));
+                result.append(&mut self.expression(&binary.right));
+                result
+            }
+            Expression::Range(range) => {
+                let mut result = Vec::new();
+                if let Some(left) = &range.left {
+                    result.append(&mut self.expression(left));
+                }
+                if let Some(right) = &range.right {
+                    result.append(&mut self.expression(right));
+                }
+                result
+            }
+
+            Expression::ExternalWord
+            | Expression::ExternalCommand(_)
+            | Expression::Synthetic(_)
+            | Expression::Literal(Literal::Operator(_))
+            | Expression::Literal(Literal::Bare(_))
+            | Expression::Garbage => Vec::new(),
+        }
+    }
+
+    fn internal_command(&self, internal: &InternalCommand) -> Vec<CompletionLocation> {
+        let mut result = Vec::new();
+
+        match internal.args.head.expr {
+            Expression::Command => {
+                result.push(LocationType::Command.spanned(internal.name_span));
+            }
+            Expression::Literal(Literal::String(_)) => {
+                result.push(LocationType::Command.spanned(internal.name_span));
+            }
+            _ => (),
+        }
+
+        if let Some(positionals) = &internal.args.positional {
+            let mut positionals = positionals.iter();
+
+            if internal.name == "run_external" {
+                if let Some(external_command) = positionals.next() {
+                    result.push(LocationType::Command.spanned(external_command.span));
+                }
+            }
+
+            result.extend(positionals.flat_map(|positional| match positional.expr {
+                Expression::Garbage => {
+                    let garbage = positional.span.slice(self.line);
+                    let location = if garbage.starts_with('-') {
+                        LocationType::Flag(internal.name.clone())
+                    } else {
+                        // TODO we may be able to map this to the name of a positional,
+                        //      but we'll need a signature
+                        LocationType::Argument(Some(internal.name.clone()), None)
+                    };
+
+                    vec![location.spanned(positional.span)]
+                }
+
+                _ => self.expression(positional),
+            }));
+        }
+
+        if let Some(named) = &internal.args.named {
+            for (name, kind) in &named.named {
+                match kind {
+                    NamedValue::PresentSwitch(span) => {
+                        result.push(LocationType::Flag(internal.name.clone()).spanned(*span));
+                    }
+
+                    NamedValue::Value(span, expr) => {
+                        result.push(LocationType::Flag(internal.name.clone()).spanned(*span));
+                        result.append(&mut self.with_flag(name.clone()).expression(expr));
+                    }
+
+                    _ => (),
+                }
+            }
+        }
+
+        result
+    }
+
+    fn pipeline(&self, pipeline: &Pipeline) -> Vec<CompletionLocation> {
+        let mut result = Vec::new();
+
+        for command in &pipeline.list {
+            match command {
+                ClassifiedCommand::Internal(internal) => {
+                    let engine = self.with_command(internal.name.clone());
+                    result.append(&mut engine.internal_command(internal));
+                }
+
+                ClassifiedCommand::Expr(expr) => result.append(&mut self.expression(expr)),
+                _ => (),
+            }
+        }
+
+        result
+    }
+
+    /// Flattens the block into a Vec of completion locations
+    pub fn completion_locations(&self, block: &Block) -> Vec<CompletionLocation> {
+        block
+            .block
+            .iter()
+            .flat_map(|g| g.pipelines.iter().flat_map(|v| self.pipeline(v)))
+            .collect()
+    }
+
+    pub fn new(line: &'s str) -> Flatten<'s> {
+        Flatten {
+            line,
+            command: None,
+            flag: None,
+        }
+    }
+
+    pub fn with_command(&self, command: String) -> Flatten<'s> {
+        Flatten {
+            line: self.line,
+            command: Some(command),
+            flag: None,
+        }
+    }
+
+    pub fn with_flag(&self, flag: String) -> Flatten<'s> {
+        Flatten {
+            line: self.line,
+            command: self.command.clone(),
+            flag: Some(flag),
+        }
+    }
+}
+
+/// Characters that precede a command name
+const BEFORE_COMMAND_CHARS: &[char] = &['|', '(', ';'];
+
+/// Determines the completion location for a given block at the given cursor position
+pub fn completion_location(line: &str, block: &Block, pos: usize) -> Vec<CompletionLocation> {
+    let completion_engine = Flatten::new(line);
+    let locations = completion_engine.completion_locations(block);
+
+    if locations.is_empty() {
+        vec![LocationType::Command.spanned(Span::unknown())]
+    } else {
+        let mut command = None;
+        let mut prev = None;
+        for loc in locations {
+            // We don't use span.contains because we want to include the end. This handles the case
+            // where the cursor is just after the text (i.e., no space between cursor and text)
+            if loc.span.start() <= pos && pos <= loc.span.end() {
+                // The parser sees the "-" in `cmd -` as an argument, but the user is likely
+                // expecting a flag.
+                return match loc.item {
+                    LocationType::Argument(ref cmd, _) => {
+                        if loc.span.slice(line) == "-" {
+                            let cmd = cmd.clone();
+                            let span = loc.span;
+                            vec![
+                                loc,
+                                LocationType::Flag(cmd.unwrap_or_default()).spanned(span),
+                            ]
+                        } else {
+                            vec![loc]
+                        }
+                    }
+                    _ => vec![loc],
+                };
+            } else if pos < loc.span.start() {
+                break;
+            }
+
+            if let LocationType::Command = loc.item {
+                command = Some(String::from(loc.span.slice(line)));
+            }
+
+            prev = Some(loc);
+        }
+
+        if let Some(prev) = prev {
+            // Cursor is between locations (or at the end). Look at the line to see if the cursor
+            // is after some character that would imply we're in the command position.
+            let start = prev.span.end();
+            if line[start..pos].contains(BEFORE_COMMAND_CHARS) {
+                vec![LocationType::Command.spanned(Span::new(pos, pos))]
+            } else {
+                // TODO this should be able to be mapped to a command
+                vec![LocationType::Argument(command, None).spanned(Span::new(pos, pos))]
+            }
+        } else {
+            // Cursor is before any possible completion location, so must be a command
+            vec![LocationType::Command.spanned(Span::unknown())]
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use nu_parser::{classify_block, lex, parse_block, ParserScope};
+    use nu_protocol::{Signature, SyntaxShape};
+
+    #[derive(Clone, Debug)]
+    struct VecRegistry(Vec<Signature>);
+
+    impl From<Vec<Signature>> for VecRegistry {
+        fn from(v: Vec<Signature>) -> Self {
+            VecRegistry(v)
+        }
+    }
+
+    impl ParserScope for VecRegistry {
+        fn has_signature(&self, name: &str) -> bool {
+            self.0.iter().any(|v| v.name == name)
+        }
+
+        fn get_signature(&self, name: &str) -> Option<nu_protocol::Signature> {
+            self.0.iter().find(|v| v.name == name).map(Clone::clone)
+        }
+
+        fn get_alias(&self, _name: &str) -> Option<Vec<Spanned<String>>> {
+            None
+        }
+
+        fn add_alias(&self, _name: &str, _replacement: Vec<Spanned<String>>) {
+            todo!()
+        }
+
+        fn add_definition(&self, _block: Block) {}
+
+        fn get_definitions(&self) -> Vec<Block> {
+            vec![]
+        }
+
+        fn enter_scope(&self) {}
+
+        fn exit_scope(&self) {}
+    }
+
+    mod completion_location {
+        use super::*;
+
+        use nu_parser::ParserScope;
+
+        fn completion_location(
+            line: &str,
+            scope: &dyn ParserScope,
+            pos: usize,
+        ) -> Vec<LocationType> {
+            let (tokens, _) = lex(line, 0);
+            let (lite_block, _) = parse_block(tokens);
+
+            scope.enter_scope();
+            let (block, _) = classify_block(&lite_block, scope);
+            scope.exit_scope();
+
+            super::completion_location(line, &block, pos)
+                .into_iter()
+                .map(|v| v.item)
+                .collect()
+        }
+
+        #[test]
+        fn completes_internal_command_names() {
+            let registry: VecRegistry =
+                vec![Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")].into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 10),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn completes_external_command_names() {
+            let registry: VecRegistry = Vec::new().into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 10),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn completes_command_names_when_cursor_immediately_after_command_name() {
+            let registry: VecRegistry = Vec::new().into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 4),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn completes_variables() {
+            let registry: VecRegistry = Vec::new().into();
+            let line = "echo $nu.env.";
+
+            assert_eq!(
+                completion_location(line, &registry, 13),
+                vec![LocationType::Variable],
+            );
+        }
+
+        #[test]
+        fn completes_flags() {
+            let registry: VecRegistry = vec![Signature::build("du")
+                .switch("recursive", "the values to echo", None)
+                .rest(SyntaxShape::Any, "blah")]
+            .into();
+
+            let line = "du --recurs";
+
+            assert_eq!(
+                completion_location(line, &registry, 7),
+                vec![LocationType::Flag("du".to_string())],
+            );
+        }
+
+        #[test]
+        fn completes_incomplete_nested_structure() {
+            let registry: VecRegistry = vec![Signature::build("sys")].into();
+            let line = "echo $(sy";
+
+            assert_eq!(
+                completion_location(line, &registry, 8),
+                vec![LocationType::Command],
+            );
+        }
+
+        #[test]
+        fn has_correct_command_name_for_argument() {
+            let registry: VecRegistry = vec![Signature::build("cd")].into();
+            let line = "cd ";
+
+            assert_eq!(
+                completion_location(line, &registry, 3),
+                vec![LocationType::Argument(Some("cd".to_string()), None)],
+            );
+        }
+
+        #[test]
+        fn completes_flags_with_just_a_single_hyphen() {
+            let registry: VecRegistry = vec![Signature::build("du")
+                .switch("recursive", "the values to echo", None)
+                .rest(SyntaxShape::Any, "blah")]
+            .into();
+
+            let line = "du -";
+
+            assert_eq!(
+                completion_location(line, &registry, 3),
+                vec![
+                    LocationType::Argument(Some("du".to_string()), None),
+                    LocationType::Flag("du".to_string()),
+                ],
+            );
+        }
+
+        #[test]
+        fn completes_arguments() {
+            let registry: VecRegistry =
+                vec![Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")].into();
+            let line = "echo 1 | echo 2";
+
+            assert_eq!(
+                completion_location(line, &registry, 6),
+                vec![LocationType::Argument(Some("echo".to_string()), None)],
+            );
+        }
+    }
+}

crates/nu-cli/src/completion/flag.rs

@@ -0,0 +1,41 @@
+use super::matchers::Matcher;
+use crate::completion::{Completer, CompletionContext, Suggestion};
+use nu_engine::EvaluationContext;
+
+pub struct FlagCompleter {
+    pub(crate) cmd: String,
+}
+
+impl Completer for FlagCompleter {
+    fn complete(
+        &self,
+        ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion> {
+        let context: &EvaluationContext = ctx.as_ref();
+
+        if let Some(cmd) = context.scope.get_command(&self.cmd) {
+            let sig = cmd.signature();
+            let mut suggestions = Vec::new();
+            for (name, (named_type, _desc)) in sig.named.iter() {
+                suggestions.push(format!("--{}", name));
+
+                if let Some(c) = named_type.get_short() {
+                    suggestions.push(format!("-{}", c));
+                }
+            }
+
+            suggestions
+                .into_iter()
+                .filter(|v| matcher.matches(partial, v))
+                .map(|v| Suggestion {
+                    replacement: format!("{} ", v),
+                    display: v,
+                })
+                .collect()
+        } else {
+            Vec::new()
+        }
+    }
+}

crates/nu-cli/src/completion/matchers/case_insensitive.rs

@@ -0,0 +1,45 @@
+use crate::completion::matchers;
+pub struct Matcher;
+
+impl matchers::Matcher for Matcher {
+    fn matches(&self, partial: &str, from: &str) -> bool {
+        from.to_ascii_lowercase()
+            .starts_with(partial.to_ascii_lowercase().as_str())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // TODO: check some unicode matches if this becomes relevant
+
+    // FIXME: could work exhaustively through ['-', '--'. ''] in a loop for each test
+    #[test]
+    fn completes_exact_matches() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        assert!(matcher.matches("shouldmatch", "shouldmatch"));
+        assert!(matcher.matches("shouldm", "shouldmatch"));
+        assert!(matcher.matches("--also-should-m", "--also-should-match"));
+        assert!(matcher.matches("-also-should-m", "-also-should-match"));
+    }
+
+    #[test]
+    fn completes_case_insensitive_matches() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        assert!(matcher.matches("thisshould", "Thisshouldmatch"));
+        assert!(matcher.matches("--Shouldm", "--shouldmatch"));
+        assert!(matcher.matches("-Shouldm", "-shouldmatch"));
+    }
+
+    #[test]
+    fn should_not_match_when_unequal() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        assert!(!matcher.matches("ashouldmatch", "Shouldnotmatch"));
+        assert!(!matcher.matches("--ashouldnotmatch", "--Shouldnotmatch"));
+        assert!(!matcher.matches("-ashouldnotmatch", "-Shouldnotmatch"));
+    }
+}

crates/nu-cli/src/completion/matchers/case_sensitive.rs

@@ -0,0 +1,28 @@
+use crate::completion::matchers;
+
+pub struct Matcher;
+
+impl matchers::Matcher for Matcher {
+    fn matches(&self, partial: &str, from: &str) -> bool {
+        from.starts_with(partial)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn completes_case_sensitive() {
+        let matcher: Box<dyn matchers::Matcher> = Box::new(Matcher);
+
+        //Should match
+        assert!(matcher.matches("shouldmatch", "shouldmatch"));
+        assert!(matcher.matches("shouldm", "shouldmatch"));
+        assert!(matcher.matches("--also-should-m", "--also-should-match"));
+        assert!(matcher.matches("-also-should-m", "-also-should-match"));
+
+        // Should not match
+        assert!(!matcher.matches("--Shouldnot", "--shouldnotmatch"));
+    }
+}

crates/nu-cli/src/completion/matchers/mod.rs

@@ -0,0 +1,6 @@
+pub(crate) mod case_insensitive;
+pub(crate) mod case_sensitive;
+
+pub trait Matcher {
+    fn matches(&self, partial: &str, from: &str) -> bool;
+}

crates/nu-cli/src/completion/mod.rs

@@ -0,0 +1,37 @@
+pub(crate) mod command;
+pub(crate) mod engine;
+pub(crate) mod flag;
+pub(crate) mod matchers;
+pub(crate) mod path;
+
+use matchers::Matcher;
+use nu_engine::EvaluationContext;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Suggestion {
+    pub display: String,
+    pub replacement: String,
+}
+
+pub struct CompletionContext<'a>(&'a EvaluationContext);
+
+impl<'a> CompletionContext<'a> {
+    pub fn new(a: &'a EvaluationContext) -> CompletionContext<'a> {
+        CompletionContext(a)
+    }
+}
+
+impl<'a> AsRef<EvaluationContext> for CompletionContext<'a> {
+    fn as_ref(&self) -> &EvaluationContext {
+        self.0
+    }
+}
+
+pub trait Completer {
+    fn complete(
+        &self,
+        ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion>;
+}

crates/nu-cli/src/completion/path.rs

@@ -0,0 +1,88 @@
+use std::path::PathBuf;
+
+use super::matchers::Matcher;
+use crate::completion::{Completer, CompletionContext, Suggestion};
+
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+pub struct PathCompleter;
+
+pub struct PathSuggestion {
+    pub(crate) path: PathBuf,
+    pub(crate) suggestion: Suggestion,
+}
+
+impl PathCompleter {
+    pub fn path_suggestions(&self, partial: &str, matcher: &dyn Matcher) -> Vec<PathSuggestion> {
+        let expanded = nu_parser::expand_ndots(partial);
+        let expanded = expanded.as_ref();
+
+        let (base_dir_name, partial) = match expanded.rfind(SEP) {
+            Some(pos) => expanded.split_at(pos + SEP.len_utf8()),
+            None => ("", expanded),
+        };
+
+        let base_dir = if base_dir_name.is_empty() {
+            PathBuf::from(".")
+        } else {
+            #[cfg(feature = "directories")]
+            {
+                let home_prefix = format!("~{}", SEP);
+                if base_dir_name.starts_with(&home_prefix) {
+                    let mut home_dir = dirs_next::home_dir().unwrap_or_else(|| PathBuf::from("~"));
+                    home_dir.push(&base_dir_name[2..]);
+                    home_dir
+                } else {
+                    PathBuf::from(base_dir_name)
+                }
+            }
+            #[cfg(not(feature = "directories"))]
+            {
+                PathBuf::from(base_dir_name)
+            }
+        };
+
+        if let Ok(result) = base_dir.read_dir() {
+            result
+                .filter_map(|entry| {
+                    entry.ok().and_then(|entry| {
+                        let mut file_name = entry.file_name().to_string_lossy().into_owned();
+                        if matcher.matches(partial, file_name.as_str()) {
+                            let mut path = format!("{}{}", base_dir_name, file_name);
+                            if entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false) {
+                                path.push(std::path::MAIN_SEPARATOR);
+                                file_name.push(std::path::MAIN_SEPARATOR);
+                            }
+
+                            Some(PathSuggestion {
+                                path: entry.path(),
+                                suggestion: Suggestion {
+                                    replacement: path,
+                                    display: file_name,
+                                },
+                            })
+                        } else {
+                            None
+                        }
+                    })
+                })
+                .collect()
+        } else {
+            Vec::new()
+        }
+    }
+}
+
+impl Completer for PathCompleter {
+    fn complete(
+        &self,
+        _ctx: &CompletionContext<'_>,
+        partial: &str,
+        matcher: &dyn Matcher,
+    ) -> Vec<Suggestion> {
+        self.path_suggestions(partial, matcher)
+            .into_iter()
+            .map(|ps| ps.suggestion)
+            .collect()
+    }
+}

crates/nu-cli/src/context.rs

@@ -1,284 +0,0 @@
-use crate::commands::{command::CommandArgs, Command, UnevaluatedCallInfo};
-use crate::env::host::Host;
-use crate::shell::shell_manager::ShellManager;
-use crate::stream::{InputStream, OutputStream};
-use indexmap::IndexMap;
-use nu_errors::ShellError;
-use nu_parser::SignatureRegistry;
-use nu_protocol::{hir, Scope, Signature};
-use nu_source::{Tag, Text};
-use parking_lot::Mutex;
-use std::error::Error;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
-#[derive(Debug, Clone, Default)]
-pub struct CommandRegistry {
-    registry: Arc<Mutex<IndexMap<String, Command>>>,
-}
-
-impl SignatureRegistry for CommandRegistry {
-    fn has(&self, name: &str) -> bool {
-        let registry = self.registry.lock();
-        registry.contains_key(name)
-    }
-    fn get(&self, name: &str) -> Option<Signature> {
-        let registry = self.registry.lock();
-        registry.get(name).map(|command| command.signature())
-    }
-    fn clone_box(&self) -> Box<dyn SignatureRegistry> {
-        Box::new(self.clone())
-    }
-}
-
-impl CommandRegistry {
-    pub fn new() -> CommandRegistry {
-        CommandRegistry {
-            registry: Arc::new(Mutex::new(IndexMap::default())),
-        }
-    }
-}
-
-impl CommandRegistry {
-    pub fn get_command(&self, name: &str) -> Option<Command> {
-        let registry = self.registry.lock();
-
-        registry.get(name).cloned()
-    }
-
-    pub fn expect_command(&self, name: &str) -> Result<Command, ShellError> {
-        self.get_command(name).ok_or_else(|| {
-            ShellError::untagged_runtime_error(format!("Could not load command: {}", name))
-        })
-    }
-
-    pub fn has(&self, name: &str) -> bool {
-        let registry = self.registry.lock();
-
-        registry.contains_key(name)
-    }
-
-    pub fn insert(&mut self, name: impl Into<String>, command: Command) {
-        let mut registry = self.registry.lock();
-        registry.insert(name.into(), command);
-    }
-
-    pub fn names(&self) -> Vec<String> {
-        let registry = self.registry.lock();
-        registry.keys().cloned().collect()
-    }
-}
-
-#[derive(Clone)]
-pub struct Context {
-    pub registry: CommandRegistry,
-    pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
-    pub current_errors: Arc<Mutex<Vec<ShellError>>>,
-    pub ctrl_c: Arc<AtomicBool>,
-    pub raw_input: String,
-    pub user_recently_used_autoenv_untrust: bool,
-    pub(crate) shell_manager: ShellManager,
-
-    #[cfg(windows)]
-    pub windows_drives_previous_cwd: Arc<Mutex<std::collections::HashMap<String, String>>>,
-}
-
-impl Context {
-    pub(crate) fn registry(&self) -> &CommandRegistry {
-        &self.registry
-    }
-
-    pub(crate) fn from_raw(raw_args: &CommandArgs, registry: &CommandRegistry) -> Context {
-        #[cfg(windows)]
-        {
-            Context {
-                registry: registry.clone(),
-                host: raw_args.host.clone(),
-                current_errors: raw_args.current_errors.clone(),
-                ctrl_c: raw_args.ctrl_c.clone(),
-                shell_manager: raw_args.shell_manager.clone(),
-                user_recently_used_autoenv_untrust: false,
-                windows_drives_previous_cwd: Arc::new(Mutex::new(std::collections::HashMap::new())),
-                raw_input: String::default(),
-            }
-        }
-        #[cfg(not(windows))]
-        {
-            Context {
-                registry: registry.clone(),
-                host: raw_args.host.clone(),
-                current_errors: raw_args.current_errors.clone(),
-                ctrl_c: raw_args.ctrl_c.clone(),
-                shell_manager: raw_args.shell_manager.clone(),
-                user_recently_used_autoenv_untrust: false,
-                raw_input: String::default(),
-            }
-        }
-    }
-
-    pub(crate) fn from_args(args: &CommandArgs, registry: &CommandRegistry) -> Context {
-        #[cfg(windows)]
-        {
-            Context {
-                registry: registry.clone(),
-                host: args.host.clone(),
-                current_errors: args.current_errors.clone(),
-                ctrl_c: args.ctrl_c.clone(),
-                shell_manager: args.shell_manager.clone(),
-                user_recently_used_autoenv_untrust: false,
-                windows_drives_previous_cwd: Arc::new(Mutex::new(std::collections::HashMap::new())),
-                raw_input: String::default(),
-            }
-        }
-        #[cfg(not(windows))]
-        {
-            Context {
-                registry: registry.clone(),
-                host: args.host.clone(),
-                current_errors: args.current_errors.clone(),
-                ctrl_c: args.ctrl_c.clone(),
-                user_recently_used_autoenv_untrust: false,
-                shell_manager: args.shell_manager.clone(),
-                raw_input: String::default(),
-            }
-        }
-    }
-
-    pub fn basic() -> Result<Context, Box<dyn Error>> {
-        let registry = CommandRegistry::new();
-
-        #[cfg(windows)]
-        {
-            Ok(Context {
-                registry: registry.clone(),
-                host: Arc::new(parking_lot::Mutex::new(Box::new(
-                    crate::env::host::BasicHost,
-                ))),
-                current_errors: Arc::new(Mutex::new(vec![])),
-                ctrl_c: Arc::new(AtomicBool::new(false)),
-                user_recently_used_autoenv_untrust: false,
-                shell_manager: ShellManager::basic(registry)?,
-                windows_drives_previous_cwd: Arc::new(Mutex::new(std::collections::HashMap::new())),
-                raw_input: String::default(),
-            })
-        }
-
-        #[cfg(not(windows))]
-        {
-            Ok(Context {
-                registry: registry.clone(),
-                host: Arc::new(parking_lot::Mutex::new(Box::new(
-                    crate::env::host::BasicHost,
-                ))),
-                current_errors: Arc::new(Mutex::new(vec![])),
-                ctrl_c: Arc::new(AtomicBool::new(false)),
-                user_recently_used_autoenv_untrust: false,
-                shell_manager: ShellManager::basic(registry)?,
-                raw_input: String::default(),
-            })
-        }
-    }
-
-    pub(crate) fn error(&mut self, error: ShellError) {
-        self.with_errors(|errors| errors.push(error))
-    }
-
-    pub(crate) fn clear_errors(&mut self) {
-        self.current_errors.lock().clear()
-    }
-
-    pub(crate) fn get_errors(&self) -> Vec<ShellError> {
-        self.current_errors.lock().clone()
-    }
-
-    pub(crate) fn add_error(&self, err: ShellError) {
-        self.current_errors.lock().push(err);
-    }
-
-    pub(crate) fn maybe_print_errors(&mut self, source: Text) -> bool {
-        let errors = self.current_errors.clone();
-        let mut errors = errors.lock();
-
-        if errors.len() > 0 {
-            let error = errors[0].clone();
-            *errors = vec![];
-
-            crate::cli::print_err(error, &source);
-            true
-        } else {
-            false
-        }
-    }
-
-    pub(crate) fn with_host<T>(&mut self, block: impl FnOnce(&mut dyn Host) -> T) -> T {
-        let mut host = self.host.lock();
-
-        block(&mut *host)
-    }
-
-    pub(crate) fn with_errors<T>(&mut self, block: impl FnOnce(&mut Vec<ShellError>) -> T) -> T {
-        let mut errors = self.current_errors.lock();
-
-        block(&mut *errors)
-    }
-
-    pub fn add_commands(&mut self, commands: Vec<Command>) {
-        for command in commands {
-            self.registry.insert(command.name().to_string(), command);
-        }
-    }
-
-    pub(crate) fn get_command(&self, name: &str) -> Option<Command> {
-        self.registry.get_command(name)
-    }
-
-    pub(crate) fn expect_command(&self, name: &str) -> Result<Command, ShellError> {
-        self.registry.expect_command(name)
-    }
-
-    pub(crate) async fn run_command(
-        &mut self,
-        command: Command,
-        name_tag: Tag,
-        args: hir::Call,
-        scope: &Scope,
-        input: InputStream,
-    ) -> Result<OutputStream, ShellError> {
-        let command_args = self.command_args(args, input, name_tag, scope);
-        command.run(command_args, self.registry()).await
-    }
-
-    fn call_info(&self, args: hir::Call, name_tag: Tag, scope: &Scope) -> UnevaluatedCallInfo {
-        UnevaluatedCallInfo {
-            args,
-            name_tag,
-            scope: scope.clone(),
-        }
-    }
-
-    fn command_args(
-        &self,
-        args: hir::Call,
-        input: InputStream,
-        name_tag: Tag,
-        scope: &Scope,
-    ) -> CommandArgs {
-        CommandArgs {
-            host: self.host.clone(),
-            ctrl_c: self.ctrl_c.clone(),
-            current_errors: self.current_errors.clone(),
-            shell_manager: self.shell_manager.clone(),
-            call_info: self.call_info(args, name_tag, scope),
-            input,
-            raw_input: self.raw_input.clone(),
-        }
-    }
-
-    pub fn get_env(&self) -> IndexMap<String, String> {
-        let mut output = IndexMap::new();
-        for (var, value) in self.host.lock().vars() {
-            output.insert(var, value);
-        }
-        output
-    }
-}

crates/nu-cli/src/data.rs

@@ -1,12 +0,0 @@
-pub(crate) mod base;
-pub(crate) mod command;
-pub mod config;
-pub(crate) mod dict;
-pub(crate) mod files;
-pub mod primitive;
-pub(crate) mod types;
-pub mod value;
-
-pub(crate) use command::command_dict;
-pub(crate) use dict::TaggedListBuilder;
-pub(crate) use files::dir_entry_dict;

crates/nu-cli/src/data/base/shape.rs

@@ -1,270 +0,0 @@
-use crate::prelude::*;
-use chrono::{DateTime, Utc};
-use nu_protocol::RangeInclusion;
-use nu_protocol::{format_primitive, ColumnPath, Dictionary, Primitive, UntaggedValue, Value};
-use nu_source::{b, PrettyDebug};
-use std::collections::BTreeMap;
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub struct InlineRange {
-    from: (InlineShape, RangeInclusion),
-    to: (InlineShape, RangeInclusion),
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub enum InlineShape {
-    Nothing,
-    Int(BigInt),
-    Decimal(BigDecimal),
-    Range(Box<InlineRange>),
-    Bytesize(u64),
-    String(String),
-    Line(String),
-    ColumnPath(ColumnPath),
-    Pattern(String),
-    Boolean(bool),
-    Date(DateTime<Utc>),
-    Duration(BigInt),
-    Path(PathBuf),
-    Binary(usize),
-
-    Row(BTreeMap<Column, InlineShape>),
-    Table(Vec<InlineShape>),
-
-    // TODO: Block arguments
-    Block,
-    // TODO: Error type
-    Error,
-
-    // Stream markers (used as bookend markers rather than actual values)
-    BeginningOfStream,
-    EndOfStream,
-}
-
-pub struct FormatInlineShape {
-    shape: InlineShape,
-    column: Option<Column>,
-}
-
-impl InlineShape {
-    pub fn from_primitive(primitive: &Primitive) -> InlineShape {
-        match primitive {
-            Primitive::Nothing => InlineShape::Nothing,
-            Primitive::Int(int) => InlineShape::Int(int.clone()),
-            Primitive::Range(range) => {
-                let (left, left_inclusion) = &range.from;
-                let (right, right_inclusion) = &range.to;
-
-                InlineShape::Range(Box::new(InlineRange {
-                    from: (InlineShape::from_primitive(left), *left_inclusion),
-                    to: (InlineShape::from_primitive(right), *right_inclusion),
-                }))
-            }
-            Primitive::Decimal(decimal) => InlineShape::Decimal(decimal.clone()),
-            Primitive::Filesize(bytesize) => InlineShape::Bytesize(*bytesize),
-            Primitive::String(string) => InlineShape::String(string.clone()),
-            Primitive::Line(string) => InlineShape::Line(string.clone()),
-            Primitive::ColumnPath(path) => InlineShape::ColumnPath(path.clone()),
-            Primitive::Pattern(pattern) => InlineShape::Pattern(pattern.clone()),
-            Primitive::Boolean(boolean) => InlineShape::Boolean(*boolean),
-            Primitive::Date(date) => InlineShape::Date(*date),
-            Primitive::Duration(duration) => InlineShape::Duration(duration.clone()),
-            Primitive::Path(path) => InlineShape::Path(path.clone()),
-            Primitive::Binary(b) => InlineShape::Binary(b.len()),
-            Primitive::BeginningOfStream => InlineShape::BeginningOfStream,
-            Primitive::EndOfStream => InlineShape::EndOfStream,
-        }
-    }
-
-    pub fn from_dictionary(dictionary: &Dictionary) -> InlineShape {
-        let mut map = BTreeMap::new();
-
-        for (key, value) in dictionary.entries.iter() {
-            let column = Column::String(key.clone());
-            map.insert(column, InlineShape::from_value(value));
-        }
-
-        InlineShape::Row(map)
-    }
-
-    pub fn from_table<'a>(table: impl IntoIterator<Item = &'a Value>) -> InlineShape {
-        let mut vec = vec![];
-
-        for item in table.into_iter() {
-            vec.push(InlineShape::from_value(item))
-        }
-
-        InlineShape::Table(vec)
-    }
-
-    pub fn from_value<'a>(value: impl Into<&'a UntaggedValue>) -> InlineShape {
-        match value.into() {
-            UntaggedValue::Primitive(p) => InlineShape::from_primitive(p),
-            UntaggedValue::Row(row) => InlineShape::from_dictionary(row),
-            UntaggedValue::Table(table) => InlineShape::from_table(table.iter()),
-            UntaggedValue::Error(_) => InlineShape::Error,
-            UntaggedValue::Block(_) => InlineShape::Block,
-        }
-    }
-
-    #[allow(unused)]
-    pub fn format_for_column(self, column: impl Into<Column>) -> FormatInlineShape {
-        FormatInlineShape {
-            shape: self,
-            column: Some(column.into()),
-        }
-    }
-
-    pub fn format(self) -> FormatInlineShape {
-        FormatInlineShape {
-            shape: self,
-            column: None,
-        }
-    }
-}
-
-impl PrettyDebug for FormatInlineShape {
-    fn pretty(&self) -> DebugDocBuilder {
-        let column = &self.column;
-
-        match &self.shape {
-            InlineShape::Nothing => b::blank(),
-            InlineShape::Int(int) => b::primitive(format!("{}", int)),
-            InlineShape::Decimal(decimal) => {
-                b::description(format_primitive(&Primitive::Decimal(decimal.clone()), None))
-            }
-            InlineShape::Range(range) => {
-                let (left, left_inclusion) = &range.from;
-                let (right, right_inclusion) = &range.to;
-
-                let op = match (left_inclusion, right_inclusion) {
-                    (RangeInclusion::Inclusive, RangeInclusion::Exclusive) => "..",
-                    _ => unimplemented!("No syntax for ranges that aren't inclusive on the left and exclusive on the right")
-                };
-
-                left.clone().format().pretty() + b::operator(op) + right.clone().format().pretty()
-            }
-            InlineShape::Bytesize(bytesize) => {
-                let byte = byte_unit::Byte::from_bytes(*bytesize as u128);
-
-                let byte = byte.get_appropriate_unit(false);
-
-                match byte.get_unit() {
-                    byte_unit::ByteUnit::B => {
-                        (b::primitive(format!("{}", byte.get_value())) + b::space() + b::kind("B"))
-                            .group()
-                    }
-                    _ => b::primitive(byte.format(1)),
-                }
-            }
-            InlineShape::String(string) => b::primitive(string),
-            InlineShape::Line(string) => b::primitive(string),
-            InlineShape::ColumnPath(path) => {
-                b::intersperse(path.iter().map(|member| member.pretty()), b::keyword("."))
-            }
-            InlineShape::Pattern(pattern) => b::primitive(pattern),
-            InlineShape::Boolean(boolean) => b::primitive(
-                match (boolean, column) {
-                    (true, None) => "Yes",
-                    (false, None) => "No",
-                    (true, Some(Column::String(s))) if !s.is_empty() => s,
-                    (false, Some(Column::String(s))) if !s.is_empty() => "",
-                    (true, Some(_)) => "Yes",
-                    (false, Some(_)) => "No",
-                }
-                .to_owned(),
-            ),
-            InlineShape::Date(date) => b::primitive(nu_protocol::format_date(date)),
-            InlineShape::Duration(duration) => b::description(format_primitive(
-                &Primitive::Duration(duration.clone()),
-                None,
-            )),
-            InlineShape::Path(path) => b::primitive(path.display()),
-            InlineShape::Binary(length) => b::opaque(format!("<binary: {} bytes>", length)),
-            InlineShape::Row(row) => b::delimit(
-                "[",
-                b::kind("row")
-                    + b::space()
-                    + if row.keys().len() <= 6 {
-                        b::intersperse(
-                            row.keys().map(|key| match key {
-                                Column::String(string) => b::description(string),
-                                Column::Value => b::blank(),
-                            }),
-                            b::space(),
-                        )
-                    } else {
-                        b::description(format!("{} columns", row.keys().len()))
-                    },
-                "]",
-            )
-            .group(),
-            InlineShape::Table(rows) => b::delimit(
-                "[",
-                b::kind("table")
-                    + b::space()
-                    + b::primitive(rows.len())
-                    + b::space()
-                    + b::description("rows"),
-                "]",
-            )
-            .group(),
-            InlineShape::Block => b::opaque("block"),
-            InlineShape::Error => b::error("error"),
-            InlineShape::BeginningOfStream => b::blank(),
-            InlineShape::EndOfStream => b::blank(),
-        }
-    }
-}
-
-pub trait GroupedValue: Debug + Clone {
-    type Item;
-
-    fn new() -> Self;
-    fn merge(&mut self, value: Self::Item);
-}
-
-impl GroupedValue for Vec<(usize, usize)> {
-    type Item = usize;
-
-    fn new() -> Vec<(usize, usize)> {
-        vec![]
-    }
-
-    fn merge(&mut self, new_value: usize) {
-        match self.last_mut() {
-            Some(value) if value.1 == new_value - 1 => {
-                value.1 += 1;
-            }
-
-            _ => self.push((new_value, new_value)),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub enum Column {
-    String(String),
-    Value,
-}
-
-impl Into<Column> for String {
-    fn into(self) -> Column {
-        Column::String(self)
-    }
-}
-
-impl Into<Column> for &String {
-    fn into(self) -> Column {
-        Column::String(self.clone())
-    }
-}
-
-impl Into<Column> for &str {
-    fn into(self) -> Column {
-        Column::String(self.to_string())
-    }
-}

crates/nu-cli/src/data/config.rs

@@ -1,163 +0,0 @@
-mod conf;
-mod nuconfig;
-
-#[cfg(test)]
-pub mod tests;
-
-pub(crate) use conf::Conf;
-pub(crate) use nuconfig::NuConfig;
-
-use crate::commands::from_toml::convert_toml_value_to_nu_value;
-use crate::commands::to_toml::value_to_toml_value;
-use crate::prelude::*;
-use indexmap::IndexMap;
-use log::trace;
-use nu_errors::ShellError;
-use nu_protocol::{Dictionary, ShellTypeName, UntaggedValue, Value};
-use nu_source::Tag;
-use std::fs::{self, OpenOptions};
-use std::io;
-use std::path::{Path, PathBuf};
-
-#[cfg(feature = "directories")]
-pub fn config_path() -> Result<PathBuf, ShellError> {
-    use directories::ProjectDirs;
-
-    let dir = ProjectDirs::from("org", "nushell", "nu")
-        .ok_or_else(|| ShellError::untagged_runtime_error("Couldn't find project directory"))?;
-    let path = ProjectDirs::config_dir(&dir).to_owned();
-    std::fs::create_dir_all(&path).map_err(|err| {
-        ShellError::untagged_runtime_error(&format!("Couldn't create {} path:\n{}", "config", err))
-    })?;
-
-    Ok(path)
-}
-
-#[cfg(not(feature = "directories"))]
-pub fn config_path() -> Result<PathBuf, ShellError> {
-    // FIXME: unsure if this should be error or a simple default
-
-    Ok(std::path::PathBuf::from("/"))
-}
-
-pub fn default_path() -> Result<PathBuf, ShellError> {
-    default_path_for(&None)
-}
-
-pub fn default_path_for(file: &Option<PathBuf>) -> Result<PathBuf, ShellError> {
-    let mut filename = config_path()?;
-    let file: &Path = file
-        .as_ref()
-        .map(AsRef::as_ref)
-        .unwrap_or_else(|| "config.toml".as_ref());
-    filename.push(file);
-
-    Ok(filename)
-}
-
-#[cfg(feature = "directories")]
-pub fn user_data() -> Result<PathBuf, ShellError> {
-    use directories::ProjectDirs;
-
-    let dir = ProjectDirs::from("org", "nushell", "nu")
-        .ok_or_else(|| ShellError::untagged_runtime_error("Couldn't find project directory"))?;
-    let path = ProjectDirs::data_local_dir(&dir).to_owned();
-    std::fs::create_dir_all(&path).map_err(|err| {
-        ShellError::untagged_runtime_error(&format!(
-            "Couldn't create {} path:\n{}",
-            "user data", err
-        ))
-    })?;
-
-    Ok(path)
-}
-
-#[cfg(not(feature = "directories"))]
-pub fn user_data() -> Result<PathBuf, ShellError> {
-    // FIXME: unsure if this should be error or a simple default
-
-    Ok(std::path::PathBuf::from("/"))
-}
-
-pub fn read(
-    tag: impl Into<Tag>,
-    at: &Option<PathBuf>,
-) -> Result<IndexMap<String, Value>, ShellError> {
-    let filename = default_path()?;
-
-    let filename = match at {
-        None => filename,
-        Some(ref file) => file.clone(),
-    };
-
-    if !filename.exists() && touch(&filename).is_err() {
-        // If we can't create configs, let's just return an empty indexmap instead as we may be in
-        // a readonly environment
-        return Ok(IndexMap::new());
-    }
-
-    trace!("config file = {}", filename.display());
-
-    let tag = tag.into();
-    let contents = fs::read_to_string(filename)
-        .map(|v| v.tagged(&tag))
-        .map_err(|err| {
-            ShellError::labeled_error(
-                &format!("Couldn't read config file:\n{}", err),
-                "file name",
-                &tag,
-            )
-        })?;
-
-    let parsed: toml::Value = toml::from_str(&contents).map_err(|err| {
-        ShellError::labeled_error(
-            &format!("Couldn't parse config file:\n{}", err),
-            "file name",
-            &tag,
-        )
-    })?;
-
-    let value = convert_toml_value_to_nu_value(&parsed, tag);
-    let tag = value.tag();
-    match value.value {
-        UntaggedValue::Row(Dictionary { entries }) => Ok(entries),
-        other => Err(ShellError::type_error(
-            "Dictionary",
-            other.type_name().spanned(tag.span),
-        )),
-    }
-}
-
-pub fn config(tag: impl Into<Tag>) -> Result<IndexMap<String, Value>, ShellError> {
-    read(tag, &None)
-}
-
-pub fn write(config: &IndexMap<String, Value>, at: &Option<PathBuf>) -> Result<(), ShellError> {
-    let filename = &mut default_path()?;
-    let filename = match at {
-        None => filename,
-        Some(file) => {
-            filename.pop();
-            filename.push(file);
-            filename
-        }
-    };
-
-    let contents = value_to_toml_value(
-        &UntaggedValue::Row(Dictionary::new(config.clone())).into_untagged_value(),
-    )?;
-
-    let contents = toml::to_string(&contents)?;
-
-    fs::write(&filename, &contents)?;
-
-    Ok(())
-}
-
-// A simple implementation of `% touch path` (ignores existing files)
-fn touch(path: &Path) -> io::Result<()> {
-    match OpenOptions::new().create(true).write(true).open(path) {
-        Ok(_) => Ok(()),
-        Err(e) => Err(e),
-    }
-}

crates/nu-cli/src/data/config/conf.rs

@@ -1,22 +0,0 @@
-use nu_protocol::Value;
-use std::fmt::Debug;
-
-pub trait Conf: Debug + Send {
-    fn env(&self) -> Option<Value>;
-    fn path(&self) -> Option<Value>;
-    fn reload(&self);
-}
-
-impl Conf for Box<dyn Conf> {
-    fn env(&self) -> Option<Value> {
-        (**self).env()
-    }
-
-    fn path(&self) -> Option<Value> {
-        (**self).path()
-    }
-
-    fn reload(&self) {
-        (**self).reload();
-    }
-}

crates/nu-cli/src/data/config/nuconfig.rs

@@ -1,64 +0,0 @@
-use crate::data::config::{read, Conf};
-use indexmap::IndexMap;
-use nu_protocol::Value;
-use nu_source::Tag;
-use parking_lot::Mutex;
-use std::fmt::Debug;
-use std::sync::Arc;
-
-#[derive(Debug, Clone, Default)]
-pub struct NuConfig {
-    pub vars: Arc<Mutex<IndexMap<String, Value>>>,
-}
-
-impl Conf for NuConfig {
-    fn env(&self) -> Option<Value> {
-        self.env()
-    }
-
-    fn path(&self) -> Option<Value> {
-        self.path()
-    }
-
-    fn reload(&self) {
-        let mut vars = self.vars.lock();
-
-        if let Ok(variables) = read(Tag::unknown(), &None) {
-            vars.extend(variables);
-        }
-    }
-}
-
-impl NuConfig {
-    pub fn new() -> NuConfig {
-        let vars = if let Ok(variables) = read(Tag::unknown(), &None) {
-            variables
-        } else {
-            IndexMap::default()
-        };
-
-        NuConfig {
-            vars: Arc::new(Mutex::new(vars)),
-        }
-    }
-
-    pub fn env(&self) -> Option<Value> {
-        let vars = self.vars.lock();
-
-        if let Some(env_vars) = vars.get("env") {
-            return Some(env_vars.clone());
-        }
-
-        None
-    }
-
-    pub fn path(&self) -> Option<Value> {
-        let vars = self.vars.lock();
-
-        if let Some(env_vars) = vars.get("path") {
-            return Some(env_vars.clone());
-        }
-
-        None
-    }
-}

crates/nu-cli/src/data/config/tests.rs

@@ -1,44 +0,0 @@
-use crate::data::config::{read, Conf, NuConfig};
-use indexmap::IndexMap;
-use nu_protocol::Value;
-use nu_source::Tag;
-use parking_lot::Mutex;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
-#[derive(Debug)]
-pub struct FakeConfig {
-    pub config: NuConfig,
-}
-
-impl Conf for FakeConfig {
-    fn env(&self) -> Option<Value> {
-        self.config.env()
-    }
-
-    fn path(&self) -> Option<Value> {
-        self.config.path()
-    }
-
-    fn reload(&self) {
-        // no-op
-    }
-}
-
-impl FakeConfig {
-    pub fn new(config_file: &Path) -> FakeConfig {
-        let config_file = PathBuf::from(config_file);
-
-        let vars = if let Ok(variables) = read(Tag::unknown(), &Some(config_file)) {
-            variables
-        } else {
-            IndexMap::default()
-        };
-
-        FakeConfig {
-            config: NuConfig {
-                vars: Arc::new(Mutex::new(vars)),
-            },
-        }
-    }
-}

crates/nu-cli/src/data/files.rs

@@ -1,200 +0,0 @@
-use crate::commands::du::{DirBuilder, DirInfo};
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{TaggedDictBuilder, UntaggedValue, Value};
-
-#[cfg(unix)]
-use std::os::unix::fs::FileTypeExt;
-
-fn get_file_type(md: &std::fs::Metadata) -> &str {
-    let ft = md.file_type();
-    let mut file_type = "Unknown";
-    if ft.is_dir() {
-        file_type = "Dir";
-    } else if ft.is_file() {
-        file_type = "File";
-    } else if ft.is_symlink() {
-        file_type = "Symlink";
-    } else {
-        #[cfg(unix)]
-        {
-            if ft.is_block_device() {
-                file_type = "Block device";
-            } else if ft.is_char_device() {
-                file_type = "Char device";
-            } else if ft.is_fifo() {
-                file_type = "Pipe";
-            } else if ft.is_socket() {
-                file_type = "Socket";
-            }
-        }
-    }
-    file_type
-}
-
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn dir_entry_dict(
-    filename: &std::path::Path,
-    metadata: Option<&std::fs::Metadata>,
-    tag: impl Into<Tag>,
-    full: bool,
-    short_name: bool,
-    with_symlink_targets: bool,
-    du: bool,
-    ctrl_c: Arc<AtomicBool>,
-) -> Result<Value, ShellError> {
-    let tag = tag.into();
-    let mut dict = TaggedDictBuilder::new(&tag);
-    // Insert all columns first to maintain proper table alignment if we can't find (or are not allowed to view) any information
-    if full {
-        #[cfg(windows)]
-        {
-            for column in [
-                "name", "type", "target", "readonly", "size", "created", "accessed", "modified",
-            ]
-            .iter()
-            {
-                dict.insert_untagged(*column, UntaggedValue::nothing());
-            }
-        }
-
-        #[cfg(unix)]
-        {
-            for column in [
-                "name", "type", "target", "readonly", "mode", "uid", "group", "size", "created",
-                "accessed", "modified",
-            ]
-            .iter()
-            {
-                dict.insert_untagged(&(*column.to_owned()), UntaggedValue::nothing());
-            }
-        }
-    } else {
-        for column in ["name", "type", "target", "size", "modified"].iter() {
-            if *column == "target" && !with_symlink_targets {
-                continue;
-            }
-            dict.insert_untagged(*column, UntaggedValue::nothing());
-        }
-    }
-
-    let name = if short_name {
-        filename.file_name().and_then(|s| s.to_str())
-    } else {
-        filename.to_str()
-    }
-    .ok_or_else(|| {
-        ShellError::labeled_error(
-            format!("Invalid file name: {:}", filename.to_string_lossy()),
-            "invalid file name",
-            tag,
-        )
-    })?;
-
-    dict.insert_untagged("name", UntaggedValue::string(name));
-
-    if let Some(md) = metadata {
-        dict.insert_untagged("type", get_file_type(md));
-    }
-
-    if full || with_symlink_targets {
-        if let Some(md) = metadata {
-            if md.file_type().is_symlink() {
-                let symlink_target_untagged_value: UntaggedValue;
-                if let Ok(path_to_link) = filename.read_link() {
-                    symlink_target_untagged_value =
-                        UntaggedValue::string(path_to_link.to_string_lossy());
-                } else {
-                    symlink_target_untagged_value =
-                        UntaggedValue::string("Could not obtain target file's path");
-                }
-                dict.insert_untagged("target", symlink_target_untagged_value);
-            }
-        }
-    }
-
-    if full {
-        if let Some(md) = metadata {
-            dict.insert_untagged(
-                "readonly",
-                UntaggedValue::boolean(md.permissions().readonly()),
-            );
-
-            #[cfg(unix)]
-            {
-                use std::os::unix::fs::MetadataExt;
-                use std::os::unix::fs::PermissionsExt;
-                let mode = md.permissions().mode();
-                dict.insert_untagged(
-                    "mode",
-                    UntaggedValue::string(umask::Mode::from(mode).to_string()),
-                );
-
-                if let Some(user) = users::get_user_by_uid(md.uid()) {
-                    dict.insert_untagged(
-                        "uid",
-                        UntaggedValue::string(user.name().to_string_lossy()),
-                    );
-                }
-
-                if let Some(group) = users::get_group_by_gid(md.gid()) {
-                    dict.insert_untagged(
-                        "group",
-                        UntaggedValue::string(group.name().to_string_lossy()),
-                    );
-                }
-            }
-        }
-    }
-
-    if let Some(md) = metadata {
-        let mut size_untagged_value: UntaggedValue = UntaggedValue::nothing();
-
-        if md.is_dir() {
-            let dir_size: u64 = if du {
-                let params = DirBuilder::new(
-                    Tag {
-                        anchor: None,
-                        span: Span::new(0, 2),
-                    },
-                    None,
-                    false,
-                    None,
-                    false,
-                );
-
-                DirInfo::new(filename, &params, None, ctrl_c).get_size()
-            } else {
-                md.len()
-            };
-
-            size_untagged_value = UntaggedValue::filesize(dir_size);
-        } else if md.is_file() {
-            size_untagged_value = UntaggedValue::filesize(md.len());
-        } else if md.file_type().is_symlink() {
-            if let Ok(symlink_md) = filename.symlink_metadata() {
-                size_untagged_value = UntaggedValue::filesize(symlink_md.len() as u64);
-            }
-        }
-
-        dict.insert_untagged("size", size_untagged_value);
-    }
-
-    if let Some(md) = metadata {
-        if full {
-            if let Ok(c) = md.created() {
-                dict.insert_untagged("created", UntaggedValue::system_date(c));
-            }
-
-            if let Ok(a) = md.accessed() {
-                dict.insert_untagged("accessed", UntaggedValue::system_date(a));
-            }
-        }
-
-        if let Ok(m) = md.modified() {
-            dict.insert_untagged("modified", UntaggedValue::system_date(m));
-        }
-    }
-
-    Ok(dict.into_value())
-}

crates/nu-cli/src/data/primitive.rs

@@ -1,20 +0,0 @@
-use nu_protocol::{hir::Number, Primitive};
-use nu_table::TextStyle;
-
-pub fn number(number: impl Into<Number>) -> Primitive {
-    let number = number.into();
-
-    match number {
-        Number::Int(int) => Primitive::Int(int),
-        Number::Decimal(decimal) => Primitive::Decimal(decimal),
-    }
-}
-
-pub fn style_primitive(primitive: &Primitive) -> TextStyle {
-    match primitive {
-        Primitive::Int(_) | Primitive::Filesize(_) | Primitive::Decimal(_) => {
-            TextStyle::basic_right()
-        }
-        _ => TextStyle::basic(),
-    }
-}

crates/nu-cli/src/data/process.rs

@@ -1,29 +0,0 @@
-use crate::data::{TaggedDictBuilder, Value};
-use crate::prelude::*;
-use itertools::join;
-use sysinfo::ProcessExt;
-
-pub(crate) fn process_dict(proc: &sysinfo::Process, tag: impl Into<Tag>) -> Value {
-    let mut dict = TaggedDictBuilder::new(tag);
-
-    let cmd = proc.cmd();
-
-    let cmd_value = if cmd.len() == 0 {
-        value::nothing()
-    } else {
-        value::string(join(cmd, ""))
-    };
-
-    dict.insert("pid", value::int(proc.pid() as i64));
-    dict.insert("status", value::string(proc.status().to_string()));
-    dict.insert("cpu", value::number(proc.cpu_usage()));
-
-    match cmd_value {
-        UntaggedValue::Primitive(Primitive::Nothing) => {
-            dict.insert("name", value::string(proc.name()));
-        }
-        _ => dict.insert("name", cmd_value),
-    }
-
-    dict.into_value()
-}

crates/nu-cli/src/data/value.rs

@@ -1,230 +0,0 @@
-use crate::data::base::coerce_compare;
-use crate::data::base::shape::{Column, InlineShape};
-use crate::data::primitive::style_primitive;
-use chrono::DateTime;
-use nu_errors::ShellError;
-use nu_protocol::hir::Operator;
-use nu_protocol::ShellTypeName;
-use nu_protocol::{Primitive, Type, UntaggedValue};
-use nu_source::{DebugDocBuilder, PrettyDebug, Span, Tagged};
-use nu_table::TextStyle;
-use num_traits::Zero;
-
-pub fn date_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
-    let date = DateTime::parse_from_rfc3339(s.item).map_err(|err| {
-        ShellError::labeled_error(
-            &format!("Date parse error: {}", err),
-            "original value",
-            s.tag,
-        )
-    })?;
-
-    let date = date.with_timezone(&chrono::offset::Utc);
-
-    Ok(UntaggedValue::Primitive(Primitive::Date(date)))
-}
-
-pub fn merge_values(
-    left: &UntaggedValue,
-    right: &UntaggedValue,
-) -> Result<UntaggedValue, (&'static str, &'static str)> {
-    match (left, right) {
-        (UntaggedValue::Row(columns), UntaggedValue::Row(columns_b)) => {
-            Ok(UntaggedValue::Row(columns.merge_from(columns_b)))
-        }
-        (left, right) => Err((left.type_name(), right.type_name())),
-    }
-}
-
-fn zero_division_error() -> UntaggedValue {
-    UntaggedValue::Error(ShellError::untagged_runtime_error("division by zero"))
-}
-
-pub fn compute_values(
-    operator: Operator,
-    left: &UntaggedValue,
-    right: &UntaggedValue,
-) -> Result<UntaggedValue, (&'static str, &'static str)> {
-    match (left, right) {
-        (UntaggedValue::Primitive(lhs), UntaggedValue::Primitive(rhs)) => match (lhs, rhs) {
-            (Primitive::Filesize(x), Primitive::Filesize(y)) => {
-                let result = match operator {
-                    Operator::Plus => Ok(x + y),
-                    Operator::Minus => Ok(x - y),
-                    _ => Err((left.type_name(), right.type_name())),
-                }?;
-                Ok(UntaggedValue::Primitive(Primitive::Filesize(result)))
-            }
-            (Primitive::Int(x), Primitive::Int(y)) => match operator {
-                Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::Int(x + y))),
-                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::Int(x - y))),
-                Operator::Multiply => Ok(UntaggedValue::Primitive(Primitive::Int(x * y))),
-                Operator::Divide => {
-                    if y.is_zero() {
-                        Ok(zero_division_error())
-                    } else if x - (y * (x / y)) == num_bigint::BigInt::from(0) {
-                        Ok(UntaggedValue::Primitive(Primitive::Int(x / y)))
-                    } else {
-                        Ok(UntaggedValue::Primitive(Primitive::Decimal(
-                            bigdecimal::BigDecimal::from(x.clone())
-                                / bigdecimal::BigDecimal::from(y.clone()),
-                        )))
-                    }
-                }
-                _ => Err((left.type_name(), right.type_name())),
-            },
-            (Primitive::Decimal(x), Primitive::Int(y)) => {
-                let result = match operator {
-                    Operator::Plus => Ok(x + bigdecimal::BigDecimal::from(y.clone())),
-                    Operator::Minus => Ok(x - bigdecimal::BigDecimal::from(y.clone())),
-                    Operator::Multiply => Ok(x * bigdecimal::BigDecimal::from(y.clone())),
-                    Operator::Divide => {
-                        if y.is_zero() {
-                            return Ok(zero_division_error());
-                        }
-                        Ok(x / bigdecimal::BigDecimal::from(y.clone()))
-                    }
-                    _ => Err((left.type_name(), right.type_name())),
-                }?;
-                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
-            }
-            (Primitive::Int(x), Primitive::Decimal(y)) => {
-                let result = match operator {
-                    Operator::Plus => Ok(bigdecimal::BigDecimal::from(x.clone()) + y),
-                    Operator::Minus => Ok(bigdecimal::BigDecimal::from(x.clone()) - y),
-                    Operator::Multiply => Ok(bigdecimal::BigDecimal::from(x.clone()) * y),
-                    Operator::Divide => {
-                        if y.is_zero() {
-                            return Ok(zero_division_error());
-                        }
-                        Ok(bigdecimal::BigDecimal::from(x.clone()) / y)
-                    }
-                    _ => Err((left.type_name(), right.type_name())),
-                }?;
-                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
-            }
-            (Primitive::Decimal(x), Primitive::Decimal(y)) => {
-                let result = match operator {
-                    Operator::Plus => Ok(x + y),
-                    Operator::Minus => Ok(x - y),
-                    Operator::Multiply => Ok(x * y),
-                    Operator::Divide => {
-                        if y.is_zero() {
-                            return Ok(zero_division_error());
-                        }
-                        Ok(x / y)
-                    }
-                    _ => Err((left.type_name(), right.type_name())),
-                }?;
-                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
-            }
-            (Primitive::Date(x), Primitive::Date(y)) => match operator {
-                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::from(
-                    x.signed_duration_since(*y),
-                ))),
-                _ => Err((left.type_name(), right.type_name())),
-            },
-            (Primitive::Date(x), Primitive::Duration(_)) => {
-                let result = match operator {
-                    Operator::Plus => {
-                        // FIXME: Not sure if I could do something better with the Span.
-                        let y = Primitive::into_chrono_duration(rhs.clone(), Span::unknown())
-                            .expect("Could not convert nushell Duration into chrono Duration.");
-                        Ok(x.checked_add_signed(y).expect("Data overflow."))
-                    }
-                    _ => Err((left.type_name(), right.type_name())),
-                }?;
-                Ok(UntaggedValue::Primitive(Primitive::Date(result)))
-            }
-            (Primitive::Duration(x), Primitive::Duration(y)) => {
-                let result = match operator {
-                    Operator::Plus => Ok(x + y),
-                    Operator::Minus => Ok(x - y),
-                    _ => Err((left.type_name(), right.type_name())),
-                }?;
-
-                Ok(UntaggedValue::Primitive(Primitive::Duration(result)))
-            }
-            _ => Err((left.type_name(), right.type_name())),
-        },
-        _ => Err((left.type_name(), right.type_name())),
-    }
-}
-
-/// If left is {{ Operator }} right
-pub fn compare_values(
-    operator: Operator,
-    left: &UntaggedValue,
-    right: &UntaggedValue,
-) -> Result<bool, (&'static str, &'static str)> {
-    let coerced = coerce_compare(left, right)?;
-    let ordering = coerced.compare();
-
-    use std::cmp::Ordering;
-
-    let result = match (operator, ordering) {
-        (Operator::Equal, Ordering::Equal) => true,
-        (Operator::NotEqual, Ordering::Less) | (Operator::NotEqual, Ordering::Greater) => true,
-        (Operator::LessThan, Ordering::Less) => true,
-        (Operator::GreaterThan, Ordering::Greater) => true,
-        (Operator::GreaterThanOrEqual, Ordering::Greater)
-        | (Operator::GreaterThanOrEqual, Ordering::Equal) => true,
-        (Operator::LessThanOrEqual, Ordering::Less)
-        | (Operator::LessThanOrEqual, Ordering::Equal) => true,
-        _ => false,
-    };
-
-    Ok(result)
-}
-
-pub fn format_type<'a>(value: impl Into<&'a UntaggedValue>, width: usize) -> String {
-    Type::from_value(value.into()).colored_string(width)
-}
-
-pub fn format_leaf<'a>(value: impl Into<&'a UntaggedValue>) -> DebugDocBuilder {
-    InlineShape::from_value(value.into()).format().pretty()
-}
-
-pub fn style_leaf<'a>(value: impl Into<&'a UntaggedValue>) -> TextStyle {
-    match value.into() {
-        UntaggedValue::Primitive(p) => style_primitive(p),
-        _ => TextStyle::basic(),
-    }
-}
-
-pub fn format_for_column<'a>(
-    value: impl Into<&'a UntaggedValue>,
-    column: impl Into<Column>,
-) -> DebugDocBuilder {
-    InlineShape::from_value(value.into())
-        .format_for_column(column)
-        .pretty()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::UntaggedValue as v;
-    use indexmap::indexmap;
-
-    use super::merge_values;
-
-    #[test]
-    fn merges_tables() {
-        let table_author_row = v::row(indexmap! {
-            "name".into() => v::string("Andrés").into_untagged_value(),
-            "country".into() => v::string("EC").into_untagged_value(),
-            "date".into() => v::string("April 29-2020").into_untagged_value()
-        });
-
-        let other_table_author_row = v::row(indexmap! {
-            "name".into() => v::string("YK").into_untagged_value(),
-            "country".into() => v::string("US").into_untagged_value(),
-            "date".into() => v::string("October 10-2019").into_untagged_value()
-        });
-
-        assert_eq!(
-            other_table_author_row,
-            merge_values(&table_author_row, &other_table_author_row).unwrap()
-        );
-    }
-}

crates/nu-cli/src/env.rs

@@ -1,6 +1,3 @@
 pub(crate) mod directory_specific_environment;
 pub(crate) mod environment;
 pub(crate) mod environment_syncer;
-pub(crate) mod host;
-
-pub(crate) use self::host::Host;