Update main.wxs (#4007)

Remove references to the old binaries

.azure/azure-pipelines.yml

@@ -21,15 +21,6 @@ strategy:
     windows-stable:
       image: windows-2019
       style: 'unflagged'
-    linux-nightly-canary:
-      image: ubuntu-18.04
-      style: 'canary'
-    macos-nightly-canary:
-      image: macos-10.14
-      style: 'canary'
-    windows-nightly-canary:
-      image: windows-2019
-      style: 'canary'
     fmt:
       image: ubuntu-18.04
       style: 'fmt'
@@ -43,7 +34,6 @@ 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"
@@ -59,18 +49,12 @@ steps:
   - bash: RUSTFLAGS="-D warnings" cargo test --all
     condition: eq(variables['style'], 'unflagged')
     displayName: Run tests
-  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used
+  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used -A clippy::needless_collect
     condition: eq(variables['style'], 'unflagged')
     displayName: Check clippy lints
-  - bash: RUSTFLAGS="-D warnings" cargo test --all
-    condition: eq(variables['style'], 'canary')
-    displayName: Run tests
-  - bash: cd samples/wasm && wasm-pack build
+  - bash: cd samples/wasm && npm install wasm-pack && node ./node_modules/wasm-pack/run.js 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 --features=rustyline-support
     condition: eq(variables['style'], 'minimal')
     displayName: Run tests

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,30 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. 
-2. 
-3. 
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-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.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,65 @@
+name: Bug Report
+description: Create a report to help us improve
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: How to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1.
+        2.
+        3.
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+      placeholder: I expected nu to...
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add any relevant screenshots here, if any
+    validations:
+      required: false
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: "Please run `> version | pivot key value | to md` and paste the output to show OS, features, etc"
+      placeholder: |
+        > version | pivot key value | to md
+        ╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
+        │ # │ key                │ value                                                                 │
+        ├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
+        │ 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, rich-benchmark,        │
+        │   │                    │ rustyline, term, uuid, which, zip                                     │
+        ╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,34 @@
+name: Feature Request
+description: "When you want a new feature for something that doesn't already exist"
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Related problem
+      description: Is your feature request related to a problem? Please describe.
+      placeholder: |
+        A clear and concise description of what the problem is.
+        Example: I am trying to do [...] but [...]
+    validations:
+      required: false
+  - type: textarea
+    id: desired
+    attributes:
+      label: "Describe the solution you'd like"
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: "Describe alternatives you've considered"
+      description: "A clear and concise description of any alternative solutions or features you've considered."
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context and details
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/workflows/release.yml

@@ -283,4 +283,4 @@ jobs:
           upload_url: ${{ steps.create_release.outputs.upload_url }}
           asset_path: ./nushell-windows.msi
           asset_name: ${{ steps.info.outputs.windowsdir }}.msi
-          asset_content_type: applictaion/x-msi
+          asset_content_type: application/x-msi

.github/workflows/stale.yml

@@ -0,0 +1,29 @@
+name: 'Close stale issues and PRs'
+#on: [workflow_dispatch]
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          #debug-only: true
+          ascending: true
+          operations-per-run: 520
+          enable-statistics: true
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          stale-issue-message: 'This issue is being marked stale because it has been open for 90 days without activity. If you feel that this is in error, please comment below and we will keep it marked as active.'
+          stale-pr-message: 'This PR is being marked stale because it has been open for 45 days without activity. If this PR is still active, please comment below and we will keep it marked as active.'
+          close-issue-message: 'This issue has been marked stale for more than 10 days without activity. Closing this issue, but if you find that the issue is still valid, please reopen.'
+          close-pr-message: 'This PR has been marked stale for more than 10 days without activity. Closing this PR, but if you are still working on it, please reopen.'
+          days-before-issue-stale: 90
+          days-before-pr-stale: 45
+          days-before-issue-close: 10
+          days-before-pr-close: 10

.github/workflows/winget-submission.yml

@@ -0,0 +1,18 @@
+name: Submit Nushell package to Windows Package Manager Community Repository 
+
+on:
+  release:
+    types: [published]
+
+jobs:
+
+  winget:
+    name: Publish winget package
+    runs-on: windows-latest
+    steps:
+      - name: Submit package to Windows Package Manager Community Repository
+        run: |
+          iwr https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
+          $github = Get-Content '${{ github.event_path }}' | ConvertFrom-Json
+          $installerUrl = $github.release.assets | Where-Object -Property name -match 'windows.msi' | Select -ExpandProperty browser_download_url -First 1
+          .\wingetcreate.exe update Nushell.Nushell -s -v $github.release.tag_name -u $installerUrl -t ${{ secrets.NUSHELL_PAT }}

.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

@@ -2,7 +2,7 @@
 
 Welcome to nushell!
 
-*Note: for a more complete guide see [The nu contributor book](https://github.com/nushell/contributor-book)*
+*Note: for a more complete guide see [The nu contributor book](https://www.nushell.sh/contributor-book/)*
 
 For speedy contributions open it in Gitpod, nu will be pre-installed with the latest build in a VSCode like editor all from your browser.
 

Cargo.toml

@@ -10,7 +10,7 @@ license = "MIT"
 name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.21.0"
+version = "0.37.0"
 
 [workspace]
 members = ["crates/*/"]
@@ -18,102 +18,130 @@ members = ["crates/*/"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-cli = {version = "0.21.0", path = "./crates/nu-cli"}
-nu-data = {version = "0.21.0", path = "./crates/nu-data"}
-nu-errors = {version = "0.21.0", path = "./crates/nu-errors"}
-nu-parser = {version = "0.21.0", path = "./crates/nu-parser"}
-nu-plugin = {version = "0.21.0", path = "./crates/nu-plugin"}
-nu-protocol = {version = "0.21.0", path = "./crates/nu-protocol"}
-nu-source = {version = "0.21.0", path = "./crates/nu-source"}
-nu-value-ext = {version = "0.21.0", path = "./crates/nu-value-ext"}
+nu-cli = { version = "0.37.0", path="./crates/nu-cli", default-features=false }
+nu-command = { version = "0.37.0", path="./crates/nu-command" }
+nu-completion = { version = "0.37.0", path="./crates/nu-completion" }
+nu-data = { version = "0.37.0", path="./crates/nu-data" }
+nu-engine = { version = "0.37.0", path="./crates/nu-engine" }
+nu-errors = { version = "0.37.0", path="./crates/nu-errors" }
+nu-parser = { version = "0.37.0", path="./crates/nu-parser" }
+nu-path = { version = "0.37.0", path="./crates/nu-path" }
+nu-plugin = { version = "0.37.0", path="./crates/nu-plugin" }
+nu-protocol = { version = "0.37.0", path="./crates/nu-protocol" }
+nu-source = { version = "0.37.0", path="./crates/nu-source" }
+nu-value-ext = { version = "0.37.0", path="./crates/nu-value-ext" }
 
-nu_plugin_binaryview = {version = "0.21.0", path = "./crates/nu_plugin_binaryview", optional = true}
-nu_plugin_chart = {version = "0.21.0", path = "./crates/nu_plugin_chart", optional = true}
-nu_plugin_fetch = {version = "0.21.0", path = "./crates/nu_plugin_fetch", optional = true}
-nu_plugin_from_bson = {version = "0.21.0", path = "./crates/nu_plugin_from_bson", optional = true}
-nu_plugin_from_sqlite = {version = "0.21.0", path = "./crates/nu_plugin_from_sqlite", optional = true}
-nu_plugin_inc = {version = "0.21.0", path = "./crates/nu_plugin_inc", optional = true}
-nu_plugin_match = {version = "0.21.0", path = "./crates/nu_plugin_match", optional = true}
-nu_plugin_post = {version = "0.21.0", path = "./crates/nu_plugin_post", optional = true}
-nu_plugin_ps = {version = "0.21.0", path = "./crates/nu_plugin_ps", optional = true}
-nu_plugin_s3 = {version = "0.21.0", path = "./crates/nu_plugin_s3", optional = true}
-nu_plugin_start = {version = "0.21.0", path = "./crates/nu_plugin_start", optional = true}
-nu_plugin_sys = {version = "0.21.0", path = "./crates/nu_plugin_sys", optional = true}
-nu_plugin_textview = {version = "0.21.0", path = "./crates/nu_plugin_textview", optional = true}
-nu_plugin_to_bson = {version = "0.21.0", path = "./crates/nu_plugin_to_bson", optional = true}
-nu_plugin_to_sqlite = {version = "0.21.0", path = "./crates/nu_plugin_to_sqlite", optional = true}
-nu_plugin_tree = {version = "0.21.0", path = "./crates/nu_plugin_tree", optional = true}
-nu_plugin_xpath = {version = "0.21.0", path = "./crates/nu_plugin_xpath", optional = true}
+nu_plugin_binaryview = { version = "0.37.0", path="./crates/nu_plugin_binaryview", optional=true }
+nu_plugin_chart = { version = "0.37.0", path="./crates/nu_plugin_chart", optional=true }
+nu_plugin_from_bson = { version = "0.37.0", path="./crates/nu_plugin_from_bson", optional=true }
+nu_plugin_from_sqlite = { version = "0.37.0", path="./crates/nu_plugin_from_sqlite", optional=true }
+nu_plugin_inc = { version = "0.37.0", path="./crates/nu_plugin_inc", optional=true }
+nu_plugin_match = { version = "0.37.0", path="./crates/nu_plugin_match", optional=true }
+nu_plugin_query_json = { version = "0.37.0", path="./crates/nu_plugin_query_json", optional=true }
+nu_plugin_s3 = { version = "0.37.0", path="./crates/nu_plugin_s3", optional=true }
+nu_plugin_selector = { version = "0.37.0", path="./crates/nu_plugin_selector", optional=true }
+nu_plugin_start = { version = "0.37.0", path="./crates/nu_plugin_start", optional=true }
+nu_plugin_textview = { version = "0.37.0", path="./crates/nu_plugin_textview", optional=true }
+nu_plugin_to_bson = { version = "0.37.0", path="./crates/nu_plugin_to_bson", optional=true }
+nu_plugin_to_sqlite = { version = "0.37.0", path="./crates/nu_plugin_to_sqlite", optional=true }
+nu_plugin_tree = { version = "0.37.0", path="./crates/nu_plugin_tree", optional=true }
+nu_plugin_xpath = { version = "0.37.0", path="./crates/nu_plugin_xpath", optional=true }
 
 # Required to bootstrap the main binary
-clap = "2.33.3"
-ctrlc = {version = "3.1.6", optional = true}
-futures = {version = "0.3.5", features = ["compat", "io-compat"]}
-log = "0.4.11"
-pretty_env_logger = "0.4.0"
+ctrlc = { version="3.1.7", optional=true }
+futures = { version="0.3.12", features=["compat", "io-compat"] }
+itertools = "0.10.0"
 
 [dev-dependencies]
-dunce = "1.0.1"
-nu-test-support = {version = "0.21.0", path = "./crates/nu-test-support"}
+nu-test-support = { version = "0.37.0", path="./crates/nu-test-support" }
+serial_test = "0.5.1"
+hamcrest2 = "0.3.0"
+rstest = "0.10.0"
 
 [build-dependencies]
 
 [features]
-ctrlc-support = ["nu-cli/ctrlc"]
-directories-support = ["nu-cli/directories", "nu-cli/dirs", "nu-data/directories", "nu-data/dirs"]
-git-support = ["nu-cli/git2"]
-ptree-support = ["nu-cli/ptree"]
-rich-benchmark = ["nu-cli/rich-benchmark"]
-rustyline-support = ["nu-cli/rustyline-support"]
-term-support = ["nu-cli/term"]
-uuid-support = ["nu-cli/uuid_crate"]
-which-support = ["nu-cli/ichwh", "nu-cli/which"]
+fetch-support = ["nu-command/fetch", "nu-command/post"]
+sys-support = ["nu-command/sys", "nu-command/ps"]
+ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
+rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
+term-support = ["nu-command/term"]
+uuid-support = ["nu-command/uuid_crate"]
+which-support = ["nu-command/which", "nu-engine/which"]
 
 default = [
-  "sys",
-  "ps",
-  "textview",
-  "inc",
-  "git-support",
-  "directories-support",
-  "ctrlc-support",
-  "which-support",
-  "ptree-support",
-  "term-support",
-  "uuid-support",
-  "rustyline-support",
-  "match",
-  "post",
-  "fetch",
-  "rich-benchmark",
+    "nu-cli/shadow-rs",
+    "sys-support",
+    "ctrlc-support",
+    "which-support",
+    "term-support",
+    "rustyline-support",
+    "match",
+    "fetch-support",
+    "zip-support",
+    "dataframe",
 ]
-extra = ["default", "binaryview", "tree", "clipboard-cli", "trash-support", "start", "bson", "sqlite", "s3", "chart", "xpath"]
+
 stable = ["default"]
+extra = [
+    "default",
+    "binaryview",
+    "inc",
+    "tree",
+    "textview",
+    "clipboard-cli",
+    "trash-support",
+    "uuid-support",
+    "start",
+    "bson",
+    "sqlite",
+    "s3",
+    "chart",
+    "xpath",
+    "selector",
+    "query-json",
+]
 
-wasi = ["inc", "match", "directories-support", "ptree-support", "match", "tree", "rustyline-support"]
-
-trace = ["nu-parser/trace"]
+wasi = ["inc", "match", "match", "tree", "rustyline-support"]
 
 # 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"]
 
 # Extra
 binaryview = ["nu_plugin_binaryview"]
 bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
 chart = ["nu_plugin_chart"]
-clipboard-cli = ["nu-cli/clipboard-cli"]
+clipboard-cli = ["nu-command/clipboard-cli"]
+query-json = ["nu_plugin_query_json"]
 s3 = ["nu_plugin_s3"]
+selector = ["nu_plugin_selector"]
 sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
 start = ["nu_plugin_start"]
-trash-support = ["nu-cli/trash-support"]
+trash-support = [
+    "nu-command/trash-support",
+    "nu-engine/trash-support",
+]
 tree = ["nu_plugin_tree"]
 xpath = ["nu_plugin_xpath"]
+zip-support = ["nu-command/zip"]
+
+#This is disabled in extra for now
+table-pager = ["nu-command/table-pager"]
+
+#dataframe feature for nushell
+dataframe = [
+    "nu-engine/dataframe",
+    "nu-protocol/dataframe",
+    "nu-command/dataframe",
+    "nu-value-ext/dataframe",
+    "nu-data/dataframe",
+    "nu_plugin_to_bson/dataframe",
+]
+
+[profile.release]
+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,31 +156,11 @@ name = "nu_plugin_core_inc"
 path = "src/plugins/nu_plugin_core_inc.rs"
 required-features = ["inc"]
 
-[[bin]]
-name = "nu_plugin_core_ps"
-path = "src/plugins/nu_plugin_core_ps.rs"
-required-features = ["ps"]
-
-[[bin]]
-name = "nu_plugin_core_sys"
-path = "src/plugins/nu_plugin_core_sys.rs"
-required-features = ["sys"]
-
-[[bin]]
-name = "nu_plugin_core_fetch"
-path = "src/plugins/nu_plugin_core_fetch.rs"
-required-features = ["fetch"]
-
 [[bin]]
 name = "nu_plugin_core_match"
 path = "src/plugins/nu_plugin_core_match.rs"
 required-features = ["match"]
 
-[[bin]]
-name = "nu_plugin_core_post"
-path = "src/plugins/nu_plugin_core_post.rs"
-required-features = ["post"]
-
 # Extra plugins
 
 [[bin]]
@@ -165,6 +173,11 @@ name = "nu_plugin_extra_tree"
 path = "src/plugins/nu_plugin_extra_tree.rs"
 required-features = ["tree"]
 
+[[bin]]
+name = "nu_plugin_extra_query_json"
+path = "src/plugins/nu_plugin_extra_query_json.rs"
+required-features = ["query-json"]
+
 [[bin]]
 name = "nu_plugin_extra_start"
 path = "src/plugins/nu_plugin_extra_start.rs"
@@ -190,6 +203,31 @@ 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"

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 - 2020 Yehuda Katz, Jonathan Turner
+Copyright (c) 2019 - 2021 Yehuda Katz, Jonathan Turner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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,29 +45,35 @@ 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.51 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`):
 
-```bash
+```shell
 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:
+To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
 
-```bash
+```shell
+winget 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/installation.html#dependencies) for your platform), once you have checked out this repo with git:
+
+```shell
 cargo build --workspace --features=extra
 ```
 
@@ -76,7 +83,7 @@ cargo build --workspace --features=extra
 
 Want to try Nu right away? Execute the following to get started.
 
-```bash
+```shell
 docker run -it quay.io/nushell/nu:latest
 ```
 
@@ -85,30 +92,30 @@ docker run -it quay.io/nushell/nu:latest
 If you want to pull a pre-built container, you can browse tags for the [nushell organization](https://quay.io/organization/nushell)
 on Quay.io. Pulling a container would come down to:
 
-```bash
+```shell
 docker pull quay.io/nushell/nu
 docker pull quay.io/nushell/nu-base
 ```
 
-Both "nu-base" and "nu" provide the nu binary, however nu-base also includes the source code at `/code`
+Both "nu-base" and "nu" provide the nu binary, however, nu-base also includes the source code at `/code`
 in the container and all dependencies.
 
 Optionally, you can also build the containers locally using the [dockerfiles provided](docker):
 To build the base image:
 
-```bash
+```shell
 docker build -f docker/Dockerfile.nu-base -t nushell/nu-base .
 ```
 
 And then to build the smaller container (using a Multistage build):
 
-```bash
+```shell
 docker build -f docker/Dockerfile -t nushell/nu .
 ```
 
 Either way, you can run either container as follows:
 
-```bash
+```shell
 docker run -it nushell/nu-base
 docker run -it nushell/nu
 /> exit
@@ -135,13 +142,13 @@ These values can be piped through a series of steps, in a series of commands cal
 
 In Unix, it's common to pipe between commands to split up a sophisticated command over multiple steps.
 Nu takes this a step further and builds heavily on the idea of _pipelines_.
-Just as the Unix philosophy, Nu allows commands to output from stdout and read from stdin.
+Just as the Unix philosophy, Nu allows commands to output to stdout and read from stdin.
 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 (e.g., `ls`)
+-   Commands that filter a stream (eg, `where type == "Dir"`)
+-   Commands that consume the output of the pipeline (e.g., `autoview`)
 
 Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.
 
@@ -170,7 +177,7 @@ We could have also written the above:
 ```
 
 Being able to use the same commands and compose them differently is an important philosophy in Nu.
-For example, we could use the built-in `ps` command as well to get a list of the running processes, using the same `where` as above.
+For example, we could use the built-in `ps` command to get a list of the running processes, using the same `where` as above.
 
 ```shell
 > ps | where cpu > 0
@@ -187,7 +194,7 @@ For example, we could use the built-in `ps` command as well to get a list of the
 
 ### Opening files
 
-Nu can load file and URL contents as raw text or as structured data (if it recognizes the format).
+Nu can load file and URL contents as raw text or structured data (if it recognizes the format).
 For example, you can load a .toml file as structured data and explore it:
 
 ```shell
@@ -219,36 +226,34 @@ 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.32.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.32.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:
 
 ```shell
-> config set edit_mode "vi"
+> config set line_editor.edit_mode "vi"
 > config set path $nu.path
 ```
 
 ### Shells
 
 Nu will work inside of a single directory and allow you to navigate around your filesystem by default.
-Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories at the same time.
+Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories simultaneously.
 
-To do so, use the `enter` command, which will allow you create a new "shell" and enter it at the specified path.
+To do so, use the `enter` command, which will allow you to create a new "shell" and enter it at the specified path.
 You can toggle between this new shell and the original shell with the `p` (for previous) and `n` (for next), allowing you to navigate around a ring buffer of shells.
 Once you're done with a shell, you can `exit` it and remove it from the ring buffer.
 
@@ -262,7 +267,7 @@ This allows you to extend nu for your needs.
 There are a few examples in the `plugins` directory.
 
 Plugins are binaries that are available in your path and follow a `nu_plugin_*` naming convention.
-These binaries interact with nu via a simple JSON-RPC protocol where the command identifies itself and passes along its configuration, which then makes it available for use.
+These binaries interact with nu via a simple JSON-RPC protocol where the command identifies itself and passes along its configuration, making it available for use.
 If the plugin is a filter, data streams to it one element at a time, and it can stream data back in return via stdin/stdout.
 If the plugin is a sink, it is given the full vector of final data and is given free reign over stdin/stdout to use as it pleases.
 
@@ -270,49 +275,61 @@ 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 consistent first-class 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  |         |        | Aliases allow for shortening large commands, while passing flags     |
+| 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 and scoped environment 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 updated to latest release, including usage examples             |
+| Paging        |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables                 |
+| Functions     |             |           |  X  |         |        | Functions and aliases are supported                                  |
+| Variables     |             |           |  X  |         |        | Nu supports variables and environment variables                      |
+| Completions   |             |           |  X  |         |        | Completions for filepaths                                            |
+| Type-checking |             |           |  X  |         |        | Commands check basic types, but input/output isn't checked           |
 
-## Current Roadmap
+## Officially Supported By
 
-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).
+Please submit an issue or PR to be added to this list.
+
+###   Integrations
+-   [zoxide](https://github.com/ajeetdsouza/zoxide)
+-   [starship](https://github.com/starship/starship)
+###   Mentions
+-   [The Python Launcher for Unix](https://github.com/brettcannon/python-launcher#how-do-i-get-a-table-of-python-executables-in-nushell)
 
 ## 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.

crates/README.md

@@ -0,0 +1,13 @@
+# Nushell core libraries and plugins
+
+These sub-crates form both the foundation for Nu and a set of plugins which extend Nu with additional functionality.
+
+Foundational libraries are split into two kinds of crates:
+
+* Core crates - those crates that work together to build the Nushell language engine
+* Support crates - a set of crates that support the engine with additional features like JSON support, ANSI support, and more.
+
+Plugins are likewise also split into two types:
+
+* Core plugins - plugins that provide part of the default experience of Nu, including access to the system properties, processes, and web-connectivity features.
+* Extra plugins - these plugins run a wide range of differnt capabilities like working with different file types, charting, viewing binary data, and more.

crates/nu-ansi-term/.gitignore

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

crates/nu-ansi-term/Cargo.toml

@@ -0,0 +1,40 @@
+[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.37.0"
+
+[lib]
+doctest = false
+# name = "nu-ansi-term"
+
+[features]
+derive_serde_style = ["serde"]
+
+[dependencies]
+overload = "0.1.1"
+serde = { version="1.0.90", features=["derive"], optional=true }
+itertools = "0.10.0"
+
+# [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/gradient_colors.rs

@@ -0,0 +1,37 @@
+use nu_ansi_term::{build_all_gradient_text, Color, Gradient, Rgb, TargetGround};
+
+fn main() {
+    let text = "lorem ipsum quia dolor sit amet, consectetur, adipisci velit";
+
+    // a gradient from hex colors
+    let start = Rgb::from_hex(0x40c9ff);
+    let end = Rgb::from_hex(0xe81cff);
+    let grad0 = Gradient::new(start, end);
+
+    // a gradient from color::rgb()
+    let start = Color::Rgb(64, 201, 255);
+    let end = Color::Rgb(232, 28, 255);
+    let gradient = Gradient::from_color_rgb(start, end);
+
+    // a slightly different gradient
+    let start2 = Color::Rgb(128, 64, 255);
+    let end2 = Color::Rgb(0, 28, 255);
+    let gradient2 = Gradient::from_color_rgb(start2, end2);
+
+    // reverse the gradient
+    let gradient3 = gradient.reverse();
+
+    let build_fg = gradient.build(text, TargetGround::Foreground);
+    println!("{}", build_fg);
+    let build_bg = gradient.build(text, TargetGround::Background);
+    println!("{}", build_bg);
+    let bgt = build_all_gradient_text(text, gradient, gradient2);
+    println!("{}", bgt);
+    let bgt2 = build_all_gradient_text(text, gradient, gradient3);
+    println!("{}", bgt2);
+
+    println!(
+        "{}",
+        grad0.build("nushell is awesome", TargetGround::Foreground)
+    );
+}

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,405 @@
+#![allow(missing_docs)]
+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::Empty => {
+                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.
+    Empty,
+}
+
+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 Empty;
+        }
+
+        // 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()  => Empty);
+    test!(uppercase:  Green.normal(); Green.bold()    => ExtraStyles(style().bold()));
+    test!(lowercase:  Green.bold();   Green.normal()  => Reset);
+    test!(nothing2:   Green.bold();   Green.bold()    => Empty);
+
+    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 `AnsiGenericStrings`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())?,
+                Empty => { /* 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 = AnsiStrings(&[one, two]).to_string();
+        assert_eq!(output, "onetwo");
+    }
+}

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

@@ -0,0 +1,105 @@
+use crate::{rgb::Rgb, Color};
+
+/// Linear color gradient between two color stops
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Gradient {
+    /// Start Color of Gradient
+    pub start: Rgb,
+
+    /// End Color of Gradient
+    pub end: Rgb,
+}
+
+impl Gradient {
+    /// Creates a new [Gradient] with two [Rgb] colors, `start` and `end`
+    #[inline]
+    pub const fn new(start: Rgb, end: Rgb) -> Self {
+        Self { start, end }
+    }
+    pub const fn from_color_rgb(start: Color, end: Color) -> Self {
+        let start_grad = match start {
+            Color::Rgb(r, g, b) => Rgb { r, g, b },
+            _ => Rgb { r: 0, g: 0, b: 0 },
+        };
+        let end_grad = match end {
+            Color::Rgb(r, g, b) => Rgb { r, g, b },
+            _ => Rgb { r: 0, g: 0, b: 0 },
+        };
+
+        Self {
+            start: start_grad,
+            end: end_grad,
+        }
+    }
+
+    /// Computes the [Rgb] color between `start` and `end` for `t`
+    pub fn at(&self, t: f32) -> Rgb {
+        self.start.lerp(self.end, t)
+    }
+
+    /// Returns the reverse of `self`
+    #[inline]
+    pub const fn reverse(&self) -> Self {
+        Self::new(self.end, self.start)
+    }
+
+    #[allow(dead_code)]
+    pub fn build(&self, text: &str, target: TargetGround) -> String {
+        let delta = 1.0 / text.len() as f32;
+        let mut result = text.char_indices().fold(String::new(), |mut acc, (i, c)| {
+            let temp = format!(
+                "\x1B[{}m{}",
+                self.at(i as f32 * delta).ansi_color_code(target),
+                c
+            );
+            acc.push_str(&temp);
+            acc
+        });
+
+        result.push_str("\x1B[0m");
+        result
+    }
+}
+
+#[allow(dead_code)]
+pub fn build_all_gradient_text(text: &str, foreground: Gradient, background: Gradient) -> String {
+    let delta = 1.0 / text.len() as f32;
+    let mut result = text.char_indices().fold(String::new(), |mut acc, (i, c)| {
+        let step = i as f32 * delta;
+        let temp = format!(
+            "\x1B[{};{}m{}",
+            foreground
+                .at(step)
+                .ansi_color_code(TargetGround::Foreground),
+            background
+                .at(step)
+                .ansi_color_code(TargetGround::Background),
+            c
+        );
+        acc.push_str(&temp);
+        acc
+    });
+
+    result.push_str("\x1B[0m");
+    result
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TargetGround {
+    Foreground,
+    Background,
+}
+
+impl TargetGround {
+    #[inline]
+    pub const fn code(&self) -> u8 {
+        match self {
+            Self::Foreground => 30,
+            Self::Background => 40,
+        }
+    }
+}
+
+pub trait ANSIColorCode {
+    fn ansi_color_code(&self, target: TargetGround) -> String;
+}

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

@@ -0,0 +1,273 @@
+//! 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");
+
+pub 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;
+
+pub mod gradient;
+pub use gradient::*;
+
+mod rgb;
+pub use rgb::*;

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

@@ -0,0 +1,173 @@
+// Code liberally borrowed from here
+// https://github.com/navierr/coloriz
+use std::ops;
+use std::u32;
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Rgb {
+    /// Red
+    pub r: u8,
+    /// Green
+    pub g: u8,
+    /// Blue
+    pub b: u8,
+}
+
+impl Rgb {
+    /// Creates a new [Rgb] color
+    #[inline]
+    pub const fn new(r: u8, g: u8, b: u8) -> Self {
+        Self { r, g, b }
+    }
+
+    /// Creates a new [Rgb] color with a hex code
+    #[inline]
+    pub const fn from_hex(hex: u32) -> Self {
+        Self::new((hex >> 16) as u8, (hex >> 8) as u8, hex as u8)
+    }
+
+    pub fn from_hex_string(hex: String) -> Self {
+        if hex.chars().count() == 8 && hex.starts_with("0x") {
+            // eprintln!("hex:{:?}", hex);
+            let (_, value_string) = hex.split_at(2);
+            // eprintln!("value_string:{:?}", value_string);
+            let int_val = u64::from_str_radix(value_string, 16);
+            match int_val {
+                Ok(num) => Self::new(
+                    ((num & 0xff0000) >> 16) as u8,
+                    ((num & 0xff00) >> 8) as u8,
+                    (num & 0xff) as u8,
+                ),
+                // Don't fail, just make the color black
+                // Should we fail?
+                _ => Self::new(0, 0, 0),
+            }
+        } else {
+            // Don't fail, just make the color black.
+            // Should we fail?
+            Self::new(0, 0, 0)
+        }
+    }
+
+    /// Creates a new [Rgb] color with three [f32] values
+    pub fn from_f32(r: f32, g: f32, b: f32) -> Self {
+        Self::new(
+            (r.clamp(0.0, 1.0) * 255.0) as u8,
+            (g.clamp(0.0, 1.0) * 255.0) as u8,
+            (b.clamp(0.0, 1.0) * 255.0) as u8,
+        )
+    }
+
+    /// Creates a grayscale [Rgb] color
+    #[inline]
+    pub const fn gray(x: u8) -> Self {
+        Self::new(x, x, x)
+    }
+
+    /// Creates a grayscale [Rgb] color with a [f32] value
+    pub fn gray_f32(x: f32) -> Self {
+        Self::from_f32(x, x, x)
+    }
+
+    /// Creates a new [Rgb] color from a [HSL] color
+    // pub fn from_hsl(hsl: HSL) -> Self {
+    //     if hsl.s == 0.0 {
+    //         return Self::gray_f32(hsl.l);
+    //     }
+
+    //     let q = if hsl.l < 0.5 {
+    //         hsl.l * (1.0 + hsl.s)
+    //     } else {
+    //         hsl.l + hsl.s - hsl.l * hsl.s
+    //     };
+    //     let p = 2.0 * hsl.l - q;
+    //     let h2c = |t: f32| {
+    //         let t = t.clamp(0.0, 1.0);
+    //         if 6.0 * t < 1.0 {
+    //             p + 6.0 * (q - p) * t
+    //         } else if t < 0.5 {
+    //             q
+    //         } else if 1.0 < 1.5 * t {
+    //             p + 6.0 * (q - p) * (1.0 / 1.5 - t)
+    //         } else {
+    //             p
+    //         }
+    //     };
+
+    //     Self::from_f32(h2c(hsl.h + 1.0 / 3.0), h2c(hsl.h), h2c(hsl.h - 1.0 / 3.0))
+    // }
+
+    /// Computes the linear interpolation between `self` and `other` for `t`
+    pub fn lerp(&self, other: Self, t: f32) -> Self {
+        let t = t.clamp(0.0, 1.0);
+        self * (1.0 - t) + other * t
+    }
+}
+
+impl From<(u8, u8, u8)> for Rgb {
+    fn from((r, g, b): (u8, u8, u8)) -> Self {
+        Self::new(r, g, b)
+    }
+}
+
+impl From<(f32, f32, f32)> for Rgb {
+    fn from((r, g, b): (f32, f32, f32)) -> Self {
+        Self::from_f32(r, g, b)
+    }
+}
+
+use crate::ANSIColorCode;
+use crate::TargetGround;
+impl ANSIColorCode for Rgb {
+    fn ansi_color_code(&self, target: TargetGround) -> String {
+        format!("{};2;{};{};{}", target.code() + 8, self.r, self.g, self.b)
+    }
+}
+
+overload::overload!(
+    (lhs: ?Rgb) + (rhs: ?Rgb) -> Rgb {
+        Rgb::new(
+            lhs.r.saturating_add(rhs.r),
+            lhs.g.saturating_add(rhs.g),
+            lhs.b.saturating_add(rhs.b)
+        )
+    }
+);
+
+overload::overload!(
+    (lhs: ?Rgb) - (rhs: ?Rgb) -> Rgb {
+        Rgb::new(
+            lhs.r.saturating_sub(rhs.r),
+            lhs.g.saturating_sub(rhs.g),
+            lhs.b.saturating_sub(rhs.b)
+        )
+    }
+);
+
+overload::overload!(
+    (lhs: ?Rgb) * (rhs: ?f32) -> Rgb {
+        Rgb::new(
+            (lhs.r as f32 * rhs.clamp(0.0, 1.0)) as u8,
+            (lhs.g as f32 * rhs.clamp(0.0, 1.0)) as u8,
+            (lhs.b as f32 * rhs.clamp(0.0, 1.0)) as u8
+        )
+    }
+);
+
+overload::overload!(
+    (lhs: ?f32) * (rhs: ?Rgb) -> Rgb {
+        Rgb::new(
+            (rhs.r as f32 * lhs.clamp(0.0, 1.0)) as u8,
+            (rhs.g as f32 * lhs.clamp(0.0, 1.0)) as u8,
+            (rhs.b as f32 * lhs.clamp(0.0, 1.0)) as u8
+        )
+    }
+);
+
+overload::overload!(
+    -(rgb: ?Rgb) -> Rgb {
+        Rgb::new(
+            255 - rgb.r,
+            255 - rgb.g,
+            255 - rgb.b)
+    }
+);

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

@@ -0,0 +1,626 @@
+/// 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 Default for Color {
+    fn default() -> Self {
+        Color::White
+    }
+}
+
+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 {
+            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), 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-cli/Cargo.toml

@@ -4,126 +4,39 @@ description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-cli"
-version = "0.21.0"
+version = "0.37.0"
+build = "build.rs"
 
 [lib]
 doctest = false
 
 [dependencies]
-nu-data = {version = "0.21.0", path = "../nu-data"}
-nu-errors = {version = "0.21.0", path = "../nu-errors"}
-nu-parser = {version = "0.21.0", path = "../nu-parser"}
-nu-plugin = {version = "0.21.0", path = "../nu-plugin"}
-nu-protocol = {version = "0.21.0", path = "../nu-protocol"}
-nu-source = {version = "0.21.0", path = "../nu-source"}
-nu-table = {version = "0.21.0", path = "../nu-table"}
-nu-test-support = {version = "0.21.0", path = "../nu-test-support"}
-nu-value-ext = {version = "0.21.0", path = "../nu-value-ext"}
+nu-completion = { version = "0.37.0", path="../nu-completion" }
+nu-command = { version = "0.37.0", path="../nu-command" }
+nu-data = { version = "0.37.0", path="../nu-data" }
+nu-engine = { version = "0.37.0", path="../nu-engine" }
+nu-errors = { version = "0.37.0", path="../nu-errors" }
+nu-parser = { version = "0.37.0", path="../nu-parser" }
+nu-protocol = { version = "0.37.0", path="../nu-protocol" }
+nu-source = { version = "0.37.0", path="../nu-source" }
+nu-stream = { version = "0.37.0", path="../nu-stream" }
+nu-ansi-term = { version = "0.37.0", path="../nu-ansi-term" }
 
-ansi_term = "0.12.1"
-async-recursion = "0.3.1"
-async-trait = "0.1.40"
-base64 = "0.12.3"
-bigdecimal = {version = "0.2.0", features = ["serde"]}
-byte-unit = "4.0.9"
-bytes = "0.5.6"
-calamine = "0.16.1"
-chrono = {version = "0.4.15", features = ["serde"]}
-clap = "2.33.3"
-codespan-reporting = "0.9.5"
-csv = "1.1.3"
-ctrlc = {version = "3.1.6", optional = true}
-derive-new = "0.5.8"
-directories = {version = "3.0.1", optional = true}
-dirs = {version = "3.0.1", optional = true}
-dtparse = "1.2.0"
-dunce = "1.0.1"
-eml-parser = "0.1.0"
-filesize = "0.2.0"
-fs_extra = "1.2.0"
-futures = {version = "0.3.5", features = ["compat", "io-compat"]}
-futures-util = "0.3.5"
-futures_codec = "0.4.1"
-getset = "0.1.1"
-git2 = {version = "0.13.11", default_features = false, optional = true}
-glob = "0.3.0"
-heim = {version = "0.1.0-beta.3", optional = true}
-htmlescape = "0.3.1"
-ical = "0.6.0"
-ichwh = {version = "0.3.4", optional = true}
-indexmap = {version = "1.6.0", features = ["serde-1"]}
-itertools = "0.9.0"
-log = "0.4.11"
-meval = "0.2.0"
-num-bigint = {version = "0.3.0", features = ["serde"]}
-num-format = {version = "0.4.0", features = ["with-num-bigint"]}
-num-traits = "0.2.12"
-parking_lot = "0.11.0"
-pin-utils = "0.1.0"
-pretty-hex = "0.2.0"
-ptree = {version = "0.3.0", optional = true}
-query_interface = "0.3.5"
-quick-xml = "0.18.1"
-rand = "0.7.3"
-regex = "1.3.9"
-roxmltree = "0.13.0"
-rust-embed = "5.6.0"
-rustyline = {version = "6.3.0", optional = true}
-serde = {version = "1.0.115", features = ["derive"]}
-serde-hjson = "0.9.1"
-serde_bytes = "0.11.5"
-serde_ini = "0.2.0"
-serde_json = "1.0.57"
-serde_urlencoded = "0.7.0"
-serde_yaml = "0.8.13"
-sha2 = "0.9.1"
-shellexpand = "2.0.0"
+indexmap ="1.6.1"
+log = "0.4.14"
+pretty_env_logger = "0.4.0"
 strip-ansi-escapes = "0.1.0"
-sxd-document = "0.3.2"
-sxd-xpath = "0.4.2"
-tempfile = "3.1.0"
-term = {version = "0.6.1", optional = true}
-term_size = "0.3.2"
-termcolor = "1.1.0"
-toml = "0.5.6"
-unicode-segmentation = "1.6.0"
-uom = {version = "0.28.0", features = ["f64", "try-from"]}
-uuid_crate = {package = "uuid", version = "0.8.1", features = ["v4"], optional = true}
-which = {version = "4.0.2", optional = true}
-zip = {version = "0.5.7", optional = true}
-
-Inflector = "0.11"
-clipboard = {version = "0.5.0", optional = true}
-encoding_rs = "0.8.24"
-rayon = "1.4.0"
-trash = {version = "1.1.1", optional = true}
-url = "2.1.1"
-
-[target.'cfg(unix)'.dependencies]
-umask = "1.0.0"
-users = "0.10.0"
-
-# TODO this will be possible with new dependency resolver
-#   (currently on nightly behind -Zfeatures=itarget):
-#   https://github.com/rust-lang/cargo/issues/7914
-#[target.'cfg(not(windows))'.dependencies]
-#num-format = {version = "0.4", features = ["with-system-locale"]}
-
-[dependencies.rusqlite]
-features = ["bundled", "blob"]
-optional = true
-version = "0.24.0"
+rustyline = { version="9.0.0", optional=true }
+ctrlc = { version="3.1.7", optional=true }
+shadow-rs = { version="0.6", default-features=false, optional=true }
+serde = { version="1.0.123", features=["derive"] }
+serde_yaml = "0.8.16"
+lazy_static = "1.4.0"
 
 [build-dependencies]
-git2 = {version = "0.13.11", optional = true}
-
-[dev-dependencies]
-quickcheck = "0.9.2"
-quickcheck_macros = "0.9.1"
+shadow-rs = "0.6"
 
 [features]
-clipboard-cli = ["clipboard"]
-rich-benchmark = ["heim"]
-rustyline-support = ["rustyline"]
+default = ["shadow-rs"]
+rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
 stable = []
-trash-support = ["trash"]

crates/nu-cli/README.md

@@ -0,0 +1,4 @@
+# nu-cli
+
+This crate provides the fundamental needs when creating the Nushell interactive REPL. In it, you'll find features for interacting with the line editor (the piece which writes the prompt and takes input from the user), keybindings, handlers for the commandline arguments passed to the REPL as it starts up, and more.
+

crates/nu-cli/build.rs

@@ -1,36 +1,3 @@
-use std::path::Path;
-use std::{env, fs, io};
-
-fn main() -> Result<(), io::Error> {
-    let out_dir = env::var_os("OUT_DIR").expect(
-    "\
-        OUT_DIR environment variable not found. \
-        OUT_DIR is guaranteed to to exist in a build script by cargo - see \
-        https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts\
-    ");
-
-    let latest_commit_hash = latest_commit_hash(env::current_dir()?).unwrap_or_default();
-
-    let commit_hash_path = Path::new(&out_dir).join("git_commit_hash");
-    fs::write(commit_hash_path, latest_commit_hash)?;
-
-    Ok(())
-}
-
-#[allow(unused_variables)]
-fn latest_commit_hash<P: AsRef<Path>>(dir: P) -> Result<String, Box<dyn std::error::Error>> {
-    #[cfg(feature = "git2")]
-    {
-        use git2::Repository;
-        let dir = dir.as_ref();
-        Ok(Repository::discover(dir)?
-            .head()?
-            .peel_to_commit()?
-            .id()
-            .to_string())
-    }
-    #[cfg(not(feature = "git2"))]
-    {
-        Ok(String::new())
-    }
+fn main() -> shadow_rs::SdResult<()> {
+    shadow_rs::new()
 }

crates/nu-cli/src/app.rs

@@ -0,0 +1,632 @@
+mod logger;
+mod options;
+mod options_parser;
+pub mod stopwatch;
+
+use self::stopwatch::Stopwatch;
+use lazy_static::lazy_static;
+use nu_command::{commands::NuSignature as Nu, utils::test_bins as binaries};
+use nu_engine::{get_full_help, EvaluationContext};
+use nu_errors::ShellError;
+use nu_protocol::hir::{Call, Expression, SpannedExpression, Synthetic};
+use nu_protocol::{Primitive, UntaggedValue};
+use nu_source::{Span, Tag};
+use nu_stream::InputStream;
+pub use options::{CliOptions, NuScript, Options};
+use options_parser::{NuParser, OptionsParser};
+use std::sync::Mutex;
+
+lazy_static! {
+    pub static ref STOPWATCH: Mutex<Stopwatch> = {
+        let mut sw = Stopwatch::default();
+        sw.start();
+        sw.stop();
+        Mutex::new(sw)
+    };
+}
+
+pub struct App {
+    parser: Box<dyn OptionsParser>,
+    pub options: Options,
+}
+
+impl App {
+    pub fn new(parser: Box<dyn OptionsParser>, options: Options) -> Self {
+        Self { parser, options }
+    }
+
+    pub fn run(args: &[String]) -> Result<(), ShellError> {
+        let nu = Box::new(NuParser::new());
+        let options = Options::default();
+        let ui = App::new(nu, options);
+
+        ui.main(args)
+    }
+
+    pub fn main(&self, argv: &[String]) -> Result<(), ShellError> {
+        if self.perf() {
+            // start the stopwatch running
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
+        let argv = quote_positionals(argv).join(" ");
+
+        if let Err(cause) = self.parse(&argv) {
+            self.parser
+                .context()
+                .host()
+                .lock()
+                .print_err(cause, &nu_source::Text::from(argv));
+            std::process::exit(1);
+        }
+
+        if self.help() {
+            let context = self.parser.context();
+            let stream = nu_stream::OutputStream::one(
+                UntaggedValue::string(get_full_help(&Nu, &context.scope))
+                    .into_value(nu_source::Tag::unknown()),
+            );
+
+            consume(context, stream)?;
+
+            if self.perf() {
+                // stop the stopwatch since we're exiting
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .stop();
+                eprintln!(
+                    "help {:?}",
+                    STOPWATCH
+                        .lock()
+                        .expect("unable to lock the stopwatch")
+                        .elapsed()
+                );
+            }
+
+            std::process::exit(0);
+        }
+
+        if self.version() {
+            let context = self.parser.context();
+
+            let stream = nu_command::commands::version(nu_engine::CommandArgs {
+                context: context.clone(),
+                call_info: nu_engine::UnevaluatedCallInfo {
+                    args: Call::new(
+                        Box::new(SpannedExpression::new(
+                            Expression::Synthetic(Synthetic::String("version".to_string())),
+                            Span::unknown(),
+                        )),
+                        Span::unknown(),
+                    ),
+                    name_tag: Tag::unknown(),
+                },
+                input: InputStream::empty(),
+            })?;
+
+            let stream = {
+                let command = context
+                    .get_command("pivot")
+                    .expect("could not find version command");
+
+                context.run_command(
+                    command,
+                    Tag::unknown(),
+                    Call::new(
+                        Box::new(SpannedExpression::new(
+                            Expression::Synthetic(Synthetic::String("pivot".to_string())),
+                            Span::unknown(),
+                        )),
+                        Span::unknown(),
+                    ),
+                    stream,
+                )?
+            };
+
+            consume(context, stream)?;
+
+            if self.perf() {
+                // stop the stopwatch since we're exiting
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .stop();
+                eprintln!(
+                    "version {:?}",
+                    STOPWATCH
+                        .lock()
+                        .expect("unable to lock the stopwatch")
+                        .elapsed()
+                );
+            }
+
+            std::process::exit(0);
+        }
+
+        if let Some(bin) = self.testbin() {
+            match bin.as_deref() {
+                Ok("echo_env") => binaries::echo_env(),
+                Ok("cococo") => binaries::cococo(),
+                Ok("meow") => binaries::meow(),
+                Ok("iecho") => binaries::iecho(),
+                Ok("fail") => binaries::fail(),
+                Ok("nonu") => binaries::nonu(),
+                Ok("chop") => binaries::chop(),
+                Ok("repeater") => binaries::repeater(),
+                _ => unreachable!(),
+            }
+
+            return Ok(());
+        }
+
+        let mut opts = CliOptions::new();
+        opts.config = self.config().map(std::ffi::OsString::from);
+        opts.stdin = self.takes_stdin();
+        opts.save_history = self.save_history();
+        opts.perf = self.perf();
+
+        use logger::{configure, debug_filters, logger, trace_filters};
+
+        logger(|builder| {
+            configure(self, builder)?;
+            trace_filters(self, builder)?;
+            debug_filters(self, builder)?;
+
+            Ok(())
+        })?;
+
+        if self.perf() {
+            // start a new split
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start()
+        }
+
+        if let Some(commands) = self.commands() {
+            let commands = commands?;
+            let script = NuScript::code(&commands)?;
+            opts.scripts = vec![script];
+            let context = crate::create_default_context(false)?;
+            return crate::run_script_file(context, opts);
+        }
+
+        if self.perf() {
+            // start a new spit
+            eprintln!(
+                "commands using -c at launch: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
+        if let Some(scripts) = self.scripts() {
+            let mut source_files = vec![];
+            for script in scripts {
+                let script_name = script?;
+                let path = std::ffi::OsString::from(&script_name);
+
+                match NuScript::source_file(path.as_os_str()) {
+                    Ok(file) => source_files.push(file),
+                    Err(_) => {
+                        eprintln!("File not found: {}", script_name);
+                        return Ok(());
+                    }
+                }
+            }
+
+            for file in source_files {
+                let mut opts = opts.clone();
+                opts.scripts = vec![file];
+
+                let context = crate::create_default_context(false)?;
+                crate::run_script_file(context, opts)?;
+            }
+
+            return Ok(());
+        }
+
+        if self.perf() {
+            // start a new split
+            eprintln!(
+                "script file(s) passed in: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .start();
+        }
+
+        let context = crate::create_default_context(true)?;
+
+        if !self.skip_plugins() {
+            let _ = crate::register_plugins(&context);
+        }
+
+        if self.perf() {
+            // start a new split
+            eprintln!(
+                "plugins registered: {:?}",
+                STOPWATCH
+                    .lock()
+                    .expect("unable to lock the stopwatch")
+                    .elapsed_split()
+            );
+        }
+
+        #[cfg(feature = "rustyline-support")]
+        {
+            crate::cli(context, opts)?;
+        }
+
+        #[cfg(not(feature = "rustyline-support"))]
+        {
+            println!("Nushell needs the 'rustyline-support' feature for CLI support");
+        }
+
+        Ok(())
+    }
+
+    pub fn commands(&self) -> Option<Result<String, ShellError>> {
+        self.options.get("commands").map(|v| match v.value {
+            UntaggedValue::Error(err) => Err(err),
+            UntaggedValue::Primitive(Primitive::String(name)) => Ok(name),
+            _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+        })
+    }
+
+    pub fn perf(&self) -> bool {
+        self.options
+            .get("perf")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn help(&self) -> bool {
+        self.options
+            .get("help")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn version(&self) -> bool {
+        self.options
+            .get("version")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn scripts(&self) -> Option<Vec<Result<String, ShellError>>> {
+        self.options.get("args").map(|v| {
+            v.table_entries()
+                .map(|v| match &v.value {
+                    UntaggedValue::Error(err) => Err(err.clone()),
+                    UntaggedValue::Primitive(Primitive::FilePath(path)) => {
+                        Ok(path.display().to_string())
+                    }
+                    UntaggedValue::Primitive(Primitive::String(name)) => Ok(name.clone()),
+                    _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+                })
+                .collect()
+        })
+    }
+
+    pub fn takes_stdin(&self) -> bool {
+        self.options
+            .get("stdin")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn config(&self) -> Option<String> {
+        self.options
+            .get("config-file")
+            .map(|v| v.as_string().expect("not a string"))
+    }
+
+    pub fn develop(&self) -> Option<Vec<Result<String, ShellError>>> {
+        self.options.get("develop").map(|v| {
+            let mut values = vec![];
+
+            match v.value {
+                UntaggedValue::Error(err) => values.push(Err(err)),
+                UntaggedValue::Primitive(Primitive::String(filters)) => {
+                    values.extend(filters.split(',').map(|filter| Ok(filter.to_string())));
+                }
+                _ => values.push(Err(ShellError::untagged_runtime_error(
+                    "Unsupported option",
+                ))),
+            };
+
+            values
+        })
+    }
+
+    pub fn debug(&self) -> Option<Vec<Result<String, ShellError>>> {
+        self.options.get("debug").map(|v| {
+            let mut values = vec![];
+
+            match v.value {
+                UntaggedValue::Error(err) => values.push(Err(err)),
+                UntaggedValue::Primitive(Primitive::String(filters)) => {
+                    values.extend(filters.split(',').map(|filter| Ok(filter.to_string())));
+                }
+                _ => values.push(Err(ShellError::untagged_runtime_error(
+                    "Unsupported option",
+                ))),
+            };
+
+            values
+        })
+    }
+
+    pub fn loglevel(&self) -> Option<Result<String, ShellError>> {
+        self.options.get("loglevel").map(|v| match v.value {
+            UntaggedValue::Error(err) => Err(err),
+            UntaggedValue::Primitive(Primitive::String(name)) => Ok(name),
+            _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+        })
+    }
+
+    pub fn testbin(&self) -> Option<Result<String, ShellError>> {
+        self.options.get("testbin").map(|v| match v.value {
+            UntaggedValue::Error(err) => Err(err),
+            UntaggedValue::Primitive(Primitive::String(name)) => Ok(name),
+            _ => Err(ShellError::untagged_runtime_error("Unsupported option")),
+        })
+    }
+
+    pub fn skip_plugins(&self) -> bool {
+        self.options
+            .get("skip-plugins")
+            .map(|v| matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(false)
+    }
+
+    pub fn save_history(&self) -> bool {
+        self.options
+            .get("no-history")
+            .map(|v| !matches!(v.as_bool(), Ok(true)))
+            .unwrap_or(true)
+    }
+
+    pub fn parse(&self, args: &str) -> Result<(), ShellError> {
+        self.parser.parse(args).map(|options| {
+            self.options.swap(&options);
+        })
+    }
+}
+
+fn quote_positionals(parameters: &[String]) -> Vec<String> {
+    parameters
+        .iter()
+        .cloned()
+        .map(|arg| {
+            if arg.contains(' ') {
+                format!("\"{}\"", arg)
+            } else {
+                arg
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
+fn consume(context: &EvaluationContext, stream: InputStream) -> Result<(), ShellError> {
+    let autoview_cmd = context
+        .get_command("autoview")
+        .expect("could not find autoview command");
+
+    let stream = context.run_command(
+        autoview_cmd,
+        Tag::unknown(),
+        Call::new(
+            Box::new(SpannedExpression::new(
+                Expression::Synthetic(Synthetic::String("autoview".to_string())),
+                Span::unknown(),
+            )),
+            Span::unknown(),
+        ),
+        stream,
+    )?;
+
+    for _ in stream {}
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn cli_app() -> App {
+        let parser = Box::new(NuParser::new());
+        let options = Options::default();
+
+        App::new(parser, options)
+    }
+
+    #[test]
+    fn default_options() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu")?;
+        assert!(!ui.version());
+        assert!(!ui.help());
+        assert!(!ui.takes_stdin());
+        assert!(ui.save_history());
+        assert!(!ui.skip_plugins());
+        assert_eq!(ui.config(), None);
+        assert_eq!(ui.loglevel(), None);
+        assert_eq!(ui.debug(), None);
+        assert_eq!(ui.develop(), None);
+        assert_eq!(ui.testbin(), None);
+        assert_eq!(ui.commands(), None);
+        assert_eq!(ui.scripts(), None);
+        Ok(())
+    }
+
+    #[test]
+    fn reports_errors_on_unsupported_flags() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        assert!(ui.parse("nu --coonfig-file /path/to/config.toml").is_err());
+        assert!(ui.config().is_none());
+        Ok(())
+    }
+
+    #[test]
+    fn configures_debug_trace_level_with_filters() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu --develop=cli,parser")?;
+        assert_eq!(ui.develop().unwrap()[0], Ok("cli".to_string()));
+        assert_eq!(ui.develop().unwrap()[1], Ok("parser".to_string()));
+        Ok(())
+    }
+
+    #[test]
+    fn configures_debug_level_with_filters() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu --debug=cli,run")?;
+        assert_eq!(ui.debug().unwrap()[0], Ok("cli".to_string()));
+        assert_eq!(ui.debug().unwrap()[1], Ok("run".to_string()));
+        Ok(())
+    }
+
+    #[test]
+    fn can_use_loglevels() -> Result<(), ShellError> {
+        for level in ["error", "warn", "info", "debug", "trace"] {
+            let ui = cli_app();
+            let args = format!("nu --loglevel={}", level);
+            ui.parse(&args)?;
+            assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
+
+            let ui = cli_app();
+            let args = format!("nu -l {}", level);
+            ui.parse(&args)?;
+            assert_eq!(ui.loglevel().unwrap(), Ok(level.to_string()));
+        }
+
+        let ui = cli_app();
+        ui.parse("nu --loglevel=nada")?;
+        assert_eq!(
+            ui.loglevel().unwrap(),
+            Err(ShellError::untagged_runtime_error("nada is not supported."))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn can_be_passed_nu_scripts() -> Result<(), ShellError> {
+        let ui = cli_app();
+        ui.parse("nu code.nu bootstrap.nu")?;
+        assert_eq!(ui.scripts().unwrap()[0], Ok("code.nu".into()));
+        assert_eq!(ui.scripts().unwrap()[1], Ok("bootstrap.nu".into()));
+        Ok(())
+    }
+
+    #[test]
+    fn can_use_test_binaries() -> Result<(), ShellError> {
+        for binarie_name in [
+            "echo_env", "cococo", "iecho", "fail", "nonu", "chop", "repeater", "meow",
+        ] {
+            let ui = cli_app();
+            let args = format!("nu --testbin={}", binarie_name);
+            ui.parse(&args)?;
+            assert_eq!(ui.testbin().unwrap(), Ok(binarie_name.to_string()));
+        }
+
+        let ui = cli_app();
+        ui.parse("nu --testbin=andres")?;
+        assert_eq!(
+            ui.testbin().unwrap(),
+            Err(ShellError::untagged_runtime_error(
+                "andres is not supported."
+            ))
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn has_version() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --version")?;
+        assert!(ui.version());
+        Ok(())
+    }
+
+    #[test]
+    fn has_help() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --help")?;
+        assert!(ui.help());
+        Ok(())
+    }
+
+    #[test]
+    fn can_take_stdin() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --stdin")?;
+        assert!(ui.takes_stdin());
+        Ok(())
+    }
+
+    #[test]
+    fn can_opt_to_avoid_saving_history() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --no-history")?;
+        assert!(!ui.save_history());
+        Ok(())
+    }
+
+    #[test]
+    fn can_opt_to_skip_plugins() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --skip-plugins")?;
+        assert!(ui.skip_plugins());
+        Ok(())
+    }
+
+    #[test]
+    fn understands_commands_need_to_be_run() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu -c \"ls | get name\"")?;
+        assert_eq!(ui.commands().unwrap(), Ok(String::from("ls | get name")));
+
+        let ui = cli_app();
+
+        ui.parse("nu -c \"echo 'hola'\"")?;
+        assert_eq!(ui.commands().unwrap(), Ok(String::from("echo 'hola'")));
+        Ok(())
+    }
+
+    #[test]
+    fn knows_custom_configurations() -> Result<(), ShellError> {
+        let ui = cli_app();
+
+        ui.parse("nu --config-file /path/to/config.toml")?;
+        assert_eq!(ui.config().unwrap(), String::from("/path/to/config.toml"));
+        Ok(())
+    }
+}

crates/nu-cli/src/app/logger.rs

@@ -0,0 +1,52 @@
+use super::App;
+use log::LevelFilter;
+use nu_errors::ShellError;
+use pretty_env_logger::env_logger::Builder;
+
+pub fn logger(f: impl FnOnce(&mut Builder) -> Result<(), ShellError>) -> Result<(), ShellError> {
+    let mut builder = pretty_env_logger::formatted_builder();
+    f(&mut builder)?;
+    let _ = builder.try_init();
+    Ok(())
+}
+
+pub fn configure(app: &App, logger: &mut Builder) -> Result<(), ShellError> {
+    if let Some(level) = app.loglevel() {
+        let level = match level.as_deref() {
+            Ok("error") => LevelFilter::Error,
+            Ok("warn") => LevelFilter::Warn,
+            Ok("info") => LevelFilter::Info,
+            Ok("debug") => LevelFilter::Debug,
+            Ok("trace") => LevelFilter::Trace,
+            Ok(_) | Err(_) => LevelFilter::Warn,
+        };
+
+        logger.filter_module("nu", level);
+    };
+
+    if let Ok(s) = std::env::var("RUST_LOG") {
+        logger.parse_filters(&s);
+    }
+
+    Ok(())
+}
+
+pub fn trace_filters(app: &App, logger: &mut Builder) -> Result<(), ShellError> {
+    if let Some(filters) = app.develop() {
+        filters.into_iter().filter_map(Result::ok).for_each(|name| {
+            logger.filter_module(&name, LevelFilter::Trace);
+        })
+    }
+
+    Ok(())
+}
+
+pub fn debug_filters(app: &App, logger: &mut Builder) -> Result<(), ShellError> {
+    if let Some(filters) = app.debug() {
+        filters.into_iter().filter_map(Result::ok).for_each(|name| {
+            logger.filter_module(&name, LevelFilter::Debug);
+        })
+    }
+
+    Ok(())
+}

crates/nu-cli/src/app/options.rs

@@ -0,0 +1,102 @@
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::{UntaggedValue, Value};
+use std::cell::RefCell;
+use std::ffi::{OsStr, OsString};
+
+#[derive(Debug, Clone)]
+pub struct CliOptions {
+    pub config: Option<OsString>,
+    pub stdin: bool,
+    pub scripts: Vec<NuScript>,
+    pub save_history: bool,
+    pub perf: bool,
+}
+
+impl Default for CliOptions {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CliOptions {
+    pub fn new() -> Self {
+        Self {
+            config: None,
+            stdin: false,
+            scripts: vec![],
+            save_history: true,
+            perf: false,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Options {
+    inner: RefCell<IndexMap<String, Value>>,
+}
+
+impl Options {
+    pub fn default() -> Self {
+        Self {
+            inner: RefCell::new(IndexMap::default()),
+        }
+    }
+
+    pub fn get(&self, key: &str) -> Option<Value> {
+        self.inner.borrow().get(key).cloned()
+    }
+
+    pub fn put(&self, key: &str, value: Value) {
+        self.inner.borrow_mut().insert(key.into(), value);
+    }
+
+    pub fn shift(&self) {
+        if let Some(Value {
+            value: UntaggedValue::Table(ref mut args),
+            ..
+        }) = self.inner.borrow_mut().get_mut("args")
+        {
+            args.remove(0);
+        }
+    }
+
+    pub fn swap(&self, other: &Options) {
+        self.inner.swap(&other.inner);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct NuScript {
+    pub filepath: Option<OsString>,
+    pub contents: String,
+}
+
+impl NuScript {
+    pub fn code(content: &str) -> Result<Self, ShellError> {
+        Ok(Self {
+            filepath: None,
+            contents: content.to_string(),
+        })
+    }
+
+    pub fn get_code(&self) -> &str {
+        &self.contents
+    }
+
+    pub fn source_file(path: &OsStr) -> Result<Self, ShellError> {
+        use std::fs::File;
+        use std::io::Read;
+
+        let path = path.to_os_string();
+        let mut file = File::open(&path)?;
+        let mut buffer = String::new();
+
+        file.read_to_string(&mut buffer)?;
+
+        Ok(Self {
+            filepath: Some(path),
+            contents: buffer,
+        })
+    }
+}

crates/nu-cli/src/app/options_parser.rs

@@ -0,0 +1,132 @@
+use super::Options;
+
+use nu_command::commands::{loglevels, testbins, NuSignature as Nu};
+use nu_command::commands::{Autoview, Pivot, Table, Version as NuVersion};
+use nu_engine::{whole_stream_command, EvaluationContext};
+use nu_errors::ShellError;
+use nu_protocol::hir::{ClassifiedCommand, InternalCommand, NamedValue};
+use nu_protocol::UntaggedValue;
+use nu_source::Tag;
+
+pub struct NuParser {
+    context: EvaluationContext,
+}
+
+pub trait OptionsParser {
+    fn parse(&self, input: &str) -> Result<Options, ShellError>;
+    fn context(&self) -> &EvaluationContext;
+}
+
+impl NuParser {
+    pub fn new() -> Self {
+        let context = EvaluationContext::basic();
+        context.add_commands(vec![
+            whole_stream_command(Nu {}),
+            whole_stream_command(NuVersion {}),
+            whole_stream_command(Autoview {}),
+            whole_stream_command(Pivot {}),
+            whole_stream_command(Table {}),
+        ]);
+
+        Self { context }
+    }
+}
+
+impl OptionsParser for NuParser {
+    fn context(&self) -> &EvaluationContext {
+        &self.context
+    }
+
+    fn parse(&self, input: &str) -> Result<Options, ShellError> {
+        let options = Options::default();
+        let (lite_result, _err) = nu_parser::lex(input, 0, nu_parser::NewlineMode::Normal);
+        let (lite_result, _err) = nu_parser::parse_block(lite_result);
+
+        let (parsed, err) = nu_parser::classify_block(&lite_result, &self.context.scope);
+
+        if let Some(reason) = err {
+            return Err(reason.into());
+        }
+
+        match parsed.block[0].pipelines[0].list[0] {
+            ClassifiedCommand::Internal(InternalCommand { ref args, .. }) => {
+                if let Some(ref params) = args.named {
+                    params.iter().for_each(|(k, v)| {
+                        let value = match v {
+                            NamedValue::AbsentSwitch => {
+                                Some(UntaggedValue::from(false).into_untagged_value())
+                            }
+                            NamedValue::PresentSwitch(span) => {
+                                Some(UntaggedValue::from(true).into_value(Tag::from(span)))
+                            }
+                            NamedValue::AbsentValue => None,
+                            NamedValue::Value(span, exprs) => {
+                                let value = nu_engine::evaluate_baseline_expr(exprs, &self.context)
+                                    .expect("value");
+                                Some(value.value.into_value(Tag::from(span)))
+                            }
+                        };
+
+                        let value = value.map(|v| match k.as_ref() {
+                            "testbin" => {
+                                if let Ok(name) = v.as_string() {
+                                    if testbins().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
+                                    }
+                                } else {
+                                    v
+                                }
+                            }
+                            "loglevel" => {
+                                if let Ok(name) = v.as_string() {
+                                    if loglevels().iter().any(|n| name == *n) {
+                                        v
+                                    } else {
+                                        UntaggedValue::Error(ShellError::untagged_runtime_error(
+                                            format!("{} is not supported.", name),
+                                        ))
+                                        .into_value(v.tag)
+                                    }
+                                } else {
+                                    v
+                                }
+                            }
+                            _ => v,
+                        });
+
+                        if let Some(value) = value {
+                            options.put(k, value);
+                        }
+                    });
+                }
+
+                let mut positional_args = vec![];
+
+                if let Some(positional) = &args.positional {
+                    for pos in positional {
+                        let result = nu_engine::evaluate_baseline_expr(pos, &self.context)?;
+                        positional_args.push(result);
+                    }
+                }
+
+                if !positional_args.is_empty() {
+                    options.put(
+                        "args",
+                        UntaggedValue::Table(positional_args).into_untagged_value(),
+                    );
+                }
+            }
+            ClassifiedCommand::Error(ref reason) => {
+                return Err(reason.clone().into());
+            }
+            _ => return Err(ShellError::untagged_runtime_error("unrecognized command")),
+        }
+
+        Ok(options)
+    }
+}

crates/nu-cli/src/app/stopwatch.rs

@@ -0,0 +1,118 @@
+#![allow(dead_code)]
+use std::default::Default;
+use std::fmt;
+use std::time::{Duration, Instant};
+
+#[derive(Clone, Copy)]
+pub struct Stopwatch {
+    /// The time the stopwatch was started last, if ever.
+    start_time: Option<Instant>,
+    /// The time the stopwatch was split last, if ever.
+    split_time: Option<Instant>,
+    /// The time elapsed while the stopwatch was running (between start() and stop()).
+    elapsed: Duration,
+}
+
+impl Default for Stopwatch {
+    fn default() -> Stopwatch {
+        Stopwatch {
+            start_time: None,
+            split_time: None,
+            elapsed: Duration::from_secs(0),
+        }
+    }
+}
+
+impl fmt::Display for Stopwatch {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        return write!(f, "{}ms", self.elapsed_ms());
+    }
+}
+
+impl Stopwatch {
+    /// Returns a new stopwatch.
+    pub fn new() -> Stopwatch {
+        let sw: Stopwatch = Default::default();
+        sw
+    }
+
+    /// Returns a new stopwatch which will immediately be started.
+    pub fn start_new() -> Stopwatch {
+        let mut sw = Stopwatch::new();
+        sw.start();
+        sw
+    }
+
+    /// Starts the stopwatch.
+    pub fn start(&mut self) {
+        self.start_time = Some(Instant::now());
+    }
+
+    /// Stops the stopwatch.
+    pub fn stop(&mut self) {
+        self.elapsed = self.elapsed();
+        self.start_time = None;
+        self.split_time = None;
+    }
+
+    /// Resets all counters and stops the stopwatch.
+    pub fn reset(&mut self) {
+        self.elapsed = Duration::from_secs(0);
+        self.start_time = None;
+        self.split_time = None;
+    }
+
+    /// Resets and starts the stopwatch again.
+    pub fn restart(&mut self) {
+        self.reset();
+        self.start();
+    }
+
+    /// Returns whether the stopwatch is running.
+    pub fn is_running(&self) -> bool {
+        self.start_time.is_some()
+    }
+
+    /// Returns the elapsed time since the start of the stopwatch.
+    pub fn elapsed(&self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(t1) => t1.elapsed() + self.elapsed,
+            // stopwatch is not running
+            None => self.elapsed,
+        }
+    }
+
+    /// Returns the elapsed time since the start of the stopwatch in milliseconds.
+    pub fn elapsed_ms(&self) -> i64 {
+        let dur = self.elapsed();
+        (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64
+    }
+
+    /// Returns the elapsed time since last split or start/restart.
+    ///
+    /// If the stopwatch is in stopped state this will always return a zero Duration.
+    pub fn elapsed_split(&mut self) -> Duration {
+        match self.start_time {
+            // stopwatch is running
+            Some(start) => {
+                let res = match self.split_time {
+                    Some(split) => split.elapsed(),
+                    None => start.elapsed(),
+                };
+                self.split_time = Some(Instant::now());
+                res
+            }
+            // stopwatch is not running
+            None => Duration::from_secs(0),
+        }
+    }
+
+    /// Returns the elapsed time since last split or start/restart in milliseconds.
+    ///
+    /// If the stopwatch is in stopped state this will always return zero.
+    pub fn elapsed_split_ms(&mut self) -> i64 {
+        let dur = self.elapsed_split();
+        (dur.as_secs() * 1000 + dur.subsec_millis() as u64) as i64
+    }
+}

crates/nu-cli/src/command_registry.rs

@@ -1,64 +0,0 @@
-use crate::commands::Command;
-use indexmap::IndexMap;
-use nu_errors::ShellError;
-use nu_parser::SignatureRegistry;
-use nu_protocol::Signature;
-use parking_lot::Mutex;
-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()
-    }
-}

crates/nu-cli/src/commands.rs

@@ -1,308 +0,0 @@
-#[macro_use]
-pub(crate) mod macros;
-
-mod from_delimited_data;
-mod to_delimited_data;
-
-pub(crate) mod alias;
-pub(crate) mod ansi;
-pub(crate) mod append;
-pub(crate) mod args;
-pub(crate) mod autoenv;
-pub(crate) mod autoenv_trust;
-pub(crate) mod autoenv_untrust;
-pub(crate) mod autoview;
-pub(crate) mod benchmark;
-pub(crate) mod build_string;
-pub(crate) mod cal;
-pub(crate) mod cd;
-pub(crate) mod char_;
-pub(crate) mod chart;
-pub(crate) mod classified;
-#[cfg(feature = "clipboard-cli")]
-pub(crate) mod clip;
-pub(crate) mod command;
-pub(crate) mod compact;
-pub(crate) mod config;
-pub(crate) mod constants;
-pub(crate) mod count;
-pub(crate) mod cp;
-pub(crate) mod date;
-pub(crate) mod debug;
-pub(crate) mod default;
-pub(crate) mod describe;
-pub(crate) mod do_;
-pub(crate) mod drop;
-pub(crate) mod du;
-pub(crate) mod each;
-pub(crate) mod echo;
-pub(crate) mod empty;
-pub(crate) mod enter;
-pub(crate) mod every;
-pub(crate) mod exec;
-pub(crate) mod exit;
-pub(crate) mod first;
-pub(crate) mod format;
-pub(crate) mod from;
-pub(crate) mod from_csv;
-pub(crate) mod from_eml;
-pub(crate) mod from_ics;
-pub(crate) mod from_ini;
-pub(crate) mod from_json;
-pub(crate) mod from_ods;
-pub(crate) mod from_ssv;
-pub(crate) mod from_toml;
-pub(crate) mod from_tsv;
-pub(crate) mod from_url;
-pub(crate) mod from_vcf;
-pub(crate) mod from_xlsx;
-pub(crate) mod from_xml;
-pub(crate) mod from_yaml;
-pub(crate) mod get;
-pub(crate) mod group_by;
-pub(crate) mod group_by_date;
-pub(crate) mod headers;
-pub(crate) mod help;
-pub(crate) mod histogram;
-pub(crate) mod history;
-pub(crate) mod if_;
-pub(crate) mod insert;
-pub(crate) mod into_int;
-pub(crate) mod keep;
-pub(crate) mod last;
-pub(crate) mod lines;
-pub(crate) mod ls;
-pub(crate) mod math;
-pub(crate) mod merge;
-pub(crate) mod mkdir;
-pub(crate) mod move_;
-pub(crate) mod next;
-pub(crate) mod nth;
-pub(crate) mod nu;
-pub(crate) mod open;
-pub(crate) mod parse;
-pub(crate) mod path;
-pub(crate) mod pivot;
-pub(crate) mod prepend;
-pub(crate) mod prev;
-pub(crate) mod pwd;
-pub(crate) mod random;
-pub(crate) mod range;
-pub(crate) mod reduce;
-pub(crate) mod reject;
-pub(crate) mod rename;
-pub(crate) mod reverse;
-pub(crate) mod rm;
-pub(crate) mod run_alias;
-pub(crate) mod run_external;
-pub(crate) mod save;
-pub(crate) mod select;
-pub(crate) mod shells;
-pub(crate) mod shuffle;
-pub(crate) mod size;
-pub(crate) mod skip;
-pub(crate) mod sleep;
-pub(crate) mod sort_by;
-pub(crate) mod split;
-pub(crate) mod split_by;
-pub(crate) mod str_;
-pub(crate) mod table;
-pub(crate) mod tags;
-pub(crate) mod to;
-pub(crate) mod to_csv;
-pub(crate) mod to_html;
-pub(crate) mod to_json;
-pub(crate) mod to_md;
-pub(crate) mod to_toml;
-pub(crate) mod to_tsv;
-pub(crate) mod to_url;
-pub(crate) mod to_xml;
-pub(crate) mod to_yaml;
-pub(crate) mod uniq;
-pub(crate) mod update;
-pub(crate) mod url_;
-pub(crate) mod version;
-pub(crate) mod where_;
-pub(crate) mod which_;
-pub(crate) mod with_env;
-pub(crate) mod wrap;
-
-pub(crate) use autoview::Autoview;
-pub(crate) use cd::Cd;
-pub(crate) use command::{
-    whole_stream_command, Command, Example, UnevaluatedCallInfo, WholeStreamCommand,
-};
-
-pub(crate) use alias::Alias;
-pub(crate) use ansi::Ansi;
-pub(crate) use append::Command as Append;
-pub(crate) use autoenv::Autoenv;
-pub(crate) use autoenv_trust::AutoenvTrust;
-pub(crate) use autoenv_untrust::AutoenvUnTrust;
-pub(crate) use benchmark::Benchmark;
-pub(crate) use build_string::BuildString;
-pub(crate) use cal::Cal;
-pub(crate) use char_::Char;
-pub(crate) use chart::Chart;
-pub(crate) use compact::Compact;
-pub(crate) use config::{
-    Config, ConfigClear, ConfigGet, ConfigLoad, ConfigPath, ConfigRemove, ConfigSet, ConfigSetInto,
-};
-pub(crate) use count::Count;
-pub(crate) use cp::Cpy;
-pub(crate) use date::{Date, DateFormat, DateNow, DateUTC};
-pub(crate) use debug::Debug;
-pub(crate) use default::Default;
-pub(crate) use describe::Describe;
-pub(crate) use do_::Do;
-pub(crate) use drop::Drop;
-pub(crate) use du::Du;
-pub(crate) use each::Each;
-pub(crate) use each::EachGroup;
-pub(crate) use each::EachWindow;
-pub(crate) use echo::Echo;
-pub(crate) use empty::Command as Empty;
-pub(crate) use if_::If;
-pub(crate) use nu::NuPlugin;
-pub(crate) use update::Command as Update;
-pub(crate) mod kill;
-pub(crate) use kill::Kill;
-pub(crate) mod clear;
-pub(crate) use clear::Clear;
-pub(crate) mod touch;
-pub(crate) use enter::Enter;
-pub(crate) use every::Every;
-pub(crate) use exec::Exec;
-pub(crate) use exit::Exit;
-pub(crate) use first::First;
-pub(crate) use format::Format;
-pub(crate) use from::From;
-pub(crate) use from_csv::FromCSV;
-pub(crate) use from_eml::FromEML;
-pub(crate) use from_ics::FromIcs;
-pub(crate) use from_ini::FromINI;
-pub(crate) use from_json::FromJSON;
-pub(crate) use from_ods::FromODS;
-pub(crate) use from_ssv::FromSSV;
-pub(crate) use from_toml::FromTOML;
-pub(crate) use from_tsv::FromTSV;
-pub(crate) use from_url::FromURL;
-pub(crate) use from_vcf::FromVcf;
-pub(crate) use from_xlsx::FromXLSX;
-pub(crate) use from_xml::FromXML;
-pub(crate) use from_yaml::FromYAML;
-pub(crate) use from_yaml::FromYML;
-pub(crate) use get::Get;
-pub(crate) use group_by::Command as GroupBy;
-pub(crate) use group_by_date::GroupByDate;
-pub(crate) use headers::Headers;
-pub(crate) use help::Help;
-pub(crate) use histogram::Histogram;
-pub(crate) use history::History;
-pub(crate) use insert::Command as Insert;
-pub(crate) use into_int::IntoInt;
-pub(crate) use keep::{Keep, KeepUntil, KeepWhile};
-pub(crate) use last::Last;
-pub(crate) use lines::Lines;
-pub(crate) use ls::Ls;
-pub(crate) use math::{
-    Math, MathAverage, MathEval, MathMaximum, MathMedian, MathMinimum, MathMode, MathProduct,
-    MathStddev, MathSummation, MathVariance,
-};
-pub(crate) use merge::Merge;
-pub(crate) use mkdir::Mkdir;
-pub(crate) use move_::{Move, MoveColumn, Mv};
-pub(crate) use next::Next;
-pub(crate) use nth::Nth;
-pub(crate) use open::Open;
-pub(crate) use parse::Parse;
-pub(crate) use path::{
-    PathBasename, PathCommand, PathDirname, PathExists, PathExpand, PathExtension, PathFilestem,
-    PathType,
-};
-pub(crate) use pivot::Pivot;
-pub(crate) use prepend::Prepend;
-pub(crate) use prev::Previous;
-pub(crate) use pwd::Pwd;
-#[cfg(feature = "uuid_crate")]
-pub(crate) use random::RandomUUID;
-pub(crate) use random::{Random, RandomBool, RandomDice, RandomInteger};
-pub(crate) use range::Range;
-pub(crate) use reduce::Reduce;
-pub(crate) use reject::Reject;
-pub(crate) use rename::Rename;
-pub(crate) use reverse::Reverse;
-pub(crate) use rm::Remove;
-pub(crate) use run_external::RunExternalCommand;
-pub(crate) use save::Save;
-pub(crate) use select::Select;
-pub(crate) use shells::Shells;
-pub(crate) use shuffle::Shuffle;
-pub(crate) use size::Size;
-pub(crate) use skip::{Skip, SkipUntil, SkipWhile};
-pub(crate) use sleep::Sleep;
-pub(crate) use sort_by::SortBy;
-pub(crate) use split::{Split, SplitChars, SplitColumn, SplitRow};
-pub(crate) use split_by::SplitBy;
-pub(crate) use str_::{
-    Str, StrCamelCase, StrCapitalize, StrCollect, StrContains, StrDowncase, StrEndsWith,
-    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLPad, StrLength, StrPascalCase, StrRPad,
-    StrReverse, StrScreamingSnakeCase, StrSet, StrSnakeCase, StrStartsWith, StrSubstring,
-    StrToDatetime, StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
-};
-pub(crate) use table::Table;
-pub(crate) use tags::Tags;
-pub(crate) use to::To;
-pub(crate) use to_csv::ToCSV;
-pub(crate) use to_html::ToHTML;
-pub(crate) use to_json::ToJSON;
-pub(crate) use to_md::ToMarkdown;
-pub(crate) use to_toml::ToTOML;
-pub(crate) use to_tsv::ToTSV;
-pub(crate) use to_url::ToURL;
-pub(crate) use to_xml::ToXML;
-pub(crate) use to_yaml::ToYAML;
-pub(crate) use touch::Touch;
-pub(crate) use uniq::Uniq;
-pub(crate) use url_::{UrlCommand, UrlHost, UrlPath, UrlQuery, UrlScheme};
-pub(crate) use version::Version;
-pub(crate) use where_::Where;
-pub(crate) use which_::Which;
-pub(crate) use with_env::WithEnv;
-pub(crate) use wrap::Wrap;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::commands::whole_stream_command;
-    use crate::examples::{test_anchors, test_examples};
-    use nu_errors::ShellError;
-
-    fn commands() -> Vec<Command> {
-        vec![
-            whole_stream_command(Append),
-            whole_stream_command(GroupBy),
-            whole_stream_command(Insert),
-            whole_stream_command(Update),
-            whole_stream_command(Empty),
-        ]
-    }
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        for cmd in commands() {
-            test_examples(cmd)?;
-        }
-
-        Ok(())
-    }
-
-    #[test]
-    fn tracks_metadata() -> Result<(), ShellError> {
-        for cmd in commands() {
-            test_anchors(cmd)?;
-        }
-
-        Ok(())
-    }
-}

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

@@ -1,351 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_data::config;
-use nu_errors::ShellError;
-use nu_parser::SignatureRegistry;
-use nu_protocol::hir::{ClassifiedCommand, Expression, NamedValue, SpannedExpression, Variable};
-use nu_protocol::{
-    hir::Block, CommandAction, NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape,
-    UntaggedValue, Value,
-};
-use nu_source::Tagged;
-use std::collections::HashMap;
-
-pub struct Alias;
-
-#[derive(Deserialize)]
-pub struct AliasArgs {
-    pub name: Tagged<String>,
-    pub args: Vec<Value>,
-    pub block: Block,
-    pub infer: Option<bool>,
-    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("infer", "infer argument types (experimental)", Some('i'))
-            .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,
-            infer,
-            save,
-        },
-        _ctx,
-    ) = args.process(&registry).await?;
-    let mut processed_args: Vec<String> = vec![];
-
-    if let Some(true) = save {
-        let mut result = nu_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", "") // TODO using regex (or reconstruct string from AST?)
-            .replace("-si", "-i")
-            .replace("-s ", "")
-            .replace("-is", "-i");
-        let right = raw_input[right_brace..]
-            .replace("--save", "")
-            .replace("-si", "-i")
-            .replace("-s ", "")
-            .replace("-is", "-i");
-        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(),
-            ));
-        }
-    }
-
-    if let Some(true) = infer {
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::AddAlias(
-                name.to_string(),
-                to_arg_shapes(processed_args, &block, &registry)?,
-                block,
-            ),
-        )))
-    } else {
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::AddAlias(
-                name.to_string(),
-                processed_args
-                    .into_iter()
-                    .map(|arg| (arg, SyntaxShape::Any))
-                    .collect(),
-                block,
-            ),
-        )))
-    }
-}
-
-fn to_arg_shapes(
-    args: Vec<String>,
-    block: &Block,
-    registry: &CommandRegistry,
-) -> Result<Vec<(String, SyntaxShape)>, ShellError> {
-    match find_block_shapes(block, registry) {
-        Ok(found) => Ok(args
-            .iter()
-            .map(|arg| {
-                (
-                    arg.clone(),
-                    match found.get(arg) {
-                        None | Some((_, None)) => SyntaxShape::Any,
-                        Some((_, Some(shape))) => *shape,
-                    },
-                )
-            })
-            .collect()),
-        Err(err) => Err(err),
-    }
-}
-
-type ShapeMap = HashMap<String, (Span, Option<SyntaxShape>)>;
-
-fn check_insert(
-    existing: &mut ShapeMap,
-    to_add: (String, (Span, Option<SyntaxShape>)),
-) -> Result<(), ShellError> {
-    match (to_add.1).1 {
-        None => match existing.get(&to_add.0) {
-            None => {
-                existing.insert(to_add.0, to_add.1);
-                Ok(())
-            }
-            Some(_) => Ok(()),
-        },
-        Some(new) => match existing.insert(to_add.0.clone(), ((to_add.1).0, Some(new))) {
-            None => Ok(()),
-            Some(exist) => match exist.1 {
-                None => Ok(()),
-                Some(shape) => match shape {
-                    SyntaxShape::Any => Ok(()),
-                    shape if shape == new => Ok(()),
-                    _ => Err(ShellError::labeled_error_with_secondary(
-                        "Type conflict in alias variable use",
-                        format!("{:?}", new),
-                        (to_add.1).0,
-                        format!("{:?}", shape),
-                        exist.0,
-                    )),
-                },
-            },
-        },
-    }
-}
-
-fn check_merge(existing: &mut ShapeMap, new: &ShapeMap) -> Result<(), ShellError> {
-    for (k, v) in new.iter() {
-        check_insert(existing, (k.clone(), *v))?;
-    }
-
-    Ok(())
-}
-
-fn find_expr_shapes(
-    spanned_expr: &SpannedExpression,
-    registry: &CommandRegistry,
-) -> Result<ShapeMap, ShellError> {
-    match &spanned_expr.expr {
-        // TODO range will need similar if/when invocations can be parsed within range expression
-        Expression::Binary(bin) => find_expr_shapes(&bin.left, registry).and_then(|mut left| {
-            find_expr_shapes(&bin.right, registry)
-                .and_then(|right| check_merge(&mut left, &right).map(|()| left))
-        }),
-        Expression::Block(b) => find_block_shapes(&b, registry),
-        Expression::Path(path) => match &path.head.expr {
-            Expression::Invocation(b) => find_block_shapes(&b, registry),
-            Expression::Variable(Variable::Other(var, _)) => {
-                let mut result = HashMap::new();
-                result.insert(var.to_string(), (spanned_expr.span, None));
-                Ok(result)
-            }
-            _ => Ok(HashMap::new()),
-        },
-        _ => Ok(HashMap::new()),
-    }
-}
-
-fn find_block_shapes(block: &Block, registry: &CommandRegistry) -> Result<ShapeMap, ShellError> {
-    let apply_shape = |found: ShapeMap, sig_shape: SyntaxShape| -> ShapeMap {
-        found
-            .iter()
-            .map(|(v, sh)| match sh.1 {
-                None => (v.clone(), (sh.0, Some(sig_shape))),
-                Some(shape) => (v.clone(), (sh.0, Some(shape))),
-            })
-            .collect()
-    };
-
-    let mut arg_shapes = HashMap::new();
-    for pipeline in &block.block {
-        for classified in &pipeline.list {
-            match classified {
-                ClassifiedCommand::Expr(spanned_expr) => {
-                    let found = find_expr_shapes(&spanned_expr, registry)?;
-                    check_merge(&mut arg_shapes, &found)?
-                }
-                ClassifiedCommand::Internal(internal) => {
-                    if let Some(signature) = registry.get(&internal.name) {
-                        if let Some(positional) = &internal.args.positional {
-                            for (i, spanned_expr) in positional.iter().enumerate() {
-                                let found = find_expr_shapes(&spanned_expr, registry)?;
-                                if i >= signature.positional.len() {
-                                    if let Some((sig_shape, _)) = &signature.rest_positional {
-                                        check_merge(
-                                            &mut arg_shapes,
-                                            &apply_shape(found, *sig_shape),
-                                        )?;
-                                    } else {
-                                        unreachable!("should have error'd in parsing");
-                                    }
-                                } else {
-                                    let (pos_type, _) = &signature.positional[i];
-                                    match pos_type {
-                                        // TODO pass on mandatory/optional?
-                                        PositionalType::Mandatory(_, sig_shape)
-                                        | PositionalType::Optional(_, sig_shape) => {
-                                            check_merge(
-                                                &mut arg_shapes,
-                                                &apply_shape(found, *sig_shape),
-                                            )?;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        if let Some(named) = &internal.args.named {
-                            for (name, val) in named.iter() {
-                                if let NamedValue::Value(_, spanned_expr) = val {
-                                    let found = find_expr_shapes(&spanned_expr, registry)?;
-                                    match signature.named.get(name) {
-                                        None => {
-                                            unreachable!("should have error'd in parsing");
-                                        }
-                                        Some((named_type, _)) => {
-                                            if let NamedType::Mandatory(_, sig_shape)
-                                            | NamedType::Optional(_, sig_shape) = named_type
-                                            {
-                                                check_merge(
-                                                    &mut arg_shapes,
-                                                    &apply_shape(found, *sig_shape),
-                                                )?;
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    } else {
-                        unreachable!("registry has lost name it provided");
-                    }
-                }
-                ClassifiedCommand::Dynamic(_) | ClassifiedCommand::Error(_) => (),
-            }
-        }
-    }
-
-    Ok(arg_shapes)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Alias;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Alias {})?)
-    }
-}

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

@@ -1,146 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use ansi_term::Color;
-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(),
-            ))
-        }
-    }
-}
-
-pub fn str_to_ansi_color(s: String) -> Option<String> {
-    match s.as_str() {
-        "g" | "green" => Some(Color::Green.prefix().to_string()),
-        "gb" | "green_bold" => Some(Color::Green.bold().prefix().to_string()),
-        "gu" | "green_underline" => Some(Color::Green.underline().prefix().to_string()),
-        "gi" | "green_italic" => Some(Color::Green.italic().prefix().to_string()),
-        "gd" | "green_dimmed" => Some(Color::Green.dimmed().prefix().to_string()),
-        "gr" | "green_reverse" => Some(Color::Green.reverse().prefix().to_string()),
-        "r" | "red" => Some(Color::Red.prefix().to_string()),
-        "rb" | "red_bold" => Some(Color::Red.bold().prefix().to_string()),
-        "ru" | "red_underline" => Some(Color::Red.underline().prefix().to_string()),
-        "ri" | "red_italic" => Some(Color::Red.italic().prefix().to_string()),
-        "rd" | "red_dimmed" => Some(Color::Red.dimmed().prefix().to_string()),
-        "rr" | "red_reverse" => Some(Color::Red.reverse().prefix().to_string()),
-        "u" | "blue" => Some(Color::Blue.prefix().to_string()),
-        "ub" | "blue_bold" => Some(Color::Blue.bold().prefix().to_string()),
-        "uu" | "blue_underline" => Some(Color::Blue.underline().prefix().to_string()),
-        "ui" | "blue_italic" => Some(Color::Blue.italic().prefix().to_string()),
-        "ud" | "blue_dimmed" => Some(Color::Blue.dimmed().prefix().to_string()),
-        "ur" | "blue_reverse" => Some(Color::Blue.reverse().prefix().to_string()),
-        "b" | "black" => Some(Color::Black.prefix().to_string()),
-        "bb" | "black_bold" => Some(Color::Black.bold().prefix().to_string()),
-        "bu" | "black_underline" => Some(Color::Black.underline().prefix().to_string()),
-        "bi" | "black_italic" => Some(Color::Black.italic().prefix().to_string()),
-        "bd" | "black_dimmed" => Some(Color::Black.dimmed().prefix().to_string()),
-        "br" | "black_reverse" => Some(Color::Black.reverse().prefix().to_string()),
-        "y" | "yellow" => Some(Color::Yellow.prefix().to_string()),
-        "yb" | "yellow_bold" => Some(Color::Yellow.bold().prefix().to_string()),
-        "yu" | "yellow_underline" => Some(Color::Yellow.underline().prefix().to_string()),
-        "yi" | "yellow_italic" => Some(Color::Yellow.italic().prefix().to_string()),
-        "yd" | "yellow_dimmed" => Some(Color::Yellow.dimmed().prefix().to_string()),
-        "yr" | "yellow_reverse" => Some(Color::Yellow.reverse().prefix().to_string()),
-        "p" | "purple" => Some(Color::Purple.prefix().to_string()),
-        "pb" | "purple_bold" => Some(Color::Purple.bold().prefix().to_string()),
-        "pu" | "purple_underline" => Some(Color::Purple.underline().prefix().to_string()),
-        "pi" | "purple_italic" => Some(Color::Purple.italic().prefix().to_string()),
-        "pd" | "purple_dimmed" => Some(Color::Purple.dimmed().prefix().to_string()),
-        "pr" | "purple_reverse" => Some(Color::Purple.reverse().prefix().to_string()),
-        "c" | "cyan" => Some(Color::Cyan.prefix().to_string()),
-        "cb" | "cyan_bold" => Some(Color::Cyan.bold().prefix().to_string()),
-        "cu" | "cyan_underline" => Some(Color::Cyan.underline().prefix().to_string()),
-        "ci" | "cyan_italic" => Some(Color::Cyan.italic().prefix().to_string()),
-        "cd" | "cyan_dimmed" => Some(Color::Cyan.dimmed().prefix().to_string()),
-        "cr" | "cyan_reverse" => Some(Color::Cyan.reverse().prefix().to_string()),
-        "w" | "white" => Some(Color::White.prefix().to_string()),
-        "wb" | "white_bold" => Some(Color::White.bold().prefix().to_string()),
-        "wu" | "white_underline" => Some(Color::White.underline().prefix().to_string()),
-        "wi" | "white_italic" => Some(Color::White.italic().prefix().to_string()),
-        "wd" | "white_dimmed" => Some(Color::White.dimmed().prefix().to_string()),
-        "wr" | "white_reverse" => Some(Color::White.reverse().prefix().to_string()),
-        "reset" => Some("\x1b[0m".to_owned()),
-        _ => None,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Ansi;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Ansi {})?)
-    }
-}

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

@@ -1,63 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-
-#[derive(Deserialize)]
-struct Arguments {
-    row: Value,
-}
-
-pub struct Command;
-
-#[async_trait]
-impl WholeStreamCommand for Command {
-    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 (Arguments { mut row }, input) = args.process(registry).await?;
-
-        let input: Vec<Value> = input.collect().await;
-
-        if let Some(first) = input.get(0) {
-            row.tag = first.tag();
-        }
-
-        Ok(
-            futures::stream::iter(input.into_iter().chain(vec![row]).map(ReturnSuccess::value))
-                .to_output_stream(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Add something to the end of a list or table",
-            example: "echo [1 2 3] | append 4",
-            result: Some(vec![
-                UntaggedValue::int(1).into(),
-                UntaggedValue::int(2).into(),
-                UntaggedValue::int(3).into(),
-                UntaggedValue::int(4).into(),
-            ]),
-        }]
-    }
-}

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

@@ -1,92 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-use serde::Deserialize;
-use serde::Serialize;
-use sha2::{Digest, Sha256};
-use std::io::Read;
-use std::path::PathBuf;
-pub struct Autoenv;
-
-#[derive(Deserialize, Serialize, Debug, Default)]
-pub struct Trusted {
-    pub files: IndexMap<String, Vec<u8>>,
-}
-impl Trusted {
-    pub fn new() -> Self {
-        Trusted {
-            files: IndexMap::new(),
-        }
-    }
-}
-pub fn file_is_trusted(nu_env_file: &PathBuf, content: &[u8]) -> Result<bool, ShellError> {
-    let contentdigest = Sha256::digest(&content).as_slice().to_vec();
-    let nufile = std::fs::canonicalize(nu_env_file)?;
-
-    let trusted = read_trusted()?;
-    Ok(trusted.files.get(&nufile.to_string_lossy().to_string()) == Some(&contentdigest))
-}
-
-pub fn read_trusted() -> Result<Trusted, ShellError> {
-    let config_path = config::default_path_for(&Some(PathBuf::from("nu-env.toml")))?;
-
-    let mut file = std::fs::OpenOptions::new()
-        .read(true)
-        .create(true)
-        .write(true)
-        .open(config_path)
-        .map_err(|_| ShellError::untagged_runtime_error("Couldn't open nu-env.toml"))?;
-    let mut doc = String::new();
-    file.read_to_string(&mut doc)?;
-
-    let allowed = toml::de::from_str(doc.as_str()).unwrap_or_else(|_| Trusted::new());
-    Ok(allowed)
-}
-
-#[async_trait]
-impl WholeStreamCommand for Autoenv {
-    fn name(&self) -> &str {
-        "autoenv"
-    }
-    fn usage(&self) -> &str {
-        // "Mark a .nu-env file in a directory as trusted. Needs to be re-run after each change to the file or its filepath."
-        r#"Manage directory specific environment variables and scripts. Create a file called .nu-env in any directory and run 'autoenv trust' to let nushell read it when entering the directory.
-The file can contain several optional sections:
-    env: environment variables to set when visiting the directory. The variables are unset after leaving the directory and any overwritten values are restored.
-    scriptvars: environment variables that should be set to the return value of a script. After they have been set, they behave in the same way as variables set in the env section.
-    scripts: scripts to run when entering the directory or leaving it."#
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("autoenv")
-    }
-    async fn run(
-        &self,
-        _args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = registry.clone();
-        Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(crate::commands::help::get_help(&Autoenv, &registry))
-                .into_value(Tag::unknown()),
-        )))
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Example .nu-env file",
-            example: r#"cat .nu-env
-    [env]
-    mykey = "myvalue"
-
-    [scriptvars]
-    myscript = "echo myval"
-
-    [scripts]
-    entryscripts = ["touch hello.txt", "touch hello2.txt"]
-    exitscripts = ["touch bye.txt"]"#,
-            result: None,
-        }]
-    }
-}

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

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

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

@@ -1,141 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
-
-pub struct Char;
-
-#[derive(Deserialize)]
-struct CharArgs {
-    name: Tagged<String>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Char {
-    fn name(&self) -> &str {
-        "char"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("ansi").required(
-            "character",
-            SyntaxShape::Any,
-            "the name of the character to output",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Output special characters (eg. 'newline')"
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Output newline",
-                example: r#"char newline"#,
-                result: Some(vec![Value::from("\n")]),
-            },
-            Example {
-                description: "Output prompt character, newline and a hamburger character",
-                example: r#"echo $(char prompt) $(char newline) $(char hamburger)"#,
-                result: Some(vec![
-                    UntaggedValue::string("\u{25b6}").into(),
-                    UntaggedValue::string("\n").into(),
-                    UntaggedValue::string("\u{2261}").into(),
-                ]),
-            },
-        ]
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let (CharArgs { name }, _) = args.process(&registry).await?;
-
-        let special_character = str_to_character(&name.item);
-
-        if let Some(output) = special_character {
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::string(output).into_value(name.tag()),
-            )))
-        } else {
-            Err(ShellError::labeled_error(
-                "Unknown character",
-                "unknown character",
-                name.tag(),
-            ))
-        }
-    }
-}
-
-fn str_to_character(s: &str) -> Option<String> {
-    match s {
-        "newline" | "enter" | "nl" => Some("\n".into()),
-        "tab" => Some("\t".into()),
-        "sp" | "space" => Some(" ".into()),
-        // Unicode names came from https://www.compart.com/en/unicode
-        // Private Use Area (U+E000-U+F8FF)
-        "branch" => Some('\u{e0a0}'.to_string()),  // 
-        "segment" => Some('\u{e0b0}'.to_string()), // 
-
-        "identical_to" | "hamburger" => Some('\u{2261}'.to_string()), // ≡
-        "not_identical_to" | "branch_untracked" => Some('\u{2262}'.to_string()), // ≢
-        "strictly_equivalent_to" | "branch_identical" => Some('\u{2263}'.to_string()), // ≣
-
-        "upwards_arrow" | "branch_ahead" => Some('\u{2191}'.to_string()), // ↑
-        "downwards_arrow" | "branch_behind" => Some('\u{2193}'.to_string()), // ↓
-        "up_down_arrow" | "branch_ahead_behind" => Some('\u{2195}'.to_string()), // ↕
-
-        "black_right_pointing_triangle" | "prompt" => Some('\u{25b6}'.to_string()), // ▶
-        "vector_or_cross_product" | "failed" => Some('\u{2a2f}'.to_string()),       // ⨯
-        "high_voltage_sign" | "elevated" => Some('\u{26a1}'.to_string()),           // ⚡
-        "tilde" | "twiddle" | "squiggly" | "home" => Some("~".into()),              // ~
-        "hash" | "hashtag" | "pound_sign" | "sharp" | "root" => Some("#".into()),   // #
-
-        // Weather symbols
-        "sun" => Some("\x1b[33;1m\u{2600}\x1b[0m".to_string()), // Yellow Bold ☀
-        "moon" => Some("\x1b[36m\u{263d}\x1b[0m".to_string()),  // Cyan ☽
-        "clouds" => Some("\x1b[37;1m\u{2601}\x1b[0m".to_string()), // White Bold ☁
-        "rain" => Some("\x1b[37;1m\u{2614}\x1b[0m".to_string()), // White Bold ☔
-        "fog" => Some("\x1b[37;1m\u{2592}\x1b[0m".to_string()), // White Bold ▒
-        "mist" => Some("\x1b[34m\u{2591}\x1b[0m".to_string()),  // Blue ░
-        "haze" => Some("\x1b[33m\u{2591}\x1b[0m".to_string()),  // Yellow ░
-        "snow" => Some("\x1b[37;1m\u{2744}\x1b[0m".to_string()), // White Bold ❄
-        "thunderstorm" => Some("\x1b[33;1m\u{26a1}\x1b[0m".to_string()), // Yellow Bold ⚡
-
-        // Reference for ansi codes https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
-        // Another good reference http://ascii-table.com/ansi-escape-sequences.php
-
-        // For setting title like `echo [$(char title) $(pwd) $(char bel)] | str collect`
-        "title" => Some("\x1b]2;".to_string()), // ESC]2; xterm sets window title
-        "bel" => Some('\x07'.to_string()),      // Terminal Bell
-        "backspace" => Some('\x08'.to_string()), // Backspace
-
-        // Ansi Erase Sequences
-        "clear_screen" => Some("\x1b[J".to_string()), // clears the screen
-        "clear_screen_from_cursor_to_end" => Some("\x1b[0J".to_string()), // clears from cursor until end of screen
-        "clear_screen_from_cursor_to_beginning" => Some("\x1b[1J".to_string()), // clears from cursor to beginning of screen
-        "cls" | "clear_entire_screen" => Some("\x1b[2J".to_string()), // clears the entire screen
-        "erase_line" => Some("\x1b[K".to_string()),                   // clears the current line
-        "erase_line_from_cursor_to_end" => Some("\x1b[0K".to_string()), // clears from cursor to end of line
-        "erase_line_from_cursor_to_beginning" => Some("\x1b[1K".to_string()), // clears from cursor to start of line
-        "erase_entire_line" => Some("\x1b[2K".to_string()),                   // clears entire line
-        _ => None,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Char;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Char {})?)
-    }
-}

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

@@ -1,88 +0,0 @@
-use crate::commands::classified::expr::run_expression_block;
-use crate::commands::classified::internal::run_internal_command;
-use crate::evaluation_context::EvaluationContext;
-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, Scope, UntaggedValue, Value};
-use std::sync::atomic::Ordering;
-
-pub(crate) async fn run_block(
-    block: &Block,
-    ctx: &mut EvaluationContext,
-    mut input: InputStream,
-    scope: Arc<Scope>,
-) -> 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, scope.clone()).await;
-
-        input = InputStream::empty();
-    }
-
-    output
-}
-
-async fn run_pipeline(
-    commands: &Commands,
-    ctx: &mut EvaluationContext,
-    mut input: InputStream,
-    scope: Arc<Scope>,
-) -> Result<InputStream, ShellError> {
-    for item in commands.list.clone() {
-        input = match item {
-            ClassifiedCommand::Dynamic(_) => {
-                return Err(ShellError::unimplemented("Dynamic commands"))
-            }
-
-            ClassifiedCommand::Expr(expr) => {
-                run_expression_block(*expr, ctx, scope.clone()).await?
-            }
-
-            ClassifiedCommand::Error(err) => return Err(err.into()),
-
-            ClassifiedCommand::Internal(left) => {
-                run_internal_command(left, ctx, input, scope.clone()).await?
-            }
-        };
-    }
-
-    Ok(input)
-}

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

@@ -1,25 +0,0 @@
-use crate::evaluate::evaluate_baseline_expr;
-use crate::prelude::*;
-
-use log::{log_enabled, trace};
-
-use futures::stream::once;
-use nu_errors::ShellError;
-use nu_protocol::hir::SpannedExpression;
-use nu_protocol::Scope;
-
-pub(crate) async fn run_expression_block(
-    expr: SpannedExpression,
-    context: &mut EvaluationContext,
-    scope: Arc<Scope>,
-) -> Result<InputStream, ShellError> {
-    if log_enabled!(log::Level::Trace) {
-        trace!(target: "nu::run::expr", "->");
-        trace!(target: "nu::run::expr", "{:?}", expr);
-    }
-
-    let registry = context.registry().clone();
-    let output = evaluate_baseline_expr(&expr, &registry, scope).await?;
-
-    Ok(once(async { Ok(output) }).to_input_stream())
-}

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

@@ -1,696 +0,0 @@
-use crate::commands::classified::maybe_text_codec::{MaybeTextCodec, StringOrBinary};
-use crate::evaluate::evaluate_baseline_expr;
-use crate::futures::ThreadedReceiver;
-use crate::prelude::*;
-
-use std::io::Write;
-use std::ops::Deref;
-use std::process::{Command, Stdio};
-use std::sync::mpsc;
-
-use futures::executor::block_on_stream;
-use futures_codec::FramedRead;
-use log::trace;
-
-use nu_errors::ShellError;
-use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
-use nu_protocol::{Primitive, Scope, ShellTypeName, UntaggedValue, Value};
-use nu_source::Tag;
-
-pub(crate) async fn run_external_command(
-    command: ExternalCommand,
-    context: &mut EvaluationContext,
-    input: InputStream,
-    scope: Arc<Scope>,
-    external_redirection: ExternalRedirection,
-) -> Result<InputStream, ShellError> {
-    trace!(target: "nu::run::external", "-> {}", command.name);
-
-    if !did_find_command(&command.name) {
-        return Err(ShellError::labeled_error(
-            "Command not found",
-            "command not found",
-            &command.name_tag,
-        ));
-    }
-
-    run_with_stdin(command, context, input, scope, external_redirection).await
-}
-
-async fn run_with_stdin(
-    command: ExternalCommand,
-    context: &mut EvaluationContext,
-    input: InputStream,
-    scope: Arc<Scope>,
-    external_redirection: ExternalRedirection,
-) -> Result<InputStream, ShellError> {
-    let path = context.shell_manager.path();
-
-    let input = trace_stream!(target: "nu::trace_stream::external::stdin", "input" = input);
-
-    let mut command_args = vec![];
-    for arg in command.args.iter() {
-        let value = evaluate_baseline_expr(arg, &context.registry, scope.clone()).await?;
-
-        // Skip any arguments that don't really exist, treating them as optional
-        // FIXME: we may want to preserve the gap in the future, though it's hard to say
-        // what value we would put in its place.
-        if value.value.is_none() {
-            continue;
-        }
-
-        // Do the cleanup that we need to do on any argument going out:
-        match &value.value {
-            UntaggedValue::Table(table) => {
-                for t in table {
-                    match &t.value {
-                        UntaggedValue::Primitive(_) => {
-                            command_args
-                                .push(t.convert_to_string().trim_end_matches('\n').to_string());
-                        }
-                        _ => {
-                            return Err(ShellError::labeled_error(
-                                "Could not convert to positional arguments",
-                                "could not convert to positional arguments",
-                                value.tag(),
-                            ));
-                        }
-                    }
-                }
-            }
-            _ => {
-                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
-                command_args.push(trimmed_value_string);
-            }
-        }
-    }
-
-    let process_args = command_args
-        .iter()
-        .map(|arg| {
-            let home_dir;
-
-            #[cfg(feature = "dirs")]
-            {
-                home_dir = dirs::home_dir;
-            }
-            #[cfg(not(feature = "dirs"))]
-            {
-                home_dir = || Some(std::path::PathBuf::from("/"));
-            }
-
-            let arg = expand_tilde(arg.deref(), home_dir);
-
-            #[cfg(not(windows))]
-            {
-                if argument_contains_whitespace(&arg) && !argument_is_quoted(&arg) {
-                    add_quotes(&arg)
-                } else {
-                    arg.as_ref().to_string()
-                }
-            }
-            #[cfg(windows)]
-            {
-                if let Some(unquoted) = remove_quotes(&arg) {
-                    unquoted.to_string()
-                } else {
-                    arg.as_ref().to_string()
-                }
-            }
-        })
-        .collect::<Vec<String>>();
-
-    spawn(
-        &command,
-        &path,
-        &process_args[..],
-        input,
-        external_redirection,
-        scope,
-    )
-}
-
-fn spawn(
-    command: &ExternalCommand,
-    path: &str,
-    args: &[String],
-    input: InputStream,
-    external_redirection: ExternalRedirection,
-    scope: Arc<Scope>,
-) -> Result<InputStream, ShellError> {
-    let command = command.clone();
-
-    let mut process = {
-        #[cfg(windows)]
-        {
-            let mut process = Command::new("cmd");
-            process.arg("/c");
-            process.arg(&command.name);
-            for arg in args {
-                // Clean the args before we use them:
-                let arg = arg.replace("|", "\\|");
-                process.arg(&arg);
-            }
-            process
-        }
-
-        #[cfg(not(windows))]
-        {
-            let cmd_with_args = vec![command.name.clone(), args.join(" ")].join(" ");
-            let mut process = Command::new("sh");
-            process.arg("-c").arg(cmd_with_args);
-            process
-        }
-    };
-
-    process.current_dir(path);
-    trace!(target: "nu::run::external", "cwd = {:?}", &path);
-
-    process.env_clear();
-    process.envs(scope.env());
-
-    // We want stdout regardless of what
-    // we are doing ($it case or pipe stdin)
-    match external_redirection {
-        ExternalRedirection::Stdout => {
-            process.stdout(Stdio::piped());
-            trace!(target: "nu::run::external", "set up stdout pipe");
-        }
-        ExternalRedirection::Stderr => {
-            process.stderr(Stdio::piped());
-            trace!(target: "nu::run::external", "set up stderr pipe");
-        }
-        ExternalRedirection::StdoutAndStderr => {
-            process.stdout(Stdio::piped());
-            trace!(target: "nu::run::external", "set up stdout pipe");
-            process.stderr(Stdio::piped());
-            trace!(target: "nu::run::external", "set up stderr pipe");
-        }
-        _ => {}
-    }
-
-    // open since we have some contents for stdin
-    if !input.is_empty() {
-        process.stdin(Stdio::piped());
-        trace!(target: "nu::run::external", "set up stdin pipe");
-    }
-
-    trace!(target: "nu::run::external", "built command {:?}", process);
-
-    // TODO Switch to async_std::process once it's stabilized
-    if let Ok(mut child) = process.spawn() {
-        let (tx, rx) = mpsc::sync_channel(0);
-
-        let mut stdin = child.stdin.take();
-
-        let stdin_write_tx = tx.clone();
-        let stdout_read_tx = tx;
-        let stdin_name_tag = command.name_tag.clone();
-        let stdout_name_tag = command.name_tag;
-
-        std::thread::spawn(move || {
-            if !input.is_empty() {
-                let mut stdin_write = stdin
-                    .take()
-                    .expect("Internal error: could not get stdin pipe for external command");
-
-                for value in block_on_stream(input) {
-                    match &value.value {
-                        UntaggedValue::Primitive(Primitive::Nothing) => continue,
-                        UntaggedValue::Primitive(Primitive::String(s))
-                        | UntaggedValue::Primitive(Primitive::Line(s)) => {
-                            if let Err(e) = stdin_write.write(s.as_bytes()) {
-                                let message = format!("Unable to write to stdin (error = {})", e);
-
-                                let _ = stdin_write_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        message,
-                                        "application may have closed before completing pipeline",
-                                        &stdin_name_tag,
-                                    )),
-                                    tag: stdin_name_tag,
-                                }));
-                                return Err(());
-                            }
-                        }
-                        UntaggedValue::Primitive(Primitive::Binary(b)) => {
-                            if let Err(e) = stdin_write.write(b) {
-                                let message = format!("Unable to write to stdin (error = {})", e);
-
-                                let _ = stdin_write_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        message,
-                                        "application may have closed before completing pipeline",
-                                        &stdin_name_tag,
-                                    )),
-                                    tag: stdin_name_tag,
-                                }));
-                                return Err(());
-                            }
-                        }
-                        unsupported => {
-                            let _ = stdin_write_tx.send(Ok(Value {
-                                value: UntaggedValue::Error(ShellError::labeled_error(
-                                    format!(
-                                        "Received unexpected type from pipeline ({})",
-                                        unsupported.type_name()
-                                    ),
-                                    "expected a string",
-                                    stdin_name_tag.clone(),
-                                )),
-                                tag: stdin_name_tag,
-                            }));
-                            return Err(());
-                        }
-                    };
-                }
-            }
-
-            Ok(())
-        });
-
-        std::thread::spawn(move || {
-            if external_redirection == ExternalRedirection::Stdout
-                || external_redirection == ExternalRedirection::StdoutAndStderr
-            {
-                let stdout = if let Some(stdout) = child.stdout.take() {
-                    stdout
-                } else {
-                    let _ = stdout_read_tx.send(Ok(Value {
-                        value: UntaggedValue::Error(ShellError::labeled_error(
-                            "Can't redirect the stdout for external command",
-                            "can't redirect stdout",
-                            &stdout_name_tag,
-                        )),
-                        tag: stdout_name_tag,
-                    }));
-                    return Err(());
-                };
-
-                let file = futures::io::AllowStdIo::new(stdout);
-                let stream = FramedRead::new(file, MaybeTextCodec::default());
-
-                for line in block_on_stream(stream) {
-                    match line {
-                        Ok(line) => match line {
-                            StringOrBinary::String(s) => {
-                                let result = stdout_read_tx.send(Ok(Value {
-                                    value: UntaggedValue::Primitive(Primitive::String(s.clone())),
-                                    tag: stdout_name_tag.clone(),
-                                }));
-
-                                if result.is_err() {
-                                    break;
-                                }
-                            }
-                            StringOrBinary::Binary(b) => {
-                                let result = stdout_read_tx.send(Ok(Value {
-                                    value: UntaggedValue::Primitive(Primitive::Binary(
-                                        b.into_iter().collect(),
-                                    )),
-                                    tag: stdout_name_tag.clone(),
-                                }));
-
-                                if result.is_err() {
-                                    break;
-                                }
-                            }
-                        },
-                        Err(e) => {
-                            // If there's an exit status, it makes sense that we may error when
-                            // trying to read from its stdout pipe (likely been closed). In that
-                            // case, don't emit an error.
-                            let should_error = match child.wait() {
-                                Ok(exit_status) => !exit_status.success(),
-                                Err(_) => true,
-                            };
-
-                            if should_error {
-                                let _ = stdout_read_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        format!("Unable to read from stdout ({})", e),
-                                        "unable to read from stdout",
-                                        &stdout_name_tag,
-                                    )),
-                                    tag: stdout_name_tag.clone(),
-                                }));
-                            }
-
-                            return Ok(());
-                        }
-                    }
-                }
-            }
-            if external_redirection == ExternalRedirection::Stderr
-                || external_redirection == ExternalRedirection::StdoutAndStderr
-            {
-                let stderr = if let Some(stderr) = child.stderr.take() {
-                    stderr
-                } else {
-                    let _ = stdout_read_tx.send(Ok(Value {
-                        value: UntaggedValue::Error(ShellError::labeled_error(
-                            "Can't redirect the stderr for external command",
-                            "can't redirect stderr",
-                            &stdout_name_tag,
-                        )),
-                        tag: stdout_name_tag,
-                    }));
-                    return Err(());
-                };
-
-                let file = futures::io::AllowStdIo::new(stderr);
-                let stream = FramedRead::new(file, MaybeTextCodec::default());
-
-                for line in block_on_stream(stream) {
-                    match line {
-                        Ok(line) => match line {
-                            StringOrBinary::String(s) => {
-                                let result = stdout_read_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(
-                                        ShellError::untagged_runtime_error(s),
-                                    ),
-                                    tag: stdout_name_tag.clone(),
-                                }));
-
-                                if result.is_err() {
-                                    break;
-                                }
-                            }
-                            StringOrBinary::Binary(_) => {
-                                let result = stdout_read_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(
-                                        ShellError::untagged_runtime_error("<binary stderr>"),
-                                    ),
-                                    tag: stdout_name_tag.clone(),
-                                }));
-
-                                if result.is_err() {
-                                    break;
-                                }
-                            }
-                        },
-                        Err(e) => {
-                            // If there's an exit status, it makes sense that we may error when
-                            // trying to read from its stdout pipe (likely been closed). In that
-                            // case, don't emit an error.
-                            let should_error = match child.wait() {
-                                Ok(exit_status) => !exit_status.success(),
-                                Err(_) => true,
-                            };
-
-                            if should_error {
-                                let _ = stdout_read_tx.send(Ok(Value {
-                                    value: UntaggedValue::Error(ShellError::labeled_error(
-                                        format!("Unable to read from stdout ({})", e),
-                                        "unable to read from stdout",
-                                        &stdout_name_tag,
-                                    )),
-                                    tag: stdout_name_tag.clone(),
-                                }));
-                            }
-
-                            return Ok(());
-                        }
-                    }
-                }
-            }
-
-            // We can give an error when we see a non-zero exit code, but this is different
-            // than what other shells will do.
-            let external_failed = match child.wait() {
-                Err(_) => true,
-                Ok(exit_status) => !exit_status.success(),
-            };
-
-            if external_failed {
-                let cfg = nu_data::config::config(Tag::unknown());
-                if let Ok(cfg) = cfg {
-                    if cfg.contains_key("nonzero_exit_errors") {
-                        let _ = stdout_read_tx.send(Ok(Value {
-                            value: UntaggedValue::Error(ShellError::labeled_error(
-                                "External command failed",
-                                "command failed",
-                                &stdout_name_tag,
-                            )),
-                            tag: stdout_name_tag.clone(),
-                        }));
-                    }
-                }
-                let _ = stdout_read_tx.send(Ok(Value {
-                    value: UntaggedValue::Error(ShellError::external_non_zero()),
-                    tag: stdout_name_tag,
-                }));
-            }
-
-            Ok(())
-        });
-
-        let stream = ThreadedReceiver::new(rx);
-        Ok(stream.to_input_stream())
-    } else {
-        Err(ShellError::labeled_error(
-            "Failed to spawn process",
-            "failed to spawn",
-            &command.name_tag,
-        ))
-    }
-}
-
-pub fn did_find_command(#[allow(unused)] name: &str) -> bool {
-    #[cfg(not(feature = "which"))]
-    {
-        // we can't perform this check, so just assume it can be found
-        true
-    }
-
-    #[cfg(all(feature = "which", unix))]
-    {
-        which::which(name).is_ok()
-    }
-
-    #[cfg(all(feature = "which", windows))]
-    {
-        if which::which(name).is_ok() {
-            true
-        } else {
-            // Reference: https://ss64.com/nt/syntax-internal.html
-            let cmd_builtins = [
-                "assoc", "break", "color", "copy", "date", "del", "dir", "dpath", "echo", "erase",
-                "for", "ftype", "md", "mkdir", "mklink", "move", "path", "ren", "rename", "rd",
-                "rmdir", "set", "start", "time", "title", "type", "ver", "verify", "vol",
-            ];
-
-            cmd_builtins.contains(&name)
-        }
-    }
-}
-
-fn expand_tilde<SI: ?Sized, P, HD>(input: &SI, home_dir: HD) -> std::borrow::Cow<str>
-where
-    SI: AsRef<str>,
-    P: AsRef<std::path::Path>,
-    HD: FnOnce() -> Option<P>,
-{
-    shellexpand::tilde_with_context(input, home_dir)
-}
-
-#[allow(unused)]
-pub fn argument_contains_whitespace(argument: &str) -> bool {
-    argument.chars().any(|c| c.is_whitespace())
-}
-
-fn argument_is_quoted(argument: &str) -> bool {
-    if argument.len() < 2 {
-        return false;
-    }
-
-    (argument.starts_with('"') && argument.ends_with('"'))
-        || (argument.starts_with('\'') && argument.ends_with('\''))
-}
-
-#[allow(unused)]
-fn add_quotes(argument: &str) -> String {
-    format!("\"{}\"", argument)
-}
-
-#[allow(unused)]
-fn remove_quotes(argument: &str) -> Option<&str> {
-    if !argument_is_quoted(argument) {
-        return None;
-    }
-
-    let size = argument.len();
-
-    Some(&argument[1..size - 1])
-}
-
-#[allow(unused)]
-fn shell_os_paths() -> Vec<std::path::PathBuf> {
-    let mut original_paths = vec![];
-
-    if let Some(paths) = std::env::var_os("PATH") {
-        original_paths = std::env::split_paths(&paths).collect::<Vec<_>>();
-    }
-
-    original_paths
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        add_quotes, argument_contains_whitespace, argument_is_quoted, expand_tilde, remove_quotes,
-    };
-    #[cfg(feature = "which")]
-    use super::{run_external_command, EvaluationContext, InputStream};
-
-    #[cfg(feature = "which")]
-    use futures::executor::block_on;
-    #[cfg(feature = "which")]
-    use nu_errors::ShellError;
-    #[cfg(feature = "which")]
-    use nu_protocol::Scope;
-    #[cfg(feature = "which")]
-    use nu_test_support::commands::ExternalBuilder;
-
-    // async fn read(mut stream: OutputStream) -> Option<Value> {
-    //     match stream.try_next().await {
-    //         Ok(val) => {
-    //             if let Some(val) = val {
-    //                 val.raw_value()
-    //             } else {
-    //                 None
-    //             }
-    //         }
-    //         Err(_) => None,
-    //     }
-    // }
-
-    #[cfg(feature = "which")]
-    async fn non_existent_run() -> Result<(), ShellError> {
-        use nu_protocol::hir::ExternalRedirection;
-        let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
-
-        let input = InputStream::empty();
-        let mut ctx =
-            EvaluationContext::basic().expect("There was a problem creating a basic context.");
-
-        assert!(run_external_command(
-            cmd,
-            &mut ctx,
-            input,
-            Scope::create(),
-            ExternalRedirection::Stdout
-        )
-        .await
-        .is_err());
-
-        Ok(())
-    }
-
-    // async fn failure_run() -> Result<(), ShellError> {
-    //     let cmd = ExternalBuilder::for_name("fail").build();
-
-    //     let mut ctx = EvaluationContext::basic().expect("There was a problem creating a basic context.");
-    //     let stream = run_external_command(cmd, &mut ctx, None, false)
-    //         .await?
-    //         .expect("There was a problem running the external command.");
-
-    //     match read(stream.into()).await {
-    //         Some(Value {
-    //             value: UntaggedValue::Error(_),
-    //             ..
-    //         }) => {}
-    //         None | _ => panic!("Command didn't fail."),
-    //     }
-
-    //     Ok(())
-    // }
-
-    // #[test]
-    // fn identifies_command_failed() -> Result<(), ShellError> {
-    //     block_on(failure_run())
-    // }
-
-    #[cfg(feature = "which")]
-    #[test]
-    fn identifies_command_not_found() -> Result<(), ShellError> {
-        block_on(non_existent_run())
-    }
-
-    #[test]
-    fn checks_contains_whitespace_from_argument_to_be_passed_in() {
-        assert_eq!(argument_contains_whitespace("andrés"), false);
-        assert_eq!(argument_contains_whitespace("and rés"), true);
-        assert_eq!(argument_contains_whitespace(r#"and\ rés"#), true);
-    }
-
-    #[test]
-    fn checks_quotes_from_argument_to_be_passed_in() {
-        assert_eq!(argument_is_quoted(""), false);
-
-        assert_eq!(argument_is_quoted("'"), false);
-        assert_eq!(argument_is_quoted("'a"), false);
-        assert_eq!(argument_is_quoted("a"), false);
-        assert_eq!(argument_is_quoted("a'"), false);
-        assert_eq!(argument_is_quoted("''"), true);
-
-        assert_eq!(argument_is_quoted(r#"""#), false);
-        assert_eq!(argument_is_quoted(r#""a"#), false);
-        assert_eq!(argument_is_quoted(r#"a"#), false);
-        assert_eq!(argument_is_quoted(r#"a""#), false);
-        assert_eq!(argument_is_quoted(r#""""#), true);
-
-        assert_eq!(argument_is_quoted("'andrés"), false);
-        assert_eq!(argument_is_quoted("andrés'"), false);
-        assert_eq!(argument_is_quoted(r#""andrés"#), false);
-        assert_eq!(argument_is_quoted(r#"andrés""#), false);
-        assert_eq!(argument_is_quoted("'andrés'"), true);
-        assert_eq!(argument_is_quoted(r#""andrés""#), true);
-    }
-
-    #[test]
-    fn adds_quotes_to_argument_to_be_passed_in() {
-        assert_eq!(add_quotes("andrés"), "\"andrés\"");
-        //assert_eq!(add_quotes("\"andrés\""), "\"andrés\"");
-    }
-
-    #[test]
-    fn strips_quotes_from_argument_to_be_passed_in() {
-        assert_eq!(remove_quotes(""), None);
-
-        assert_eq!(remove_quotes("'"), None);
-        assert_eq!(remove_quotes("'a"), None);
-        assert_eq!(remove_quotes("a"), None);
-        assert_eq!(remove_quotes("a'"), None);
-        assert_eq!(remove_quotes("''"), Some(""));
-
-        assert_eq!(remove_quotes(r#"""#), None);
-        assert_eq!(remove_quotes(r#""a"#), None);
-        assert_eq!(remove_quotes(r#"a"#), None);
-        assert_eq!(remove_quotes(r#"a""#), None);
-        assert_eq!(remove_quotes(r#""""#), Some(""));
-
-        assert_eq!(remove_quotes("'andrés"), None);
-        assert_eq!(remove_quotes("andrés'"), None);
-        assert_eq!(remove_quotes(r#""andrés"#), None);
-        assert_eq!(remove_quotes(r#"andrés""#), None);
-        assert_eq!(remove_quotes("'andrés'"), Some("andrés"));
-        assert_eq!(remove_quotes(r#""andrés""#), Some("andrés"));
-    }
-
-    #[test]
-    fn expands_tilde_if_starts_with_tilde_character() {
-        assert_eq!(
-            expand_tilde("~", || Some(std::path::Path::new("the_path_to_nu_light"))),
-            "the_path_to_nu_light"
-        );
-    }
-
-    #[test]
-    fn does_not_expand_tilde_if_tilde_is_not_first_character() {
-        assert_eq!(
-            expand_tilde("1~1", || Some(std::path::Path::new("the_path_to_nu_light"))),
-            "1~1"
-        );
-    }
-}

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

@@ -1,267 +0,0 @@
-use crate::commands::command::whole_stream_command;
-use crate::commands::run_alias::AliasCommand;
-use crate::commands::UnevaluatedCallInfo;
-use crate::prelude::*;
-use log::{log_enabled, trace};
-use nu_errors::ShellError;
-use nu_protocol::hir::{ExternalRedirection, InternalCommand};
-use nu_protocol::{CommandAction, Primitive, ReturnSuccess, Scope, UntaggedValue, Value};
-
-pub(crate) async fn run_internal_command(
-    command: InternalCommand,
-    context: &mut EvaluationContext,
-    input: InputStream,
-    scope: Arc<Scope>,
-) -> Result<InputStream, ShellError> {
-    if log_enabled!(log::Level::Trace) {
-        trace!(target: "nu::run::internal", "->");
-        trace!(target: "nu::run::internal", "{}", command.name);
-    }
-
-    let objects: InputStream = trace_stream!(target: "nu::trace_stream::internal", "input" = input);
-    let internal_command = context.expect_command(&command.name);
-
-    if command.name == "autoenv untrust" {
-        context.user_recently_used_autoenv_untrust = true;
-    }
-
-    let result = {
-        context
-            .run_command(
-                internal_command?,
-                Tag::unknown_anchor(command.name_span),
-                command.args.clone(),
-                scope.clone(),
-                objects,
-            )
-            .await?
-    };
-
-    let head = Arc::new(command.args.head.clone());
-    //let context = Arc::new(context.clone());
-    let context = context.clone();
-    let command = Arc::new(command);
-
-    Ok(InputStream::from_stream(
-        result
-            .then(move |item| {
-                let head = head.clone();
-                let command = command.clone();
-                let mut context = context.clone();
-                let scope = scope.clone();
-                async move {
-                    match item {
-                        Ok(ReturnSuccess::Action(action)) => match action {
-                            CommandAction::ChangePath(path) => {
-                                context.shell_manager.set_path(path);
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                            CommandAction::Exit => std::process::exit(0), // TODO: save history.txt
-                            CommandAction::Error(err) => {
-                                context.error(err.clone());
-                                InputStream::one(UntaggedValue::Error(err).into_untagged_value())
-                            }
-                            CommandAction::AutoConvert(tagged_contents, extension) => {
-                                let contents_tag = tagged_contents.tag.clone();
-                                let command_name = format!("from {}", extension);
-                                let command = command.clone();
-                                if let Some(converter) = context.registry.get_command(&command_name)
-                                {
-                                    let new_args = RawCommandArgs {
-                                        host: context.host.clone(),
-                                        ctrl_c: context.ctrl_c.clone(),
-                                        current_errors: context.current_errors.clone(),
-                                        shell_manager: context.shell_manager.clone(),
-                                        call_info: UnevaluatedCallInfo {
-                                            args: nu_protocol::hir::Call {
-                                                head: (&*head).clone(),
-                                                positional: None,
-                                                named: None,
-                                                span: Span::unknown(),
-                                                external_redirection: ExternalRedirection::Stdout,
-                                            },
-                                            name_tag: Tag::unknown_anchor(command.name_span),
-                                            scope,
-                                        },
-                                    };
-                                    let result = converter
-                                        .run(
-                                            new_args.with_input(vec![tagged_contents]),
-                                            &context.registry,
-                                        )
-                                        .await;
-
-                                    match result {
-                                        Ok(mut result) => {
-                                            let result_vec: Vec<Result<ReturnSuccess, ShellError>> =
-                                                result.drain_vec().await;
-
-                                            let mut output = vec![];
-                                            for res in result_vec {
-                                                match res {
-                                                    Ok(ReturnSuccess::Value(Value {
-                                                        value: UntaggedValue::Table(list),
-                                                        ..
-                                                    })) => {
-                                                        for l in list {
-                                                            output.push(Ok(l));
-                                                        }
-                                                    }
-                                                    Ok(ReturnSuccess::Value(Value {
-                                                        value,
-                                                        ..
-                                                    })) => {
-                                                        output
-                                                            .push(Ok(value
-                                                                .into_value(contents_tag.clone())));
-                                                    }
-                                                    Err(e) => output.push(Err(e)),
-                                                    _ => {}
-                                                }
-                                            }
-
-                                            futures::stream::iter(output).to_input_stream()
-                                        }
-                                        Err(e) => {
-                                            context.add_error(e);
-                                            InputStream::empty()
-                                        }
-                                    }
-                                } else {
-                                    InputStream::one(tagged_contents)
-                                }
-                            }
-                            CommandAction::EnterHelpShell(value) => match value {
-                                Value {
-                                    value: UntaggedValue::Primitive(Primitive::String(cmd)),
-                                    tag,
-                                } => {
-                                    context.shell_manager.insert_at_current(Box::new(
-                                        match HelpShell::for_command(
-                                            UntaggedValue::string(cmd).into_value(tag),
-                                            &context.registry(),
-                                        ) {
-                                            Ok(v) => v,
-                                            Err(err) => {
-                                                return InputStream::one(
-                                                    UntaggedValue::Error(err).into_untagged_value(),
-                                                )
-                                            }
-                                        },
-                                    ));
-                                    InputStream::from_stream(futures::stream::iter(vec![]))
-                                }
-                                _ => {
-                                    context.shell_manager.insert_at_current(Box::new(
-                                        match HelpShell::index(&context.registry()) {
-                                            Ok(v) => v,
-                                            Err(err) => {
-                                                return InputStream::one(
-                                                    UntaggedValue::Error(err).into_untagged_value(),
-                                                )
-                                            }
-                                        },
-                                    ));
-                                    InputStream::from_stream(futures::stream::iter(vec![]))
-                                }
-                            },
-                            CommandAction::EnterValueShell(value) => {
-                                context
-                                    .shell_manager
-                                    .insert_at_current(Box::new(ValueShell::new(value)));
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                            CommandAction::EnterShell(location) => {
-                                context.shell_manager.insert_at_current(Box::new(
-                                    match FilesystemShell::with_location(location) {
-                                        Ok(v) => v,
-                                        Err(err) => {
-                                            return InputStream::one(
-                                                UntaggedValue::Error(err.into())
-                                                    .into_untagged_value(),
-                                            )
-                                        }
-                                    },
-                                ));
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                            CommandAction::AddAlias(name, args, block) => {
-                                context.add_commands(vec![whole_stream_command(
-                                    AliasCommand::new(name, args, block),
-                                )]);
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                            CommandAction::AddPlugins(path) => {
-                                match crate::plugin::scan(vec![std::path::PathBuf::from(path)]) {
-                                    Ok(plugins) => {
-                                        context.add_commands(
-                                            plugins
-                                                .into_iter()
-                                                .filter(|p| {
-                                                    !context.is_command_registered(p.name())
-                                                })
-                                                .collect(),
-                                        );
-
-                                        InputStream::from_stream(futures::stream::iter(vec![]))
-                                    }
-                                    Err(reason) => {
-                                        context.error(reason.clone());
-                                        InputStream::one(
-                                            UntaggedValue::Error(reason).into_untagged_value(),
-                                        )
-                                    }
-                                }
-                            }
-                            CommandAction::PreviousShell => {
-                                context.shell_manager.prev();
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                            CommandAction::NextShell => {
-                                context.shell_manager.next();
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                            CommandAction::LeaveShell => {
-                                context.shell_manager.remove_at_current();
-                                if context.shell_manager.is_empty() {
-                                    std::process::exit(0); // TODO: save history.txt
-                                }
-                                InputStream::from_stream(futures::stream::iter(vec![]))
-                            }
-                        },
-
-                        Ok(ReturnSuccess::Value(Value {
-                            value: UntaggedValue::Error(err),
-                            tag,
-                        })) => {
-                            context.error(err.clone());
-                            InputStream::one(UntaggedValue::Error(err).into_value(tag))
-                        }
-
-                        Ok(ReturnSuccess::Value(v)) => InputStream::one(v),
-
-                        Ok(ReturnSuccess::DebugValue(v)) => {
-                            let doc = PrettyDebug::pretty_doc(&v);
-                            let mut buffer = termcolor::Buffer::ansi();
-
-                            let _ = doc.render_raw(
-                                context.with_host(|host| host.width() - 5),
-                                &mut nu_source::TermColored::new(&mut buffer),
-                            );
-
-                            let value = String::from_utf8_lossy(buffer.as_slice());
-
-                            InputStream::one(UntaggedValue::string(value).into_untagged_value())
-                        }
-
-                        Err(err) => {
-                            context.error(err.clone());
-                            InputStream::one(UntaggedValue::Error(err).into_untagged_value())
-                        }
-                    }
-                }
-            })
-            .flatten()
-            .take_while(|x| futures::future::ready(!x.is_error())),
-    ))
-}

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

@@ -1,10 +0,0 @@
-pub(crate) mod block;
-mod dynamic;
-pub(crate) mod expr;
-pub(crate) mod external;
-pub(crate) mod internal;
-pub(crate) mod maybe_text_codec;
-pub(crate) mod plugin;
-
-#[allow(unused_imports)]
-pub(crate) use dynamic::Command as DynamicCommand;

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

@@ -1,340 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::help::get_help;
-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: Arc<Scope>,
-}
-
-impl UnevaluatedCallInfo {
-    pub async fn evaluate(self, registry: &CommandRegistry) -> Result<CallInfo, ShellError> {
-        let args = evaluate_args(&self.args, registry, self.scope.clone()).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: Arc<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, 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> {
-        self.call_info
-            .args
-            .nth(pos)
-            .ok_or_else(|| ShellError::unimplemented("Better error: expect_nth"))
-    }
-
-    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
-    }
-
-    // Commands that are not meant to be run by users
-    fn is_internal(&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 is_internal(&self) -> bool {
-        self.0.is_internal()
-    }
-
-    pub fn stream_command(&self) -> &dyn WholeStreamCommand {
-        &*self.0
-    }
-}
-
-pub fn whole_stream_command(command: impl WholeStreamCommand + 'static) -> Command {
-    Command(Arc::new(command))
-}

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

@@ -1,95 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use futures::future;
-use futures::stream::StreamExt;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-use nu_source::Tagged;
-
-pub struct Compact;
-
-#[derive(Deserialize)]
-pub struct CompactArgs {
-    rest: Vec<Tagged<String>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Compact {
-    fn name(&self) -> &str {
-        "compact"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("compact").rest(SyntaxShape::Any, "the columns to compact from the table")
-    }
-
-    fn usage(&self) -> &str {
-        "Creates a table with non-empty rows"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        compact(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Filter out all directory entries having no 'target'",
-            example: "ls -la | compact target",
-            result: None,
-        }]
-    }
-}
-
-pub async fn compact(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (CompactArgs { rest: columns }, input) = args.process(&registry).await?;
-    Ok(input
-        .filter_map(move |item| {
-            future::ready(if columns.is_empty() {
-                if !item.is_empty() {
-                    Some(ReturnSuccess::value(item))
-                } else {
-                    None
-                }
-            } else {
-                match item {
-                    Value {
-                        value: UntaggedValue::Row(ref r),
-                        ..
-                    } => {
-                        if columns
-                            .iter()
-                            .all(|field| r.get_data(field).borrow().is_some())
-                        {
-                            Some(ReturnSuccess::value(item))
-                        } else {
-                            None
-                        }
-                    }
-                    _ => None,
-                }
-            })
-        })
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Compact;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Compact {})?)
-    }
-}

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

@@ -1,57 +0,0 @@
-use crate::command_registry::CommandRegistry;
-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 {
-        "config clear"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config clear")
-    }
-
-    fn usage(&self) -> &str {
-        "clear the config"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        clear(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Clear the config (be careful!)",
-            example: "config clear",
-            result: None,
-        }]
-    }
-}
-
-pub async fn clear(
-    args: CommandArgs,
-    _registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-
-    // NOTE: None because we are not loading a new config file, we just want to read from the
-    // existing config
-    let mut result = nu_data::config::read(name_span, &None)?;
-
-    result.clear();
-
-    config::write(&result, &None)?;
-
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::Row(result.into()).into_value(args.call_info.name_tag),
-    )))
-}

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

@@ -1,37 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use crate::{CommandArgs, CommandRegistry, OutputStream};
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-
-pub struct Command;
-
-#[async_trait]
-impl WholeStreamCommand for Command {
-    fn name(&self) -> &str {
-        "config"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config")
-    }
-
-    fn usage(&self) -> &str {
-        "Configuration management."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        _registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let name_span = args.call_info.name_tag.clone();
-        let name = args.call_info.name_tag;
-        let result = nu_data::config::read(name_span, &None)?;
-
-        Ok(futures::stream::iter(vec![ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(name),
-        )])
-        .to_output_stream())
-    }
-}

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

@@ -1,76 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-
-pub struct SubCommand;
-
-#[derive(Deserialize)]
-pub struct GetArgs {
-    path: ColumnPath,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "config get"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config get").required(
-            "get",
-            SyntaxShape::ColumnPath,
-            "value to get from the config",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Gets a value from the config"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        get(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get the current startup commands",
-            example: "config get startup",
-            result: None,
-        }]
-    }
-}
-
-pub async fn get(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_tag = args.call_info.name_tag.clone();
-    let (GetArgs { path }, _) = 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 result = UntaggedValue::row(nu_data::config::read(&name_tag, &None)?).into_value(&name_tag);
-
-    let value = crate::commands::get::get_column_path(&path, &result)?;
-
-    Ok(match value {
-        Value {
-            value: UntaggedValue::Table(list),
-            ..
-        } => {
-            let list: Vec<_> = list
-                .iter()
-                .map(|x| ReturnSuccess::value(x.clone()))
-                .collect();
-
-            futures::stream::iter(list).to_output_stream()
-        }
-        x => OutputStream::one(ReturnSuccess::value(x)),
-    })
-}

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

@@ -1,59 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
-use nu_source::Tagged;
-use std::path::PathBuf;
-
-pub struct SubCommand;
-
-#[derive(Deserialize)]
-pub struct LoadArgs {
-    load: Tagged<PathBuf>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "config load"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config load").required(
-            "load",
-            SyntaxShape::Path,
-            "Path to load the config from",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Loads the config from the path given"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        set(args, registry).await
-    }
-}
-
-pub async fn set(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name = args.call_info.name_tag.clone();
-    let name_span = args.call_info.name_tag.clone();
-    let (LoadArgs { load }, _) = args.process(&registry).await?;
-
-    let configuration = load.item().clone();
-
-    let result = nu_data::config::read(name_span, &Some(configuration))?;
-
-    Ok(futures::stream::iter(vec![ReturnSuccess::value(
-        UntaggedValue::Row(result.into()).into_value(name),
-    )])
-    .to_output_stream())
-}

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

@@ -1,49 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "config path"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config path")
-    }
-
-    fn usage(&self) -> &str {
-        "return the path to the config file"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        path(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get the path to the current config file",
-            example: "config path",
-            result: None,
-        }]
-    }
-}
-
-pub async fn path(
-    args: CommandArgs,
-    _registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let path = config::default_path()?;
-
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::Primitive(Primitive::Path(path)).into_value(args.call_info.name_tag),
-    )))
-}

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

@@ -1,75 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
-use nu_source::Tagged;
-
-pub struct SubCommand;
-
-#[derive(Deserialize)]
-pub struct RemoveArgs {
-    remove: Tagged<String>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "config remove"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config remove").required(
-            "remove",
-            SyntaxShape::Any,
-            "remove a value from the config",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Removes a value from the config"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        remove(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Remove the startup commands",
-            example: "config remove startup",
-            result: None,
-        }]
-    }
-}
-
-pub async fn remove(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let (RemoveArgs { remove }, _) = args.process(&registry).await?;
-
-    let mut result = nu_data::config::read(name_span, &None)?;
-
-    let key = remove.to_string();
-
-    if result.contains_key(&key) {
-        result.swap_remove(&key);
-        config::write(&result, &None)?;
-        Ok(futures::stream::iter(vec![ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(remove.tag()),
-        )])
-        .to_output_stream())
-    } else {
-        Err(ShellError::labeled_error(
-            "Key does not exist in config",
-            "key",
-            remove.tag(),
-        ))
-    }
-}

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

@@ -1,97 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ColumnPath, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-
-pub struct SubCommand;
-
-#[derive(Deserialize)]
-pub struct SetArgs {
-    path: ColumnPath,
-    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::ColumnPath, "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 auto pivoting",
-                example: "config set pivot_mode always",
-                result: None,
-            },
-            Example {
-                description: "Set line editor options",
-                example: "config set line_editor [[edit_mode, completion_type]; [emacs circular]]",
-                result: None,
-            },
-            Example {
-                description: "Set coloring options",
-                example: "config set color_config [[header_align header_bold]; [left $true]]",
-                result: None,
-            },
-            Example {
-                description: "Set nested options",
-                example: "config set color_config.header_color white",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub async fn set(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_tag = args.call_info.name_tag.clone();
-    let (SetArgs { path, mut 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 raw_entries = nu_data::config::read(&name_tag, &None)?;
-    let configuration = UntaggedValue::row(raw_entries).into_value(&name_tag);
-
-    if let UntaggedValue::Table(rows) = &value.value {
-        if rows.len() == 1 && rows[0].is_row() {
-            value = rows[0].clone();
-        }
-    }
-
-    match configuration.forgiving_insert_data_at_column_path(&path, value) {
-        Ok(Value {
-            value: UntaggedValue::Row(changes),
-            ..
-        }) => {
-            config::write(&changes.entries, &None)?;
-
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::Row(changes).into_value(name_tag),
-            )))
-        }
-        Ok(_) => Ok(OutputStream::empty()),
-        Err(reason) => Err(reason),
-    }
-}

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

@@ -1,98 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-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 SetIntoArgs {
-    set_into: Tagged<String>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "config set_into"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("config set_into").required(
-            "set_into",
-            SyntaxShape::String,
-            "sets a variable from values in the pipeline",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Sets a value in the config"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        set_into(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Store the contents of the pipeline as a path",
-            example: "echo ['/usr/bin' '/bin'] | config set_into path",
-            result: None,
-        }]
-    }
-}
-
-pub async fn set_into(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let name = args.call_info.name_tag.clone();
-
-    let (SetIntoArgs { set_into: v }, input) = args.process(&registry).await?;
-
-    // NOTE: None because we are not loading a new config file, we just want to read from the
-    // existing config
-    let mut result = nu_data::config::read(name_span, &None)?;
-
-    // In the original code, this is set to `Some` if the `load flag is set`
-    let configuration = None;
-
-    let rows: Vec<Value> = input.collect().await;
-    let key = v.to_string();
-
-    Ok(if rows.is_empty() {
-        return Err(ShellError::labeled_error(
-            "No values given for set_into",
-            "needs value(s) from pipeline",
-            v.tag(),
-        ));
-    } else if rows.len() == 1 {
-        // A single value
-        let value = &rows[0];
-
-        result.insert(key, value.clone());
-
-        config::write(&result, &configuration)?;
-
-        OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(name),
-        ))
-    } else {
-        // Take in the pipeline as a table
-        let value = UntaggedValue::Table(rows).into_value(name.clone());
-
-        result.insert(key, value);
-
-        config::write(&result, &configuration)?;
-
-        OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(name),
-        ))
-    })
-}

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

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

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

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

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

@@ -1,76 +0,0 @@
-use crate::prelude::*;
-use chrono::{DateTime, Local};
-use nu_errors::ShellError;
-
-use crate::commands::date::utils::{date_to_value, date_to_value_raw};
-use crate::commands::WholeStreamCommand;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
-use nu_source::Tagged;
-
-pub struct Date;
-
-#[derive(Deserialize)]
-pub struct FormatArgs {
-    format: Tagged<String>,
-    raw: Option<bool>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Date {
-    fn name(&self) -> &str {
-        "date format"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("date format")
-            .required("format", SyntaxShape::String, "strftime format")
-            .switch("raw", "print date without tables", Some('r'))
-    }
-
-    fn usage(&self) -> &str {
-        "format the current date using the given format string."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        format(args, registry).await
-    }
-}
-
-pub async fn format(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let tag = args.call_info.name_tag.clone();
-    let (FormatArgs { format, raw }, _) = args.process(&registry).await?;
-
-    let dt_fmt = format.to_string();
-
-    let value = {
-        let local: DateTime<Local> = Local::now();
-        if let Some(true) = 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;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Date {})?)
-    }
-}

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

@@ -1,11 +0,0 @@
-pub mod command;
-pub mod format;
-pub mod now;
-pub mod utc;
-
-mod utils;
-
-pub use command::Command as Date;
-pub use format::Date as DateFormat;
-pub use now::Date as DateNow;
-pub use utc::Date as DateUTC;

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

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

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

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

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

@@ -1,64 +0,0 @@
-use crate::prelude::*;
-use chrono::DateTime;
-use nu_protocol::{Dictionary, Value};
-
-use chrono::{Datelike, TimeZone, Timelike};
-use core::fmt::Display;
-use indexmap::IndexMap;
-use nu_protocol::UntaggedValue;
-
-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)
-}

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

@@ -1,175 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-
-use futures::stream::once;
-use nu_errors::ShellError;
-use nu_protocol::{
-    hir::Block, hir::Expression, hir::SpannedExpression, hir::Synthetic, Scope, Signature,
-    SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
-};
-use nu_source::Tagged;
-
-pub struct Each;
-
-#[derive(Deserialize)]
-pub struct EachArgs {
-    block: Block,
-    numbered: Tagged<bool>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Each {
-    fn name(&self) -> &str {
-        "each"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("each")
-            .required("block", SyntaxShape::Block, "the block to run on each row")
-            .switch(
-                "numbered",
-                "returned a numbered item ($it.index and $it.item)",
-                Some('n'),
-            )
-    }
-
-    fn usage(&self) -> &str {
-        "Run a block on each row of the table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        each(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Echo the sum of each row",
-                example: "echo [[1 2] [3 4]] | each { echo $it | math sum }",
-                result: None,
-            },
-            Example {
-                description: "Echo the square of each integer",
-                example: "echo [1 2 3] | each { echo $(= $it * $it) }",
-                result: Some(vec![
-                    UntaggedValue::int(1).into(),
-                    UntaggedValue::int(4).into(),
-                    UntaggedValue::int(9).into(),
-                ]),
-            },
-            Example {
-                description: "Number each item and echo a message",
-                example:
-                    "echo ['bob' 'fred'] | each --numbered { echo `{{$it.index}} is {{$it.item}}` }",
-                result: Some(vec![Value::from("0 is bob"), Value::from("1 is fred")]),
-            },
-        ]
-    }
-}
-
-fn is_expanded_it_usage(head: &SpannedExpression) -> bool {
-    matches!(&*head, SpannedExpression {
-        expr: Expression::Synthetic(Synthetic::String(s)),
-        ..
-    } if s == "expanded-each")
-}
-
-pub async fn process_row(
-    block: Arc<Block>,
-    scope: Arc<Scope>,
-    head: Arc<Box<SpannedExpression>>,
-    mut context: Arc<EvaluationContext>,
-    input: Value,
-) -> Result<OutputStream, ShellError> {
-    let input_clone = input.clone();
-    let input_stream = if is_expanded_it_usage(&head) {
-        InputStream::empty()
-    } else {
-        once(async { Ok(input_clone) }).to_input_stream()
-    };
-    Ok(run_block(
-        &block,
-        Arc::make_mut(&mut context),
-        input_stream,
-        Scope::append_it(scope, input),
-    )
-    .await?
-    .to_output_stream())
-}
-
-pub(crate) fn make_indexed_item(index: usize, item: Value) -> Value {
-    let mut dict = TaggedDictBuilder::new(item.tag());
-    dict.insert_untagged("index", UntaggedValue::int(index));
-    dict.insert_value("item", item);
-
-    dict.into_value()
-}
-
-async fn each(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let head = Arc::new(raw_args.call_info.args.head.clone());
-    let scope = raw_args.call_info.scope.clone();
-    let context = Arc::new(EvaluationContext::from_raw(&raw_args, &registry));
-    let (each_args, input): (EachArgs, _) = raw_args.process(&registry).await?;
-    let block = Arc::new(each_args.block);
-
-    if each_args.numbered.item {
-        Ok(input
-            .enumerate()
-            .then(move |input| {
-                let block = block.clone();
-                let scope = scope.clone();
-                let head = head.clone();
-                let context = context.clone();
-                let row = make_indexed_item(input.0, input.1);
-
-                async {
-                    match process_row(block, scope, head, context, row).await {
-                        Ok(s) => s,
-                        Err(e) => OutputStream::one(Err(e)),
-                    }
-                }
-            })
-            .flatten()
-            .to_output_stream())
-    } else {
-        Ok(input
-            .then(move |input| {
-                let block = block.clone();
-                let scope = scope.clone();
-                let head = head.clone();
-                let context = context.clone();
-
-                async {
-                    match process_row(block, scope, head, context, input).await {
-                        Ok(s) => s,
-                        Err(e) => OutputStream::one(Err(e)),
-                    }
-                }
-            })
-            .flatten()
-            .to_output_stream())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Each;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Each {})?)
-    }
-}

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

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

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

@@ -1,173 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::hir::Operator;
-use nu_protocol::{
-    Primitive, Range, RangeInclusion, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
-
-pub struct Echo;
-
-#[derive(Deserialize)]
-pub struct EchoArgs {
-    pub rest: Vec<Value>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Echo {
-    fn name(&self) -> &str {
-        "echo"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("echo").rest(SyntaxShape::Any, "the values to echo")
-    }
-
-    fn usage(&self) -> &str {
-        "Echo the arguments back to the user."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        echo(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Put a hello message in the pipeline",
-                example: "echo 'hello'",
-                result: Some(vec![Value::from("hello")]),
-            },
-            Example {
-                description: "Print the value of the special '$nu' variable",
-                example: "echo $nu",
-                result: None,
-            },
-        ]
-    }
-}
-
-async fn echo(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (args, _): (EchoArgs, _) = args.process(&registry).await?;
-
-    let stream = args.rest.into_iter().map(|i| match i.as_string() {
-        Ok(s) => OutputStream::one(Ok(ReturnSuccess::Value(
-            UntaggedValue::string(s).into_value(i.tag.clone()),
-        ))),
-        _ => match i {
-            Value {
-                value: UntaggedValue::Table(table),
-                ..
-            } => futures::stream::iter(table.into_iter().map(ReturnSuccess::value))
-                .to_output_stream(),
-            Value {
-                value: UntaggedValue::Primitive(Primitive::Range(range)),
-                tag,
-            } => futures::stream::iter(RangeIterator::new(*range, tag)).to_output_stream(),
-            _ => OutputStream::one(Ok(ReturnSuccess::Value(i.clone()))),
-        },
-    });
-
-    Ok(futures::stream::iter(stream).flatten().to_output_stream())
-}
-
-struct RangeIterator {
-    curr: Primitive,
-    end: Primitive,
-    tag: Tag,
-    is_end_inclusive: bool,
-}
-
-impl RangeIterator {
-    pub fn new(range: Range, tag: Tag) -> RangeIterator {
-        let start = match range.from.0.item {
-            Primitive::Nothing => Primitive::Int(0.into()),
-            x => x,
-        };
-
-        RangeIterator {
-            curr: start,
-            end: range.to.0.item,
-            tag,
-            is_end_inclusive: matches!(range.to.1, RangeInclusion::Inclusive),
-        }
-    }
-}
-
-impl Iterator for RangeIterator {
-    type Item = Result<ReturnSuccess, ShellError>;
-    fn next(&mut self) -> Option<Self::Item> {
-        let ordering = if self.end == Primitive::Nothing {
-            Ordering::Less
-        } else {
-            let result =
-                nu_data::base::coerce_compare_primitive(&self.curr, &self.end).map_err(|_| {
-                    ShellError::labeled_error(
-                        "Cannot create range",
-                        "unsupported range",
-                        self.tag.span,
-                    )
-                });
-
-            if let Err(result) = result {
-                return Some(Err(result));
-            }
-
-            let result = result
-                .expect("Internal error: the error case was already protected, but that failed");
-
-            result.compare()
-        };
-
-        use std::cmp::Ordering;
-
-        if (ordering == Ordering::Less) || (self.is_end_inclusive && ordering == Ordering::Equal) {
-            let output = UntaggedValue::Primitive(self.curr.clone()).into_value(self.tag.clone());
-
-            let next_value = nu_data::value::compute_values(
-                Operator::Plus,
-                &UntaggedValue::Primitive(self.curr.clone()),
-                &UntaggedValue::int(1),
-            );
-
-            self.curr = match next_value {
-                Ok(result) => match result {
-                    UntaggedValue::Primitive(p) => p,
-                    _ => {
-                        return Some(Err(ShellError::unimplemented(
-                            "Internal error: expected a primitive result from increment",
-                        )));
-                    }
-                },
-                Err((left_type, right_type)) => {
-                    return Some(Err(ShellError::coerce_error(
-                        left_type.spanned(self.tag.span),
-                        right_type.spanned(self.tag.span),
-                    )));
-                }
-            };
-            Some(ReturnSuccess::value(output))
-        } else {
-            // TODO: add inclusive/exclusive ranges
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Echo;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Echo {})?)
-    }
-}

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

@@ -1,202 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::UnevaluatedCallInfo;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::hir::ExternalRedirection;
-use nu_protocol::{
-    CommandAction, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
-use nu_source::Tagged;
-use std::path::PathBuf;
-
-pub struct Enter;
-
-#[derive(Deserialize)]
-pub struct EnterArgs {
-    location: Tagged<PathBuf>,
-    encoding: Option<Tagged<String>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Enter {
-    fn name(&self) -> &str {
-        "enter"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("enter")
-            .required(
-                "location",
-                SyntaxShape::Path,
-                "the location to create a new shell from",
-            )
-            .named(
-                "encoding",
-                SyntaxShape::String,
-                "encoding to use to open file",
-                Some('e'),
-            )
-    }
-
-    fn usage(&self) -> &str {
-        r#"Create a new shell and begin at this path.
-        
-Multiple encodings are supported for reading text files by using
-the '--encoding <encoding>' parameter. Here is an example of a few:
-big5, euc-jp, euc-kr, gbk, iso-8859-1, utf-16, cp1252, latin5
-
-For a more complete list of encodings please refer to the encoding_rs
-documentation link at https://docs.rs/encoding_rs/0.8.23/encoding_rs/#statics"#
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        enter(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Enter a path as a new shell",
-                example: "enter ../projectB",
-                result: None,
-            },
-            Example {
-                description: "Enter a file as a new shell",
-                example: "enter package.json",
-                result: None,
-            },
-            Example {
-                description: "Enters file with iso-8859-1 encoding",
-                example: "enter file.csv --encoding iso-8859-1",
-                result: None,
-            },
-        ]
-    }
-}
-
-async fn enter(
-    raw_args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let scope = raw_args.call_info.scope.clone();
-    let shell_manager = raw_args.shell_manager.clone();
-    let head = raw_args.call_info.args.head.clone();
-    let ctrl_c = raw_args.ctrl_c.clone();
-    let current_errors = raw_args.current_errors.clone();
-    let host = raw_args.host.clone();
-    let tag = raw_args.call_info.name_tag.clone();
-    let (EnterArgs { location, encoding }, _) = raw_args.process(&registry).await?;
-    let location_string = location.display().to_string();
-    let location_clone = location_string.clone();
-
-    if location_string.starts_with("help") {
-        let spec = location_string.split(':').collect::<Vec<&str>>();
-
-        if spec.len() == 2 {
-            let (_, command) = (spec[0], spec[1]);
-
-            if registry.has(command) {
-                return Ok(OutputStream::one(ReturnSuccess::action(
-                    CommandAction::EnterHelpShell(
-                        UntaggedValue::string(command).into_value(Tag::unknown()),
-                    ),
-                )));
-            }
-        }
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::EnterHelpShell(UntaggedValue::nothing().into_value(Tag::unknown())),
-        )))
-    } else if location.is_dir() {
-        Ok(OutputStream::one(ReturnSuccess::action(
-            CommandAction::EnterShell(location_clone),
-        )))
-    } else {
-        // If it's a file, attempt to open the file as a value and enter it
-        let cwd = shell_manager.path();
-
-        let full_path = std::path::PathBuf::from(cwd);
-
-        let (file_extension, tagged_contents) = crate::commands::open::fetch(
-            &full_path,
-            &PathBuf::from(location_clone),
-            tag.span,
-            encoding,
-        )
-        .await?;
-
-        match tagged_contents.value {
-            UntaggedValue::Primitive(Primitive::String(_)) => {
-                if let Some(extension) = file_extension {
-                    let command_name = format!("from {}", extension);
-                    if let Some(converter) = registry.get_command(&command_name) {
-                        let new_args = RawCommandArgs {
-                            host,
-                            ctrl_c,
-                            current_errors,
-                            shell_manager,
-                            call_info: UnevaluatedCallInfo {
-                                args: nu_protocol::hir::Call {
-                                    head,
-                                    positional: None,
-                                    named: None,
-                                    span: Span::unknown(),
-                                    external_redirection: ExternalRedirection::Stdout,
-                                },
-                                name_tag: tag.clone(),
-                                scope: scope.clone(),
-                            },
-                        };
-                        let tag = tagged_contents.tag.clone();
-                        let mut result = converter
-                            .run(new_args.with_input(vec![tagged_contents]), &registry)
-                            .await?;
-                        let result_vec: Vec<Result<ReturnSuccess, ShellError>> =
-                            result.drain_vec().await;
-                        Ok(futures::stream::iter(result_vec.into_iter().map(
-                            move |res| match res {
-                                Ok(ReturnSuccess::Value(Value { value, .. })) => Ok(
-                                    ReturnSuccess::Action(CommandAction::EnterValueShell(Value {
-                                        value,
-                                        tag: tag.clone(),
-                                    })),
-                                ),
-                                x => x,
-                            },
-                        ))
-                        .to_output_stream())
-                    } else {
-                        Ok(OutputStream::one(ReturnSuccess::action(
-                            CommandAction::EnterValueShell(tagged_contents),
-                        )))
-                    }
-                } else {
-                    Ok(OutputStream::one(ReturnSuccess::action(
-                        CommandAction::EnterValueShell(tagged_contents),
-                    )))
-                }
-            }
-            _ => Ok(OutputStream::one(ReturnSuccess::action(
-                CommandAction::EnterValueShell(tagged_contents),
-            ))),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Enter;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Enter {})?)
-    }
-}

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

@@ -1,74 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::command::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{CommandAction, ReturnSuccess, Signature};
-
-pub struct Exit;
-
-#[async_trait]
-impl WholeStreamCommand for Exit {
-    fn name(&self) -> &str {
-        "exit"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("exit").switch("now", "exit out of the shell immediately", Some('n'))
-    }
-
-    fn usage(&self) -> &str {
-        "Exit the current shell (or all shells)"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        exit(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Exit the current shell",
-                example: "exit",
-                result: None,
-            },
-            Example {
-                description: "Exit all shells (exiting Nu)",
-                example: "exit --now",
-                result: None,
-            },
-        ]
-    }
-}
-
-pub async fn exit(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
-
-    let command_action = if args.call_info.args.has("now") {
-        CommandAction::Exit
-    } else {
-        CommandAction::LeaveShell
-    };
-
-    Ok(OutputStream::one(ReturnSuccess::action(command_action)))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Exit;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Exit {})?)
-    }
-}

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

@@ -1,83 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue};
-use nu_source::Tagged;
-
-pub struct First;
-
-#[derive(Deserialize)]
-pub struct FirstArgs {
-    rows: Option<Tagged<usize>>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for First {
-    fn name(&self) -> &str {
-        "first"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("first").optional(
-            "rows",
-            SyntaxShape::Int,
-            "starting from the front, the number of rows to return",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Show only the first number of rows."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        first(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Return the first item of a list/table",
-                example: "echo [1 2 3] | first",
-                result: Some(vec![UntaggedValue::int(1).into()]),
-            },
-            Example {
-                description: "Return the first 2 items of a list/table",
-                example: "echo [1 2 3] | first 2",
-                result: Some(vec![
-                    UntaggedValue::int(1).into(),
-                    UntaggedValue::int(2).into(),
-                ]),
-            },
-        ]
-    }
-}
-
-async fn first(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (FirstArgs { rows }, input) = args.process(&registry).await?;
-    let rows_desired = if let Some(quantity) = rows {
-        *quantity
-    } else {
-        1
-    };
-
-    Ok(input.take(rows_desired).to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::First;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(First {})?)
-    }
-}

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

@@ -1,162 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::evaluate::evaluate_baseline_expr;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue};
-use nu_source::Tagged;
-use std::borrow::Borrow;
-
-pub struct Format;
-
-#[derive(Deserialize)]
-pub struct FormatArgs {
-    pattern: Tagged<String>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Format {
-    fn name(&self) -> &str {
-        "format"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("format").required(
-            "pattern",
-            SyntaxShape::String,
-            "the pattern to output. Eg) \"{foo}: {bar}\"",
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Format columns into a string using a simple pattern."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        format_command(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Print filenames with their sizes",
-            example: "ls | format '{name}: {size}'",
-            result: None,
-        }]
-    }
-}
-
-async fn format_command(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = Arc::new(registry.clone());
-    let scope = args.call_info.scope.clone();
-    let (FormatArgs { pattern }, input) = args.process(&registry).await?;
-
-    let format_pattern = format(&pattern);
-    let commands = Arc::new(format_pattern);
-
-    Ok(input
-        .then(move |value| {
-            let mut output = String::new();
-            let commands = commands.clone();
-            let registry = registry.clone();
-            let scope = scope.clone();
-
-            async move {
-                for command in &*commands {
-                    match command {
-                        FormatCommand::Text(s) => {
-                            output.push_str(&s);
-                        }
-                        FormatCommand::Column(c) => {
-                            // FIXME: use the correct spans
-                            let full_column_path = nu_parser::parse_full_column_path(
-                                &(c.to_string()).spanned(Span::unknown()),
-                                &*registry,
-                            );
-
-                            let result = evaluate_baseline_expr(
-                                &full_column_path.0,
-                                &registry,
-                                Scope::append_it(scope.clone(), value.clone()),
-                            )
-                            .await;
-
-                            if let Ok(c) = result {
-                                output
-                                    .push_str(&value::format_leaf(c.borrow()).plain_string(100_000))
-                            } else {
-                                // That column doesn't match, so don't emit anything
-                            }
-                        }
-                    }
-                }
-
-                ReturnSuccess::value(UntaggedValue::string(output).into_untagged_value())
-            }
-        })
-        .to_output_stream())
-}
-
-#[derive(Debug)]
-enum FormatCommand {
-    Text(String),
-    Column(String),
-}
-
-fn format(input: &str) -> Vec<FormatCommand> {
-    let mut output = vec![];
-
-    let mut loop_input = input.chars();
-    loop {
-        let mut before = String::new();
-
-        while let Some(c) = loop_input.next() {
-            if c == '{' {
-                break;
-            }
-            before.push(c);
-        }
-
-        if !before.is_empty() {
-            output.push(FormatCommand::Text(before.to_string()));
-        }
-        // Look for column as we're now at one
-        let mut column = String::new();
-
-        while let Some(c) = loop_input.next() {
-            if c == '}' {
-                break;
-            }
-            column.push(c);
-        }
-
-        if !column.is_empty() {
-            output.push(FormatCommand::Column(column.to_string()));
-        }
-
-        if before.is_empty() && column.is_empty() {
-            break;
-        }
-    }
-
-    output
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Format;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Format {})?)
-    }
-}

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

@@ -1,46 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-
-pub struct From;
-
-#[async_trait]
-impl WholeStreamCommand for From {
-    fn name(&self) -> &str {
-        "from"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("from")
-    }
-
-    fn usage(&self) -> &str {
-        "Parse content (string or binary) as a table (input format based on subcommand, like csv, ini, json, toml)"
-    }
-
-    async fn run(
-        &self,
-        _args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = registry.clone();
-        Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(crate::commands::help::get_help(&From, &registry))
-                .into_value(Tag::unknown()),
-        )))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::From;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(From {})?)
-    }
-}

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

@@ -1,106 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, Signature, TaggedDictBuilder, UntaggedValue, Value};
-use std::collections::HashMap;
-
-pub struct FromINI;
-
-#[async_trait]
-impl WholeStreamCommand for FromINI {
-    fn name(&self) -> &str {
-        "from ini"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("from ini")
-    }
-
-    fn usage(&self) -> &str {
-        "Parse text as .ini and create table"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_ini(args, registry).await
-    }
-}
-
-fn convert_ini_second_to_nu_value(v: &HashMap<String, String>, tag: impl Into<Tag>) -> Value {
-    let mut second = TaggedDictBuilder::new(tag);
-
-    for (key, value) in v.iter() {
-        second.insert_untagged(key.clone(), Primitive::String(value.clone()));
-    }
-
-    second.into_value()
-}
-
-fn convert_ini_top_to_nu_value(
-    v: &HashMap<String, HashMap<String, String>>,
-    tag: impl Into<Tag>,
-) -> Value {
-    let tag = tag.into();
-    let mut top_level = TaggedDictBuilder::new(tag.clone());
-
-    for (key, value) in v.iter() {
-        top_level.insert_value(
-            key.clone(),
-            convert_ini_second_to_nu_value(value, tag.clone()),
-        );
-    }
-
-    top_level.into_value()
-}
-
-pub fn from_ini_string_to_value(
-    s: String,
-    tag: impl Into<Tag>,
-) -> Result<Value, serde_ini::de::Error> {
-    let v: HashMap<String, HashMap<String, String>> = serde_ini::from_str(&s)?;
-    Ok(convert_ini_top_to_nu_value(&v, tag))
-}
-
-async fn from_ini(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
-    let tag = args.name_tag();
-    let input = args.input;
-    let concat_string = input.collect_string(tag.clone()).await?;
-
-    match from_ini_string_to_value(concat_string.item, tag.clone()) {
-        Ok(x) => match x {
-            Value {
-                value: UntaggedValue::Table(list),
-                ..
-            } => Ok(futures::stream::iter(list).to_output_stream()),
-            x => Ok(OutputStream::one(x)),
-        },
-        Err(_) => Err(ShellError::labeled_error_with_secondary(
-            "Could not parse as INI",
-            "input cannot be parsed as INI",
-            &tag,
-            "value originates from here",
-            concat_string.tag,
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::FromINI;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(FromINI {})?)
-    }
-}

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

@@ -1,155 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
-
-pub struct FromJSON;
-
-#[derive(Deserialize)]
-pub struct FromJSONArgs {
-    objects: bool,
-}
-
-#[async_trait]
-impl WholeStreamCommand for FromJSON {
-    fn name(&self) -> &str {
-        "from json"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("from json").switch(
-            "objects",
-            "treat each line as a separate value",
-            Some('o'),
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Parse text as .json and create table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_json(args, registry).await
-    }
-}
-
-fn convert_json_value_to_nu_value(v: &serde_hjson::Value, tag: impl Into<Tag>) -> Value {
-    let tag = tag.into();
-    let span = tag.span;
-
-    match v {
-        serde_hjson::Value::Null => UntaggedValue::Primitive(Primitive::Nothing).into_value(&tag),
-        serde_hjson::Value::Bool(b) => UntaggedValue::boolean(*b).into_value(&tag),
-        serde_hjson::Value::F64(n) => UntaggedValue::decimal_from_float(*n, span).into_value(&tag),
-        serde_hjson::Value::U64(n) => UntaggedValue::int(*n).into_value(&tag),
-        serde_hjson::Value::I64(n) => UntaggedValue::int(*n).into_value(&tag),
-        serde_hjson::Value::String(s) => {
-            UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(&tag)
-        }
-        serde_hjson::Value::Array(a) => UntaggedValue::Table(
-            a.iter()
-                .map(|x| convert_json_value_to_nu_value(x, &tag))
-                .collect(),
-        )
-        .into_value(tag),
-        serde_hjson::Value::Object(o) => {
-            let mut collected = TaggedDictBuilder::new(&tag);
-            for (k, v) in o.iter() {
-                collected.insert_value(k.clone(), convert_json_value_to_nu_value(v, &tag));
-            }
-
-            collected.into_value()
-        }
-    }
-}
-
-pub fn from_json_string_to_value(s: String, tag: impl Into<Tag>) -> serde_hjson::Result<Value> {
-    let v: serde_hjson::Value = serde_hjson::from_str(&s)?;
-    Ok(convert_json_value_to_nu_value(&v, tag))
-}
-
-async fn from_json(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let name_tag = args.call_info.name_tag.clone();
-    let registry = registry.clone();
-
-    let (FromJSONArgs { objects }, input) = args.process(&registry).await?;
-    let concat_string = input.collect_string(name_tag.clone()).await?;
-
-    let string_clone: Vec<_> = concat_string.item.lines().map(|x| x.to_string()).collect();
-
-    if objects {
-        Ok(
-            futures::stream::iter(string_clone.into_iter().filter_map(move |json_str| {
-                if json_str.is_empty() {
-                    return None;
-                }
-
-                match from_json_string_to_value(json_str, &name_tag) {
-                    Ok(x) => Some(ReturnSuccess::value(x)),
-                    Err(e) => {
-                        let mut message = "Could not parse as JSON (".to_string();
-                        message.push_str(&e.to_string());
-                        message.push_str(")");
-
-                        Some(Err(ShellError::labeled_error_with_secondary(
-                            message,
-                            "input cannot be parsed as JSON",
-                            name_tag.clone(),
-                            "value originates from here",
-                            concat_string.tag.clone(),
-                        )))
-                    }
-                }
-            }))
-            .to_output_stream(),
-        )
-    } else {
-        match from_json_string_to_value(concat_string.item, name_tag.clone()) {
-            Ok(x) => match x {
-                Value {
-                    value: UntaggedValue::Table(list),
-                    ..
-                } => Ok(
-                    futures::stream::iter(list.into_iter().map(ReturnSuccess::value))
-                        .to_output_stream(),
-                ),
-                x => Ok(OutputStream::one(ReturnSuccess::value(x))),
-            },
-            Err(e) => {
-                let mut message = "Could not parse as JSON (".to_string();
-                message.push_str(&e.to_string());
-                message.push_str(")");
-
-                Ok(OutputStream::one(Err(
-                    ShellError::labeled_error_with_secondary(
-                        message,
-                        "input cannot be parsed as JSON",
-                        name_tag,
-                        "value originates from here",
-                        concat_string.tag,
-                    ),
-                )))
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::FromJSON;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(FromJSON {})?)
-    }
-}

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

@@ -1,112 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
-
-pub struct FromTOML;
-
-#[async_trait]
-impl WholeStreamCommand for FromTOML {
-    fn name(&self) -> &str {
-        "from toml"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("from toml")
-    }
-
-    fn usage(&self) -> &str {
-        "Parse text as .toml and create table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_toml(args, registry).await
-    }
-}
-
-pub fn convert_toml_value_to_nu_value(v: &toml::Value, tag: impl Into<Tag>) -> Value {
-    let tag = tag.into();
-    let span = tag.span;
-
-    match v {
-        toml::Value::Boolean(b) => UntaggedValue::boolean(*b).into_value(tag),
-        toml::Value::Integer(n) => UntaggedValue::int(*n).into_value(tag),
-        toml::Value::Float(n) => UntaggedValue::decimal_from_float(*n, span).into_value(tag),
-        toml::Value::String(s) => {
-            UntaggedValue::Primitive(Primitive::String(String::from(s))).into_value(tag)
-        }
-        toml::Value::Array(a) => UntaggedValue::Table(
-            a.iter()
-                .map(|x| convert_toml_value_to_nu_value(x, &tag))
-                .collect(),
-        )
-        .into_value(tag),
-        toml::Value::Datetime(dt) => {
-            UntaggedValue::Primitive(Primitive::String(dt.to_string())).into_value(tag)
-        }
-        toml::Value::Table(t) => {
-            let mut collected = TaggedDictBuilder::new(&tag);
-
-            for (k, v) in t.iter() {
-                collected.insert_value(k.clone(), convert_toml_value_to_nu_value(v, &tag));
-            }
-
-            collected.into_value()
-        }
-    }
-}
-
-pub fn from_toml_string_to_value(s: String, tag: impl Into<Tag>) -> Result<Value, toml::de::Error> {
-    let v: toml::Value = s.parse::<toml::Value>()?;
-    Ok(convert_toml_value_to_nu_value(&v, tag))
-}
-
-pub async fn from_toml(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let args = args.evaluate_once(&registry).await?;
-    let tag = args.name_tag();
-    let input = args.input;
-
-    let concat_string = input.collect_string(tag.clone()).await?;
-    Ok(
-        match from_toml_string_to_value(concat_string.item, tag.clone()) {
-            Ok(x) => match x {
-                Value {
-                    value: UntaggedValue::Table(list),
-                    ..
-                } => futures::stream::iter(list.into_iter().map(ReturnSuccess::value))
-                    .to_output_stream(),
-                x => OutputStream::one(ReturnSuccess::value(x)),
-            },
-            Err(_) => {
-                return Err(ShellError::labeled_error_with_secondary(
-                    "Could not parse as TOML",
-                    "input cannot be parsed as TOML",
-                    &tag,
-                    "value originates from here",
-                    concat_string.tag,
-                ))
-            }
-        },
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::FromTOML;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(FromTOML {})?)
-    }
-}

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

@@ -1,63 +0,0 @@
-use crate::commands::from_delimited_data::from_delimited_data;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::Signature;
-
-pub struct FromTSV;
-
-#[derive(Deserialize)]
-pub struct FromTSVArgs {
-    headerless: bool,
-}
-
-#[async_trait]
-impl WholeStreamCommand for FromTSV {
-    fn name(&self) -> &str {
-        "from tsv"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("from tsv").switch(
-            "headerless",
-            "don't treat the first row as column names",
-            None,
-        )
-    }
-
-    fn usage(&self) -> &str {
-        "Parse text as .tsv and create table."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        from_tsv(args, registry).await
-    }
-}
-
-async fn from_tsv(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let name = args.call_info.name_tag.clone();
-    let (FromTSVArgs { headerless }, input) = args.process(&registry).await?;
-
-    from_delimited_data(headerless, '\t', "TSV", input, name).await
-}
-
-#[cfg(test)]
-mod tests {
-    use super::FromTSV;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(FromTSV {})?)
-    }
-}

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

@@ -1,90 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_data::config::{Conf, NuConfig};
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
-use std::fs::File;
-use std::io::{BufRead, BufReader};
-use std::path::PathBuf;
-
-const DEFAULT_LOCATION: &str = "history.txt";
-
-pub fn history_path(config: &dyn Conf) -> PathBuf {
-    let default_path = nu_data::config::user_data()
-        .map(|mut p| {
-            p.push(DEFAULT_LOCATION);
-            p
-        })
-        .unwrap_or_else(|_| PathBuf::from(DEFAULT_LOCATION));
-
-    config
-        .var("history-path")
-        .map_or(default_path.clone(), |custom_path| {
-            match custom_path.as_string() {
-                Ok(path) => PathBuf::from(path),
-                Err(_) => default_path,
-            }
-        })
-}
-
-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 config: Box<dyn Conf> = Box::new(NuConfig::new());
-    let tag = args.call_info.name_tag;
-    let path = history_path(&config);
-    let file = File::open(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;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(History {})?)
-    }
-}

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

@@ -1,185 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::classified::block::run_block;
-use crate::commands::WholeStreamCommand;
-use crate::evaluate::evaluate_baseline_expr;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{
-    hir::Block, hir::ClassifiedCommand, Scope, 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 = raw_args.call_info.scope.clone();
-    let tag = raw_args.call_info.name_tag.clone();
-    let context = Arc::new(EvaluationContext::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::append_it(scope.clone(), input);
-            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, scope.clone()).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(),
-                                    scope,
-                                )
-                                .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(),
-                                    scope,
-                                )
-                                .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;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(If {})?)
-    }
-}

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

@@ -1,89 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
-
-use num_bigint::ToBigInt;
-
-pub struct IntoInt;
-
-#[derive(Deserialize)]
-pub struct IntoIntArgs {
-    pub rest: Vec<Value>,
-}
-
-#[async_trait]
-impl WholeStreamCommand for IntoInt {
-    fn name(&self) -> &str {
-        "into-int"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("into-int").rest(SyntaxShape::Any, "the values to into-int")
-    }
-
-    fn usage(&self) -> &str {
-        "Convert value to integer"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        into_int(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Convert filesize to integer",
-            example: "echo 1kb | into-int $it | = $it / 1024",
-            result: Some(vec![UntaggedValue::int(1).into()]),
-        }]
-    }
-}
-
-async fn into_int(
-    args: CommandArgs,
-    registry: &CommandRegistry,
-) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (args, _): (IntoIntArgs, _) = args.process(&registry).await?;
-
-    let stream = args.rest.into_iter().map(|i| match i {
-        Value {
-            value: UntaggedValue::Primitive(primitive_val),
-            tag,
-        } => match primitive_val {
-            Primitive::Filesize(size) => OutputStream::one(Ok(ReturnSuccess::Value(Value {
-                value: UntaggedValue::int(size.to_bigint().expect("Conversion should never fail.")),
-                tag,
-            }))),
-            Primitive::Int(_) => OutputStream::one(Ok(ReturnSuccess::Value(Value {
-                value: UntaggedValue::Primitive(primitive_val),
-                tag,
-            }))),
-            _ => OutputStream::one(Err(ShellError::labeled_error(
-                "Could not convert int value",
-                "original value",
-                tag,
-            ))),
-        },
-        _ => OutputStream::one(Ok(ReturnSuccess::Value(i))),
-    });
-
-    Ok(futures::stream::iter(stream).flatten().to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::IntoInt;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(IntoInt {})?)
-    }
-}

crates/nu-cli/src/commands/keep/until.rs

@@ -1,113 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::evaluate::evaluate_baseline_expr;
-use crate::prelude::*;
-use log::trace;
-use nu_errors::ShellError;
-use nu_protocol::{hir::ClassifiedCommand, Scope, Signature, SyntaxShape, UntaggedValue, Value};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "keep until"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("keep until")
-            .required(
-                "condition",
-                SyntaxShape::Math,
-                "The condition that must be met to stop keeping rows",
-            )
-            .filter()
-    }
-
-    fn usage(&self) -> &str {
-        "Keeps rows until the condition matches."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = Arc::new(registry.clone());
-        let scope = args.call_info.scope.clone();
-
-        let call_info = args.evaluate_once(&registry).await?;
-
-        let block = call_info.args.expect_nth(0)?.clone();
-
-        let condition = Arc::new(match block {
-            Value {
-                value: UntaggedValue::Block(block),
-                tag,
-            } => {
-                if block.block.len() != 1 {
-                    return Err(ShellError::labeled_error(
-                        "Expected a condition",
-                        "expected a condition",
-                        tag,
-                    ));
-                }
-                match block.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,
-                        ));
-                    }
-                }
-            }
-            Value { tag, .. } => {
-                return Err(ShellError::labeled_error(
-                    "Expected a condition",
-                    "expected a condition",
-                    tag,
-                ));
-            }
-        });
-
-        Ok(call_info
-            .input
-            .take_while(move |item| {
-                let condition = condition.clone();
-                let registry = registry.clone();
-                let scope = Scope::append_it(scope.clone(), item.clone());
-                trace!("ITEM = {:?}", item);
-
-                async move {
-                    let result = evaluate_baseline_expr(&*condition, &registry, scope).await;
-                    trace!("RESULT = {:?}", result);
-
-                    !matches!(result, Ok(ref v) if v.is_true())
-                }
-            })
-            .to_output_stream())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ShellError;
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(SubCommand {})?)
-    }
-}

crates/nu-cli/src/commands/keep/while_.rs

@@ -1,112 +0,0 @@
-use crate::commands::WholeStreamCommand;
-use crate::evaluate::evaluate_baseline_expr;
-use crate::prelude::*;
-use log::trace;
-use nu_errors::ShellError;
-use nu_protocol::{hir::ClassifiedCommand, Scope, Signature, SyntaxShape, UntaggedValue, Value};
-
-pub struct SubCommand;
-
-#[async_trait]
-impl WholeStreamCommand for SubCommand {
-    fn name(&self) -> &str {
-        "keep while"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("keep while")
-            .required(
-                "condition",
-                SyntaxShape::Math,
-                "The condition that must be met to keep rows",
-            )
-            .filter()
-    }
-
-    fn usage(&self) -> &str {
-        "Keeps rows while the condition matches."
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let registry = Arc::new(registry.clone());
-        let scope = args.call_info.scope.clone();
-        let call_info = args.evaluate_once(&registry).await?;
-
-        let block = call_info.args.expect_nth(0)?.clone();
-
-        let condition = Arc::new(match block {
-            Value {
-                value: UntaggedValue::Block(block),
-                tag,
-            } => {
-                if block.block.len() != 1 {
-                    return Err(ShellError::labeled_error(
-                        "Expected a condition",
-                        "expected a condition",
-                        tag,
-                    ));
-                }
-                match block.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,
-                        ));
-                    }
-                }
-            }
-            Value { tag, .. } => {
-                return Err(ShellError::labeled_error(
-                    "Expected a condition",
-                    "expected a condition",
-                    tag,
-                ));
-            }
-        });
-
-        Ok(call_info
-            .input
-            .take_while(move |item| {
-                let condition = condition.clone();
-                let registry = registry.clone();
-                let scope = Scope::append_it(scope.clone(), item.clone());
-                trace!("ITEM = {:?}", item);
-
-                async move {
-                    let result = evaluate_baseline_expr(&*condition, &registry, scope).await;
-                    trace!("RESULT = {:?}", result);
-
-                    matches!(result, Ok(ref v) if v.is_true())
-                }
-            })
-            .to_output_stream())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ShellError;
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(SubCommand {})?)
-    }
-}

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

@@ -1,352 +0,0 @@
-#[doc(hidden)]
-#[macro_export]
-macro_rules! command {
-    (
-        Named { $export:tt $args:ident $body:block }
-        Positional { $($number:tt)* }
-        Rest {}
-        Signature {
-            name: $config_name:tt,
-            mandatory_positional: vec![ $($mandatory_positional:tt)* ],
-            optional_positional: vec![ $($optional_positional:tt)* ],
-            rest_positional: $rest_positional:tt,
-            named: {
-                $(
-                    ($named_param:tt : $named_type:ty : $named_kind:tt)
-                )*
-            }
-        }
-
-        Function {
-            $( ( $param_name:tt : $param_type:tt ) )*
-        }
-
-        Extract {
-            $($extract:tt)*
-        }
-    ) => {
-        #[allow(non_camel_case_types)]
-        pub struct $export;
-
-        impl Command for $export {
-            fn run(&self, $args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-                fn command($args: EvaluatedCommandArgs, ( $($param_name),*, ): ( $($param_type),*, )) -> Result<OutputStream, ShellError> {
-                    let output = $body;
-
-                    Ok(output.boxed().to_output_stream())
-                }
-
-                let $args = $args.evaluate_once(registry)?;
-                let tuple = ( $($extract ,)* );
-                command( $args, tuple )
-            }
-
-            fn name(&self) -> &str {
-                stringify!($config_name)
-            }
-
-            fn config(&self) -> $nu_parser::registry::Signature {
-                $nu_parser::registry::Signature {
-                    name: self.name().to_string(),
-                    positional: vec![$($mandatory_positional)*],
-                    rest_positional: false,
-                    is_filter: false,
-                    is_sink: false,
-
-                    named: {
-                        use $nu_parser::registry::NamedType;
-
-                        #[allow(unused_mut)]
-                        let mut named: indexmap::IndexMap<String, NamedType> = indexmap::IndexMap::new();
-
-                        $(
-                            named.insert(stringify!($named_param).to_string(), $nu_parser::registry::NamedType::$named_kind);
-                        )*
-
-                        named
-                    }
-                }
-            }
-        }
-    };
-
-    // switch
-    (
-        Named { $export:tt $args:ident $body:block }
-        Positional { $($positional_count:tt)* }
-        Rest { -- $param_name:ident : Switch , $($rest:tt)* }
-        Signature {
-            name: $config_name:tt,
-            mandatory_positional: vec![ $($mandatory_positional:tt)* ],
-            optional_positional: vec![ $($optional_positional:tt)* ],
-            rest_positional: $rest_positional:tt,
-            named: {
-                $($config_named:tt)*
-            }
-        }
-        Function {
-            $($function:tt)*
-        }
-        Extract {
-            $($extract:tt)*
-        }
-    ) => {
-        command!(
-            Named { $export $args $body }
-            Positional { $($positional_count)* + 1 }
-            Rest { $($rest)* }
-            Signature {
-                name: $config_name,
-                mandatory_positional: vec![ $($mandatory_positional)* ],
-                optional_positional: vec![ $($optional_positional)* ],
-                rest_positional: $rest_positional,
-                named: {
-                    $($config_named)*
-                    ($param_name : Switch : Switch)
-                }
-            }
-
-            Function {
-                $($function)* ($param_name : Switch)
-            }
-
-            Extract {
-                $($extract)* {
-                    use std::convert::TryInto;
-
-                    $args.get(stringify!($param_name)).try_into()?
-                }
-            }
-        );
-    };
-
-    // mandatory named arguments
-    (
-        Named { $export:tt $args:ident $body:block }
-        Positional { $($positional_count:tt)* }
-        Rest { -- $param_name:ident : $param_kind:ty , $($rest:tt)* }
-        Signature {
-            name: $config_name:tt,
-            mandatory_positional: vec![ $($mandatory_positional:tt)* ],
-            optional_positional: vec![ $($optional_positional:tt)* ],
-            rest_positional: $rest_positional:tt,
-            named: {
-                $($config_named:tt)*
-            }
-        }
-        Function {
-            $($function:tt)*
-        }
-        Extract {
-            $($extract:tt)*
-        }
-    ) => {
-        command!(
-            Named { $export $args $body }
-            Positional { $($positional_count)* + 1 }
-            Rest { $($rest)* }
-            Signature {
-                name: $config_name,
-                mandatory_positional: vec![ $($mandatory_positional)* ],
-                optional_positional: vec![ $($optional_positional)* ],
-                rest_positional: $rest_positional,
-                named: {
-                    $($config_named)*
-                    ($param_name : Mandatory(NamedValue::Single))
-                }
-            }
-
-            Function {
-                $($function)* ($param_name : $param_kind)
-            }
-
-            Extract {
-                $($extract)* {
-                    use std::convert::TryInto;
-
-                    $args.get(stringify!($param_name)).try_into()?
-                }
-            }
-        );
-    };
-
-    // optional named arguments
-    (
-        Named { $export:tt $args:ident $body:block }
-        Positional { $($positional_count:tt)* }
-        Rest { -- $param_name:ident ? : $param_kind:ty , $($rest:tt)* }
-        Signature {
-            name: $config_name:tt,
-            mandatory_positional: vec![ $($mandatory_positional:tt)* ],
-            optional_positional: vec![ $($optional_positional:tt)* ],
-            rest_positional: $rest_positional:tt,
-            named: {
-                $($config_named:tt)*
-            }
-        }
-        Function {
-            $($function:tt)*
-        }
-        Extract {
-            $($extract:tt)*
-        }
-    ) => {
-        command!(
-            Named { $export $args $body }
-            Positional { $($positional_count)* + 1 }
-            Rest { $($rest)* }
-            Signature {
-                name: $config_name,
-                mandatory_positional: vec![ $($mandatory_positional)* ],
-                optional_positional: vec![ $($optional_positional)* ],
-                rest_positional: $rest_positional,
-                named: {
-                    $($config_named)*
-                    ($param_name : Optional(NamedValue::Single))
-                }
-            }
-
-            Function {
-                $($function)* ($param_name : $param_kind)
-            }
-
-            Extract {
-                $($extract)* {
-                    use std::convert::TryInto;
-
-                    $args.get(stringify!($param_name)).try_into()?
-                }
-            }
-        );
-    };
-
-    // mandatory positional block
-    (
-        Named { $export:ident $args:ident $body:block }
-        Positional { $($positional_count:tt)* }
-        Rest { $param_name:ident : Block , $($rest:tt)* }
-        Signature {
-            name: $config_name:tt,
-            mandatory_positional: vec![ $($mandatory_positional:tt)* ],
-            optional_positional: vec![ $($optional_positional:tt)* ],
-            rest_positional: $rest_positional:tt,
-            named: {
-                $($config_named:tt)*
-            }
-        }
-
-        Function {
-            $($function:tt)*
-        }
-
-        Extract {
-            $($extract:tt)*
-        }
-
-    ) => {
-        command!(
-            Named { $export $args $body }
-            Positional { $($positional_count)* + 1 }
-            Rest { $($rest)* }
-            Signature {
-                name: $config_name,
-                mandatory_positional: vec![ $($mandatory_positional)* $nu_parser::registry::PositionalType::mandatory_block(
-                    stringify!($param_name)
-                ), ],
-                optional_positional: vec![ $($optional_positional)* ],
-                rest_positional: $rest_positional,
-                named: {
-                    $($config_named)*
-                }
-            }
-
-            Function {
-                $($function)* ($param_name : Block)
-            }
-
-            Extract {
-                $($extract:tt)* {
-                    use $nu_data::types::ExtractType;
-                    let value = $args.expect_nth($($positional_count)*)?;
-                    Block::extract(value)?
-                }
-            }
-        );
-    };
-
-
-    // mandatory positional argument
-    (
-        Named { $export:ident $args:ident $body:block }
-        Positional { $($positional_count:tt)* }
-        Rest { $param_name:ident : $param_kind:ty , $($rest:tt)* }
-        Signature {
-            name: $config_name:tt,
-            mandatory_positional: vec![ $($mandatory_positional:tt)* ],
-            optional_positional: vec![ $($optional_positional:tt)* ],
-            rest_positional: $rest_positional:tt,
-            named: {
-                $($config_named:tt)*
-            }
-        }
-
-        Function {
-            $($function:tt)*
-        }
-
-        Extract {
-            $($extract:tt)*
-        }
-
-    ) => {
-        command!(
-            Named { $export $args $body }
-            Positional { $($positional_count)* + 1 }
-            Rest { $($rest)* }
-            Signature {
-                name: $config_name,
-                mandatory_positional: vec![ $($mandatory_positional)* $nu_parser::registry::PositionalType::mandatory(
-                    stringify!($param_name), <$param_kind>::syntax_type()
-                ), ],
-                optional_positional: vec![ $($optional_positional)* ],
-                rest_positional: $rest_positional,
-                named: {
-                    $($config_named)*
-                }
-            }
-
-            Function {
-                $($function)* ($param_name : $param_kind)
-            }
-
-            Extract {
-                $($extract:tt)* {
-                    use $nu_data::types::ExtractType;
-                    let value = $args.expect_nth($($positional_count)*)?;
-                    <$param_kind>::extract(&value)?
-                }
-            }
-        );
-    };
-
-    ($export:ident as $config_name:tt ( $args:ident , $($command_rest:tt)* ) $body:block) => {
-        command!(
-            Named { $export $args $body }
-            Positional { 0 }
-            Rest { $($command_rest)* }
-            Signature {
-                name: $config_name,
-                mandatory_positional: vec![],
-                optional_positional: vec![],
-                rest_positional: false,
-                named: {}
-            }
-
-            Function {
-            }
-
-            Extract {
-            }
-        );
-    };
-}

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

@@ -1,112 +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_from_float(
-                2.5,
-                Span::unknown(),
-            )
-            .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::ShellError;
-    use super::SubCommand;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(SubCommand {})?)
-    }
-}

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

@@ -1,47 +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;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Command {})?)
-    }
-}

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

@@ -1,7 +0,0 @@
-mod column;
-mod command;
-pub mod mv;
-
-pub use column::SubCommand as MoveColumn;
-pub use command::Command as Move;
-pub use mv::Mv;

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

@@ -1,107 +0,0 @@
-use crate::command_registry::CommandRegistry;
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, Value};
-use nu_source::Tagged;
-
-#[derive(Deserialize)]
-struct NthArgs {
-    row_number: Tagged<u64>,
-    rest: Vec<Tagged<u64>>,
-}
-
-pub struct Nth;
-
-#[async_trait]
-impl WholeStreamCommand for Nth {
-    fn name(&self) -> &str {
-        "nth"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("nth")
-            .required(
-                "row number",
-                SyntaxShape::Int,
-                "the number of the row to return",
-            )
-            .rest(SyntaxShape::Any, "Optionally return more rows")
-    }
-
-    fn usage(&self) -> &str {
-        "Return only the selected rows"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        nth(args, registry).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Get the second row",
-                example: "echo [first second third] | nth 1",
-                result: Some(vec![Value::from("second")]),
-            },
-            Example {
-                description: "Get the first and third rows",
-                example: "echo [first second third] | nth 0 2",
-                result: Some(vec![Value::from("first"), Value::from("third")]),
-            },
-        ]
-    }
-}
-
-async fn nth(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let registry = registry.clone();
-    let (
-        NthArgs {
-            row_number,
-            rest: and_rows,
-        },
-        input,
-    ) = args.process(&registry).await?;
-
-    let row_numbers = vec![vec![row_number], and_rows]
-        .into_iter()
-        .flatten()
-        .map(|x| x.item)
-        .collect::<Vec<u64>>();
-
-    let max_row_number = row_numbers
-        .iter()
-        .max()
-        .expect("Internal error: should be > 0 row numbers");
-
-    Ok(input
-        .take(*max_row_number as usize + 1)
-        .enumerate()
-        .filter_map(move |(idx, item)| {
-            futures::future::ready(
-                if row_numbers.iter().any(|requested| *requested == idx as u64) {
-                    Some(ReturnSuccess::value(item))
-                } else {
-                    None
-                },
-            )
-        })
-        .to_output_stream())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Nth;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(Nth {})?)
-    }
-}

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

@@ -1,3 +0,0 @@
-mod plugin;
-
-pub use plugin::SubCommand as NuPlugin;

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

@@ -1,62 +0,0 @@
-use super::{operate, DefaultArguments};
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
-use std::path::Path;
-
-pub struct PathBasename;
-
-#[async_trait]
-impl WholeStreamCommand for PathBasename {
-    fn name(&self) -> &str {
-        "path basename"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("path basename")
-            .rest(SyntaxShape::ColumnPath, "optionally operate by path")
-    }
-
-    fn usage(&self) -> &str {
-        "gets the filename of a path"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let tag = args.call_info.name_tag.clone();
-        let (DefaultArguments { rest }, input) = args.process(&registry).await?;
-        operate(input, rest, &action, tag.span).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get basename of a path",
-            example: "echo '/home/joe/test.txt' | path basename",
-            result: Some(vec![Value::from("test.txt")]),
-        }]
-    }
-}
-
-fn action(path: &Path) -> UntaggedValue {
-    UntaggedValue::string(match path.file_name() {
-        Some(filename) => filename.to_string_lossy().to_string(),
-        _ => "".to_string(),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::PathBasename;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(PathBasename {})?)
-    }
-}

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

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

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

@@ -1,61 +0,0 @@
-use super::{operate, DefaultArguments};
-use crate::commands::WholeStreamCommand;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
-use std::path::Path;
-
-pub struct PathDirname;
-
-#[async_trait]
-impl WholeStreamCommand for PathDirname {
-    fn name(&self) -> &str {
-        "path dirname"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("path dirname").rest(SyntaxShape::ColumnPath, "optionally operate by path")
-    }
-
-    fn usage(&self) -> &str {
-        "gets the dirname of a path"
-    }
-
-    async fn run(
-        &self,
-        args: CommandArgs,
-        registry: &CommandRegistry,
-    ) -> Result<OutputStream, ShellError> {
-        let tag = args.call_info.name_tag.clone();
-        let (DefaultArguments { rest }, input) = args.process(&registry).await?;
-        operate(input, rest, &action, tag.span).await
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Get dirname of a path",
-            example: "echo '/home/joe/test.txt' | path dirname",
-            result: Some(vec![Value::from("/home/joe")]),
-        }]
-    }
-}
-
-fn action(path: &Path) -> UntaggedValue {
-    UntaggedValue::string(match path.parent() {
-        Some(dirname) => dirname.to_string_lossy().to_string(),
-        _ => "".to_string(),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::PathDirname;
-    use super::ShellError;
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        use crate::examples::test as test_examples;
-
-        Ok(test_examples(PathDirname {})?)
-    }
-}