Bump to 0.35 (#3884)

* Add the nu-serde crate

nu-serde is a crate that can be used to turn a value implementing
`serde::Serialize` into a `nu-protocol::Value`. This has the potential to
significantly simplify plugin authorship.

This crate was the previously independent
[serde-nu](https://github.com/lily-mara/serde-nu) but the nushell maintainers
expressed an interest in having it added to the mainline nushell repository.

* fixup! Add the nu-serde crate

.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,47 +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):**
-
-Run `version | pivot` and paste the output to show OS, features, etc.
-
-```
-> version | pivot
-╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
-│ # │ Column0            │ Column1                                                               │
-├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
-│ 0 │ version            │ 0.24.1                                                                │
-│ 1 │ build_os           │ macos-x86_64                                                          │
-│ 2 │ rust_version       │ rustc 1.48.0                                                          │
-│ 3 │ cargo_version      │ cargo 1.48.0                                                          │
-│ 4 │ pkg_version        │ 0.24.1                                                                │
-│ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
-│ 6 │ build_rust_channel │ release                                                               │
-│ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, ptree, rich-benchmark, │
-│   │                    │ rustyline, term, uuid, which, zip                                     │
-╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
-```
-
-
-**Add any other context about the problem here.**

.github/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: 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` and paste the output to show OS, features, etc"
+      placeholder: |
+        > version | pivot
+        ╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
+        │ # │ Column0            │ Column1                                                               │
+        ├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
+        │ 0 │ version            │ 0.24.1                                                                │
+        │ 1 │ build_os           │ macos-x86_64                                                          │
+        │ 2 │ rust_version       │ rustc 1.48.0                                                          │
+        │ 3 │ cargo_version      │ cargo 1.48.0                                                          │
+        │ 4 │ pkg_version        │ 0.24.1                                                                │
+        │ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
+        │ 6 │ build_rust_channel │ release                                                               │
+        │ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, 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 }}

Cargo.toml

@@ -10,7 +10,7 @@ license = "MIT"
 name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.29.0"
+version = "0.35.0"
 
 [workspace]
 members = ["crates/*/"]
@@ -18,102 +18,85 @@ members = ["crates/*/"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-cli = { version = "0.29.0", path = "./crates/nu-cli", default-features = false }
-nu-command = { version = "0.29.0", path = "./crates/nu-command" }
-nu-data = { version = "0.29.0", path = "./crates/nu-data" }
-nu-engine = { version = "0.29.0", path = "./crates/nu-engine" }
-nu-errors = { version = "0.29.0", path = "./crates/nu-errors" }
-nu-parser = { version = "0.29.0", path = "./crates/nu-parser" }
-nu-plugin = { version = "0.29.0", path = "./crates/nu-plugin" }
-nu-protocol = { version = "0.29.0", path = "./crates/nu-protocol" }
-nu-source = { version = "0.29.0", path = "./crates/nu-source" }
-nu-value-ext = { version = "0.29.0", path = "./crates/nu-value-ext" }
+nu-cli = { version = "0.35.0", path="./crates/nu-cli", default-features=false }
+nu-command = { version = "0.35.0", path="./crates/nu-command" }
+nu-completion = { version = "0.35.0", path="./crates/nu-completion" }
+nu-data = { version = "0.35.0", path="./crates/nu-data" }
+nu-engine = { version = "0.35.0", path="./crates/nu-engine" }
+nu-errors = { version = "0.35.0", path="./crates/nu-errors" }
+nu-parser = { version = "0.35.0", path="./crates/nu-parser" }
+nu-path = { version = "0.35.0", path="./crates/nu-path" }
+nu-plugin = { version = "0.35.0", path="./crates/nu-plugin" }
+nu-protocol = { version = "0.35.0", path="./crates/nu-protocol" }
+nu-source = { version = "0.35.0", path="./crates/nu-source" }
+nu-value-ext = { version = "0.35.0", path="./crates/nu-value-ext" }
 
-nu_plugin_binaryview = { version = "0.29.0", path = "./crates/nu_plugin_binaryview", optional = true }
-nu_plugin_chart = { version = "0.29.0", path = "./crates/nu_plugin_chart", optional = true }
-nu_plugin_fetch = { version = "0.29.0", path = "./crates/nu_plugin_fetch", optional = true }
-nu_plugin_from_bson = { version = "0.29.0", path = "./crates/nu_plugin_from_bson", optional = true }
-nu_plugin_from_sqlite = { version = "0.29.0", path = "./crates/nu_plugin_from_sqlite", optional = true }
-nu_plugin_inc = { version = "0.29.0", path = "./crates/nu_plugin_inc", optional = true }
-nu_plugin_match = { version = "0.29.0", path = "./crates/nu_plugin_match", optional = true }
-nu_plugin_post = { version = "0.29.0", path = "./crates/nu_plugin_post", optional = true }
-nu_plugin_ps = { version = "0.29.0", path = "./crates/nu_plugin_ps", optional = true }
-nu_plugin_s3 = { version = "0.29.0", path = "./crates/nu_plugin_s3", optional = true }
-nu_plugin_selector = { version = "0.29.0", path = "./crates/nu_plugin_selector", optional = true }
-nu_plugin_start = { version = "0.29.0", path = "./crates/nu_plugin_start", optional = true }
-nu_plugin_sys = { version = "0.29.0", path = "./crates/nu_plugin_sys", optional = true }
-nu_plugin_textview = { version = "0.29.0", path = "./crates/nu_plugin_textview", optional = true }
-nu_plugin_to_bson = { version = "0.29.0", path = "./crates/nu_plugin_to_bson", optional = true }
-nu_plugin_to_sqlite = { version = "0.29.0", path = "./crates/nu_plugin_to_sqlite", optional = true }
-nu_plugin_tree = { version = "0.29.0", path = "./crates/nu_plugin_tree", optional = true }
-nu_plugin_xpath = { version = "0.29.0", path = "./crates/nu_plugin_xpath", optional = true }
+nu_plugin_binaryview = { version = "0.35.0", path="./crates/nu_plugin_binaryview", optional=true }
+nu_plugin_chart = { version = "0.35.0", path="./crates/nu_plugin_chart", optional=true }
+nu_plugin_fetch = { version = "0.35.0", path="./crates/nu_plugin_fetch", optional=true }
+nu_plugin_from_bson = { version = "0.35.0", path="./crates/nu_plugin_from_bson", optional=true }
+nu_plugin_from_sqlite = { version = "0.35.0", path="./crates/nu_plugin_from_sqlite", optional=true }
+nu_plugin_inc = { version = "0.35.0", path="./crates/nu_plugin_inc", optional=true }
+nu_plugin_match = { version = "0.35.0", path="./crates/nu_plugin_match", optional=true }
+nu_plugin_post = { version = "0.35.0", path="./crates/nu_plugin_post", optional=true }
+nu_plugin_ps = { version = "0.35.0", path="./crates/nu_plugin_ps", optional=true }
+nu_plugin_query_json = { version = "0.35.0", path="./crates/nu_plugin_query_json", optional=true }
+nu_plugin_s3 = { version = "0.35.0", path="./crates/nu_plugin_s3", optional=true }
+nu_plugin_selector = { version = "0.35.0", path="./crates/nu_plugin_selector", optional=true }
+nu_plugin_start = { version = "0.35.0", path="./crates/nu_plugin_start", optional=true }
+nu_plugin_sys = { version = "0.35.0", path="./crates/nu_plugin_sys", optional=true }
+nu_plugin_textview = { version = "0.35.0", path="./crates/nu_plugin_textview", optional=true }
+nu_plugin_to_bson = { version = "0.35.0", path="./crates/nu_plugin_to_bson", optional=true }
+nu_plugin_to_sqlite = { version = "0.35.0", path="./crates/nu_plugin_to_sqlite", optional=true }
+nu_plugin_tree = { version = "0.35.0", path="./crates/nu_plugin_tree", optional=true }
+nu_plugin_xpath = { version = "0.35.0", path="./crates/nu_plugin_xpath", optional=true }
 
 # Required to bootstrap the main binary
-clap = "2.33.3"
-ctrlc = { version = "3.1.7", optional = true }
-futures = { version = "0.3.12", features = ["compat", "io-compat"] }
+ctrlc = { version="3.1.7", optional=true }
+futures = { version="0.3.12", features=["compat", "io-compat"] }
 itertools = "0.10.0"
-log = "0.4.14"
-pretty_env_logger = "0.4.0"
 
 [dev-dependencies]
-nu-test-support = { version = "0.29.0", path = "./crates/nu-test-support" }
+nu-test-support = { version = "0.35.0", path="./crates/nu-test-support" }
 dunce = "1.0.1"
 serial_test = "0.5.1"
 hamcrest2 = "0.3.0"
-
+rstest = "0.10.0"
 
 [build-dependencies]
 
 [features]
 ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
-directories-support = [
-    "nu-cli/directories",
-    "nu-cli/dirs",
-    "nu-command/directories",
-    "nu-command/dirs",
-    "nu-data/directories",
-    "nu-data/dirs",
-    "nu-engine/dirs",
-]
-ptree-support = ["nu-cli/ptree", "nu-command/ptree"]
 rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
-term-support = ["nu-cli/term", "nu-command/term"]
-uuid-support = ["nu-cli/uuid_crate", "nu-command/uuid_crate"]
-which-support = [
-    "nu-cli/ichwh",
-    "nu-cli/which",
-    "nu-command/ichwh",
-    "nu-command/which",
-    "nu-engine/which",
-]
+term-support = ["nu-command/term"]
+uuid-support = ["nu-command/uuid_crate"]
+which-support = ["nu-command/which", "nu-engine/which"]
 
 default = [
     "nu-cli/shadow-rs",
     "sys",
     "ps",
-    "textview",
-    "inc",
-    "directories-support",
     "ctrlc-support",
     "which-support",
-    "ptree-support",
     "term-support",
-    "uuid-support",
     "rustyline-support",
     "match",
     "post",
     "fetch",
     "zip-support",
+    "dataframe",
 ]
 
 stable = ["default"]
 extra = [
     "default",
     "binaryview",
+    "inc",
     "tree",
+    "textview",
     "clipboard-cli",
     "trash-support",
+    "uuid-support",
     "start",
     "bson",
     "sqlite",
@@ -121,11 +104,10 @@ extra = [
     "chart",
     "xpath",
     "selector",
+    "query-json",
 ]
 
-wasi = ["inc", "match", "ptree-support", "match", "tree", "rustyline-support"]
-
-trace = ["nu-parser/trace"]
+wasi = ["inc", "match", "match", "tree", "rustyline-support"]
 
 # Stable (Default)
 fetch = ["nu_plugin_fetch"]
@@ -135,32 +117,38 @@ post = ["nu_plugin_post"]
 ps = ["nu_plugin_ps"]
 sys = ["nu_plugin_sys"]
 textview = ["nu_plugin_textview"]
-zip-support = ["nu-cli/zip", "nu-command/zip"]
 
 # Extra
 binaryview = ["nu_plugin_binaryview"]
 bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
 chart = ["nu_plugin_chart"]
-clipboard-cli = ["nu-cli/clipboard-cli", "nu-command/clipboard-cli"]
+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",
     "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"]
 
-[profile.release]
-#strip = "symbols" #Couldn't get working +nightly
-codegen-units = 1 #Reduce parallel codegen units
-lto = true #Link Time Optimization
-opt-level = 'z' #Optimize for size
+#dataframe feature for nushell
+dataframe = [
+    "nu-engine/dataframe",
+    "nu-protocol/dataframe",
+    "nu-command/dataframe",
+    "nu-value-ext/dataframe",
+    "nu-data/dataframe",
+    "nu_plugin_post/dataframe",
+    "nu_plugin_to_bson/dataframe",
+]
 
 # Core plugins that ship with `cargo install nu` by default
 # Currently, Cargo limits us to installing only one binary
@@ -212,6 +200,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"

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

@@ -47,7 +47,7 @@ Try it in Gitpod.
 
 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.47 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:
 
@@ -61,13 +61,19 @@ Optional dependencies:
 
 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
 ```
 
+To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
+
+```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:
 
-```bash
+```shell
 cargo build --workspace --features=extra
 ```
 
@@ -77,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
 ```
 
@@ -86,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
@@ -136,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 produce a stream (e.g., `ls`)
 -   Commands that filter a stream (eg, `where type == "Dir"`)
--   Commands that consume the output of the pipeline (eg, `autoview`)
+-   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.
 
@@ -171,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
@@ -188,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
@@ -220,7 +226,7 @@ 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.21.0
+ version       │ 0.32.0
 ───────────────┴────────────────────────────────────
 ```
 
@@ -228,11 +234,9 @@ Finally, we can use commands outside of Nu once we have the data we want:
 
 ```shell
 > open Cargo.toml | get package.version
-0.21.0
+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/configuration.html).
@@ -247,9 +251,9 @@ To set one of these variables, you can use `config set`. For example:
 ### 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.
 
@@ -263,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.
 
@@ -271,7 +275,7 @@ 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.
 
@@ -287,28 +291,28 @@ You can find a list of Nu commands, complete with documentation, in [quick comma
 
 ## 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                  |
+| 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, but no session-wide env variables             |
+| 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 and related are barebones and lack task-based lessons           |
+| Documentation |             |           |  X  |         |        | Book updated to latest release, including usage examples             |
 | 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           |
+| 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
 
-We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release as well as capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
+We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release and capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
 
 ## Contributing
 

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/Cargo.toml

@@ -9,7 +9,7 @@ description = "Library for ANSI terminal colors and styles (bold, underline)"
 edition = "2018"
 license = "MIT"
 name = "nu-ansi-term"
-version = "0.29.0"
+version = "0.35.0"
 
 [lib]
 doctest = false
@@ -18,10 +18,15 @@ doctest = false
 [features]
 derive_serde_style = ["serde"]
 
-[dependencies.serde]
-version = "1.0.90"
-features = ["derive"]
-optional = true
+[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"

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/src/ansi.rs

@@ -1,3 +1,4 @@
+#![allow(missing_docs)]
 use crate::style::{Color, Style};
 use crate::write::AnyWrite;
 use std::fmt;
@@ -319,7 +320,7 @@ impl fmt::Display for Infix {
                 let f: &mut dyn fmt::Write = f;
                 write!(f, "{}{}", RESET, self.1.prefix())
             }
-            Difference::NoDifference => {
+            Difference::Empty => {
                 Ok(()) // nothing to write
             }
         }

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

@@ -14,7 +14,7 @@ pub enum Difference {
 
     /// The before style is exactly the same as the after style, so no further
     /// control codes need to be printed.
-    NoDifference,
+    Empty,
 }
 
 impl Difference {
@@ -40,7 +40,7 @@ impl Difference {
         // it commented out for now, and defaulting to Reset.
 
         if first == next {
-            return NoDifference;
+            return Empty;
         }
 
         // Cannot un-bold, so must Reset.
@@ -153,10 +153,10 @@ mod test {
         };
     }
 
-    test!(nothing:    Green.normal(); Green.normal()  => NoDifference);
+    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()    => NoDifference);
+    test!(nothing2:   Green.bold();   Green.bold()    => Empty);
 
     test!(color_change: Red.normal(); Blue.normal() => ExtraStyles(Blue.normal()));
 

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

@@ -266,7 +266,7 @@ where
             match Difference::between(&window[0].style, &window[1].style) {
                 ExtraStyles(style) => write!(w, "{}", style.prefix())?,
                 Reset => write!(w, "{}{}", RESET, window[1].style.prefix())?,
-                NoDifference => { /* Do nothing! */ }
+                Empty => { /* Do nothing! */ }
             }
 
             w.write_str(&window[1].string)?;

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

@@ -121,13 +121,13 @@
 //! `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,
+//! 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;
+//! use nu_ansi_term::Color::Rgb;
 //!
-//! RGB(70, 130, 180).paint("Steel blue");
+//! Rgb(70, 130, 180).paint("Steel blue");
 //! ```
 //!
 //! ## Combining successive colored strings
@@ -233,7 +233,7 @@
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![warn(missing_copy_implementations)]
-#![warn(missing_docs)]
+// #![warn(missing_docs)]
 #![warn(trivial_casts, trivial_numeric_casts)]
 // #![warn(unused_extern_crates, unused_qualifications)]
 
@@ -246,7 +246,7 @@ extern crate doc_comment;
 #[cfg(test)]
 doctest!("../README.md");
 
-mod ansi;
+pub mod ansi;
 pub use ansi::{Infix, Prefix, Suffix};
 
 mod style;
@@ -265,3 +265,9 @@ 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

@@ -364,10 +364,16 @@ pub enum Color {
     /// [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.
+    /// 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.
     ///
@@ -546,7 +552,7 @@ impl Color {
     /// ```
     /// use nu_ansi_term::Color;
     ///
-    /// let style = Color::RGB(31, 31, 31).on(Color::White);
+    /// let style = Color::Rgb(31, 31, 31).on(Color::White);
     /// println!("{}", style.paint("eyyyy"));
     /// ```
     pub fn on(self, background: Color) -> Style {
@@ -584,13 +590,13 @@ mod serde_json_tests {
         let colors = &[
             Color::Red,
             Color::Blue,
-            Color::RGB(123, 123, 123),
+            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}]")
+            String::from("[\"Red\",\"Blue\",{\"Rgb\":[123,123,123]},{\"Fixed\":255}]")
         );
     }
 
@@ -599,11 +605,11 @@ mod serde_json_tests {
         let colors = &[
             Color::Red,
             Color::Blue,
-            Color::RGB(123, 123, 123),
+            Color::Rgb(123, 123, 123),
             Color::Fixed(255),
         ];
 
-        for color in colors.into_iter() {
+        for color in colors.iter() {
             let serialized = serde_json::to_string(&color).unwrap();
             let deserialized: Color = serde_json::from_str(&serialized).unwrap();
 

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

@@ -43,7 +43,7 @@ pub fn unstyle(strs: &AnsiStrings) -> String {
     let mut s = String::new();
 
     for i in strs.0.iter() {
-        s += &i.deref();
+        s += i.deref();
     }
 
     s

crates/nu-cli/Cargo.toml

@@ -1,135 +1,42 @@
 [package]
 authors = ["The Nu Project Contributors"]
-build = "build.rs"
 description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-cli"
-version = "0.29.0"
+version = "0.35.0"
+build = "build.rs"
 
 [lib]
 doctest = false
 
 [dependencies]
-nu-command = { version = "0.29.0", path = "../nu-command" }
-nu-data = { version = "0.29.0", path = "../nu-data" }
-nu-engine = { version = "0.29.0", path = "../nu-engine" }
-nu-errors = { version = "0.29.0", path = "../nu-errors" }
-nu-json = { version = "0.29.0", path = "../nu-json" }
-nu-parser = { version = "0.29.0", path = "../nu-parser" }
-nu-plugin = { version = "0.29.0", path = "../nu-plugin" }
-nu-protocol = { version = "0.29.0", path = "../nu-protocol" }
-nu-source = { version = "0.29.0", path = "../nu-source" }
-nu-stream = { version = "0.29.0", path = "../nu-stream" }
-nu-table = { version = "0.29.0", path = "../nu-table" }
-nu-test-support = { version = "0.29.0", path = "../nu-test-support" }
-nu-value-ext = { version = "0.29.0", path = "../nu-value-ext" }
-nu-ansi-term = { version = "0.29.0", path = "../nu-ansi-term" }
+nu-completion = { version = "0.35.0", path="../nu-completion" }
+nu-command = { version = "0.35.0", path="../nu-command" }
+nu-data = { version = "0.35.0", path="../nu-data" }
+nu-engine = { version = "0.35.0", path="../nu-engine" }
+nu-errors = { version = "0.35.0", path="../nu-errors" }
+nu-parser = { version = "0.35.0", path="../nu-parser" }
+nu-protocol = { version = "0.35.0", path="../nu-protocol" }
+nu-source = { version = "0.35.0", path="../nu-source" }
+nu-stream = { version = "0.35.0", path="../nu-stream" }
+nu-ansi-term = { version = "0.35.0", path="../nu-ansi-term" }
 
-Inflector = "0.11"
-arboard = { version = "1.1.0", optional = true }
-async-recursion = "0.3.2"
-async-trait = "0.1.42"
-base64 = "0.13.0"
-bigdecimal = { version = "0.2.0", features = ["serde"] }
-byte-unit = "4.0.9"
-bytes = "1.0.1"
-calamine = "0.17.0"
-chrono = { version = "0.4.19", features = ["serde"] }
-chrono-tz = "0.5.3"
-clap = "2.33.3"
-codespan-reporting = "0.11.0"
-csv = "1.1.5"
-ctrlc = { version = "3.1.7", optional = true }
-derive-new = "0.5.8"
-directories-next = { version = "2.0.0", optional = true }
-dirs-next = { version = "2.0.0", optional = true }
-dtparse = "1.2.0"
-dunce = "1.0.1"
-eml-parser = "0.1.0"
-encoding_rs = "0.8.28"
-filesize = "0.2.0"
-fs_extra = "1.2.0"
-futures = { version = "0.3.12", features = ["compat", "io-compat"] }
-futures-util = "0.3.12"
-futures_codec = "0.4.1"
-getset = "0.1.1"
-glob = "0.3.0"
-htmlescape = "0.3.1"
-ical = "0.7.0"
-ichwh = { version = "0.3.4", optional = true }
-indexmap = { version = "1.6.1", features = ["serde-1"] }
-itertools = "0.10.0"
-lazy_static = "1.*"
+indexmap ="1.6.1"
 log = "0.4.14"
-meval = "0.2.0"
-num-bigint = { version = "0.3.1", features = ["serde"] }
-num-format = { version = "0.4.0", features = ["with-num-bigint"] }
-num-traits = "0.2.14"
-parking_lot = "0.11.1"
-pin-utils = "0.1.0"
-pretty-hex = "0.2.1"
-ptree = { version = "0.3.1", optional = true }
-query_interface = "0.3.5"
-quick-xml = "0.21.0"
-rand = "0.8.3"
-rayon = "1.5.0"
-regex = "1.4.3"
-roxmltree = "0.14.0"
-rust-embed = "5.9.0"
-rustyline = { version = "8.0.0", optional = true }
-serde = { version = "1.0.123", features = ["derive"] }
-serde_bytes = "0.11.5"
-serde_ini = "0.2.0"
-serde_json = "1.0.61"
-serde_urlencoded = "0.7.0"
-serde_yaml = "0.8.16"
-sha2 = "0.9.3"
-shellexpand = "2.1.0"
+pretty_env_logger = "0.4.0"
 strip-ansi-escapes = "0.1.0"
-sxd-document = "0.3.2"
-sxd-xpath = "0.4.2"
-tempfile = "3.2.0"
-term = { version = "0.7.0", optional = true }
-term_size = "0.3.2"
-termcolor = "1.1.2"
-titlecase = "1.1.0"
-toml = "0.5.8"
-trash = { version = "1.3.0", optional = true }
-unicode-segmentation = "1.7.1"
-url = "2.1.1"
-uuid_crate = { package = "uuid", version = "0.8.2", features = ["v4"], optional = true }
-which = { version = "4.0.2", optional = true }
-zip = { version = "0.5.9", optional = true }
-shadow-rs = { version = "0.5", default-features = false, optional = true }
-
-[target.'cfg(unix)'.dependencies]
-umask = "1.0.0"
-users = "0.11.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.2"
+rustyline = { version="8.1.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]
-shadow-rs = "0.5"
-
-[dev-dependencies]
-quickcheck = "1.0.3"
-quickcheck_macros = "1.0.0"
+shadow-rs = "0.6"
 
 [features]
 default = ["shadow-rs"]
-clipboard-cli = ["arboard"]
 rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
 stable = []
-trash-support = ["trash"]
-dirs = ["dirs-next"]
-directories = ["directories-next"]

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/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).map(Clone::clone)
+    }
+
+    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,143 @@
+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) {
+                                                Some(v)
+                                            } else {
+                                                Some(
+                                                    UntaggedValue::Error(
+                                                        ShellError::untagged_runtime_error(
+                                                            format!("{} is not supported.", name),
+                                                        ),
+                                                    )
+                                                    .into_value(v.tag),
+                                                )
+                                            }
+                                        } else {
+                                            Some(v)
+                                        }
+                                    }
+                                    "loglevel" => {
+                                        if let Ok(name) = v.as_string() {
+                                            if loglevels().iter().any(|n| name == *n) {
+                                                Some(v)
+                                            } else {
+                                                Some(
+                                                    UntaggedValue::Error(
+                                                        ShellError::untagged_runtime_error(
+                                                            format!("{} is not supported.", name),
+                                                        ),
+                                                    )
+                                                    .into_value(v.tag),
+                                                )
+                                            }
+                                        } else {
+                                            Some(v)
+                                        }
+                                    }
+                                    _ => Some(v),
+                                })
+                                .flatten();
+
+                        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/cli.rs

@@ -1,6 +1,7 @@
+use crate::app::STOPWATCH;
 use crate::line_editor::configure_ctrl_c;
-use nu_command::commands::default_context::create_default_context;
-use nu_engine::{evaluation_context, run_block, script::run_script_standalone, EvaluationContext};
+use nu_ansi_term::Color;
+use nu_engine::{maybe_print_errors, run_block, script::run_script_standalone, EvaluationContext};
 
 #[allow(unused_imports)]
 pub(crate) use nu_engine::script::{process_script, LineResult};
@@ -13,101 +14,23 @@ use crate::line_editor::{
 
 #[allow(unused_imports)]
 use nu_data::config;
-use nu_data::config::{Conf, NuConfig};
-use nu_source::{AnchorLocation, Tag, Text};
+use nu_source::{Tag, Text};
 use nu_stream::InputStream;
-use std::ffi::{OsStr, OsString};
 #[allow(unused_imports)]
 use std::sync::atomic::Ordering;
 
 #[cfg(feature = "rustyline-support")]
 use rustyline::{self, error::ReadlineError};
 
-use crate::EnvironmentSyncer;
 use nu_errors::ShellError;
 use nu_parser::ParserScope;
-use nu_protocol::{hir::ExternalRedirection, UntaggedValue, Value};
+use nu_protocol::{hir::ExternalRedirection, ConfigPath, UntaggedValue, Value};
 
 use log::trace;
 use std::error::Error;
 use std::iter::Iterator;
 use std::path::PathBuf;
 
-pub struct Options {
-    pub config: Option<OsString>,
-    pub history: Option<PathBuf>,
-    pub save_history: bool,
-    pub stdin: bool,
-    pub scripts: Vec<NuScript>,
-}
-
-impl Default for Options {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Options {
-    pub fn new() -> Self {
-        Self {
-            config: None,
-            history: None,
-            save_history: true,
-            stdin: false,
-            scripts: vec![],
-        }
-    }
-
-    pub fn history(&self, block: impl FnOnce(&std::path::Path)) {
-        if !self.save_history {
-            return;
-        }
-
-        if let Some(file) = &self.history {
-            block(&file)
-        }
-    }
-}
-
-pub struct NuScript {
-    pub filepath: Option<OsString>,
-    pub contents: String,
-}
-
-impl NuScript {
-    pub fn code<'a>(content: impl Iterator<Item = &'a str>) -> Result<Self, ShellError> {
-        let text = content
-            .map(|x| x.to_string())
-            .collect::<Vec<String>>()
-            .join("\n");
-
-        Ok(Self {
-            filepath: None,
-            contents: text,
-        })
-    }
-
-    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,
-        })
-    }
-}
-
 pub fn search_paths() -> Vec<std::path::PathBuf> {
     use std::env;
 
@@ -137,134 +60,149 @@ pub fn search_paths() -> Vec<std::path::PathBuf> {
     search_paths
 }
 
-pub async fn run_script_file(mut options: Options) -> Result<(), Box<dyn Error>> {
-    let mut context = create_default_context(false)?;
-    let mut syncer = create_environment_syncer(&context, &mut options);
-    let config = syncer.get_config();
+pub fn run_script_file(
+    context: EvaluationContext,
+    options: super::app::CliOptions,
+) -> Result<(), ShellError> {
+    if let Some(cfg) = options.config {
+        load_cfg_as_global_cfg(&context, PathBuf::from(cfg));
+    } else {
+        load_global_cfg(&context);
+    }
 
-    context.configure(&config, |_, ctx| {
-        syncer.load_environment();
-        syncer.sync_env_vars(ctx);
-        syncer.sync_path_vars(ctx);
-
-        if let Err(reason) = syncer.autoenv(ctx) {
-            ctx.with_host(|host| host.print_err(reason, &Text::from("")));
-        }
-
-        let _ = register_plugins(ctx);
-        let _ = configure_ctrl_c(ctx);
-    });
-
-    let _ = run_startup_commands(&mut context, &config).await;
+    let _ = register_plugins(&context);
+    let _ = configure_ctrl_c(&context);
 
     let script = options
         .scripts
         .get(0)
         .ok_or_else(|| ShellError::unexpected("Nu source code not available"))?;
 
-    run_script_standalone(script.get_code().to_string(), options.stdin, &context, true).await?;
+    run_script_standalone(script.get_code().to_string(), options.stdin, &context, true)?;
 
     Ok(())
 }
 
-fn create_environment_syncer(
-    context: &EvaluationContext,
-    options: &mut Options,
-) -> EnvironmentSyncer {
-    let configuration = match &options.config {
-        Some(config_file) => {
-            let location = Some(AnchorLocation::File(
-                config_file.to_string_lossy().to_string(),
-            ));
-
-            let tag = Tag::unknown().anchored(location);
-
-            context.scope.add_var(
-                "config-path",
-                UntaggedValue::filepath(PathBuf::from(&config_file)).into_value(tag),
-            );
-
-            NuConfig::with(Some(config_file.into()))
-        }
-        None => NuConfig::new(),
-    };
-
-    let history_path = configuration.history_path();
-    options.history = Some(history_path.clone());
-
-    let location = Some(AnchorLocation::File(
-        history_path.to_string_lossy().to_string(),
-    ));
-
-    let tag = Tag::unknown().anchored(location);
-
-    context.scope.add_var(
-        "history-path",
-        UntaggedValue::filepath(history_path).into_value(tag),
-    );
-
-    EnvironmentSyncer::with_config(Box::new(configuration))
-}
-
 #[cfg(feature = "rustyline-support")]
-pub async fn cli(
-    mut context: EvaluationContext,
-    mut options: Options,
+pub fn cli(
+    context: EvaluationContext,
+    options: super::app::CliOptions,
 ) -> Result<(), Box<dyn Error>> {
-    let mut syncer = create_environment_syncer(&context, &mut options);
+    let _ = configure_ctrl_c(&context);
 
-    let configuration = syncer.get_config();
-
-    let mut rl = default_rustyline_editor_configuration();
-
-    context.configure(&configuration, |config, ctx| {
-        syncer.load_environment();
-        syncer.sync_env_vars(ctx);
-        syncer.sync_path_vars(ctx);
-
-        if let Err(reason) = syncer.autoenv(ctx) {
-            ctx.with_host(|host| host.print_err(reason, &Text::from("")));
-        }
-
-        let _ = configure_ctrl_c(ctx);
-        let _ = configure_rustyline_editor(&mut rl, config);
-
-        let helper = Some(nu_line_editor_helper(ctx, config));
-        rl.set_helper(helper);
-    });
-
-    // start time for command duration
+    // start time for running startup scripts (this metric includes loading of the cfg, but w/e)
     let startup_commands_start_time = std::time::Instant::now();
-    // run the startup commands
-    let _ = run_startup_commands(&mut context, &configuration).await;
+
+    if let Some(cfg) = options.config {
+        load_cfg_as_global_cfg(&context, PathBuf::from(cfg));
+    } else {
+        load_global_cfg(&context);
+    }
+
     // Store cmd duration in an env var
     context.scope.add_env_var(
-        "CMD_DURATION",
-        format!("{:?}", startup_commands_start_time.elapsed()),
-    );
-    trace!(
-        "startup commands took {:?}",
-        startup_commands_start_time.elapsed()
+        "CMD_DURATION_MS",
+        format!("{}", startup_commands_start_time.elapsed().as_millis()),
     );
 
+    if options.perf {
+        eprintln!(
+            "config loaded: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    //Configure rustyline
+    let mut rl = default_rustyline_editor_configuration();
+    let history_path = if let Some(cfg) = &context.configs().lock().global_config {
+        let _ = configure_rustyline_editor(&mut rl, cfg);
+        let helper = Some(nu_line_editor_helper(&context, cfg));
+        rl.set_helper(helper);
+        nu_data::config::path::history_path_or_default(cfg)
+    } else {
+        nu_data::config::path::default_history_path()
+    };
+
+    if options.perf {
+        eprintln!(
+            "rustyline configuration: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    // Don't load history if it's not necessary
+    if options.save_history {
+        let _ = rl.load_history(&history_path);
+    }
+
+    if options.perf {
+        eprintln!(
+            "history load: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    //set vars from cfg if present
+    let (skip_welcome_message, prompt) = if let Some(cfg) = &context.configs().lock().global_config
+    {
+        (
+            cfg.var("skip_welcome_message")
+                .map(|x| x.is_true())
+                .unwrap_or(false),
+            cfg.var("prompt"),
+        )
+    } else {
+        (false, None)
+    };
+
+    if options.perf {
+        eprintln!(
+            "load custom prompt: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .start();
+    }
+
+    //Check whether dir we start in contains local cfg file and if so load it.
+    load_local_cfg_if_present(&context);
+
     // Give ourselves a scope to work in
     context.scope.enter_scope();
 
-    options.history(|file| {
-        let _ = rl.load_history(&file);
-    });
-
     let mut session_text = String::new();
     let mut line_start: usize = 0;
 
-    let skip_welcome_message = configuration
-        .var("skip_welcome_message")
-        .map(|x| x.is_true())
-        .unwrap_or(false);
     if !skip_welcome_message {
         println!(
             "Welcome to Nushell {} (type 'help' for more info)",
-            clap::crate_version!()
+            nu_command::commands::core_version()
         );
     }
 
@@ -275,40 +213,61 @@ pub async fn cli(
 
     let mut ctrlcbreak = false;
 
+    if options.perf {
+        eprintln!(
+            "timing stopped. starting run loop: {:?}",
+            STOPWATCH
+                .lock()
+                .expect("unable to lock the stopwatch")
+                .elapsed_split()
+        );
+        STOPWATCH
+            .lock()
+            .expect("unable to lock the stopwatch")
+            .stop();
+    }
+
     loop {
-        if context.ctrl_c.load(Ordering::SeqCst) {
-            context.ctrl_c.store(false, Ordering::SeqCst);
+        if context.ctrl_c().load(Ordering::SeqCst) {
+            context.ctrl_c().store(false, Ordering::SeqCst);
             continue;
         }
 
-        let cwd = context.shell_manager.path();
+        let cwd = context.shell_manager().path();
 
         let colored_prompt = {
-            if let Some(prompt) = configuration.var("prompt") {
+            if let Some(prompt) = &prompt {
                 let prompt_line = prompt.as_string()?;
 
                 context.scope.enter_scope();
-
-                let (mut prompt_block, err) = nu_parser::parse(&prompt_line, 0, &context.scope);
-
-                prompt_block.set_redirect(ExternalRedirection::Stdout);
+                let (prompt_block, err) = nu_parser::parse(&prompt_line, 0, &context.scope);
 
                 if err.is_some() {
                     context.scope.exit_scope();
 
-                    format!("\x1b[32m{}{}\x1b[m> ", cwd, current_branch())
+                    format!(
+                        "{}{}{}{}{}{}> ",
+                        Color::Green.bold().prefix().to_string(),
+                        cwd,
+                        nu_ansi_term::ansi::RESET,
+                        Color::Cyan.bold().prefix().to_string(),
+                        current_branch(),
+                        nu_ansi_term::ansi::RESET
+                    )
                 } else {
-                    let run_result = run_block(&prompt_block, &context, InputStream::empty()).await;
+                    let run_result = run_block(
+                        &prompt_block,
+                        &context,
+                        InputStream::empty(),
+                        ExternalRedirection::Stdout,
+                    );
                     context.scope.exit_scope();
 
                     match run_result {
-                        Ok(result) => match result.collect_string(Tag::unknown()).await {
+                        Ok(result) => match result.collect_string(Tag::unknown()) {
                             Ok(string_result) => {
                                 let errors = context.get_errors();
-                                evaluation_context::maybe_print_errors(
-                                    &context,
-                                    Text::from(prompt_line),
-                                );
+                                maybe_print_errors(&context, Text::from(prompt_line));
                                 context.clear_errors();
 
                                 if !errors.is_empty() {
@@ -318,14 +277,14 @@ pub async fn cli(
                                 }
                             }
                             Err(e) => {
-                                context.host.lock().print_err(e, &Text::from(prompt_line));
+                                context.host().lock().print_err(e, &Text::from(prompt_line));
                                 context.clear_errors();
 
                                 "> ".to_string()
                             }
                         },
                         Err(e) => {
-                            context.host.lock().print_err(e, &Text::from(prompt_line));
+                            context.host().lock().print_err(e, &Text::from(prompt_line));
                             context.clear_errors();
 
                             "> ".to_string()
@@ -333,7 +292,15 @@ pub async fn cli(
                     }
                 }
             } else {
-                format!("\x1b[32m{}{}\x1b[m> ", cwd, current_branch())
+                format!(
+                    "{}{}{}{}{}{}> ",
+                    Color::Green.bold().prefix().to_string(),
+                    cwd,
+                    nu_ansi_term::ansi::RESET,
+                    Color::Cyan.bold().prefix().to_string(),
+                    current_branch(),
+                    nu_ansi_term::ansi::RESET
+                )
             }
         };
 
@@ -345,11 +312,13 @@ pub async fn cli(
             }
         };
 
-        rl.helper_mut().expect("No helper").colored_prompt = colored_prompt;
+        if let Some(helper) = rl.helper_mut() {
+            helper.colored_prompt = colored_prompt;
+        }
         let mut initial_command = Some(String::new());
         let mut readline = Err(ReadlineError::Eof);
         while let Some(ref cmd) = initial_command {
-            readline = rl.readline_with_initial(&prompt, (&cmd, ""));
+            readline = rl.readline_with_initial(&prompt, (cmd, ""));
             initial_command = None;
         }
 
@@ -363,72 +332,66 @@ pub async fn cli(
         let cmd_start_time = std::time::Instant::now();
 
         let line = match convert_rustyline_result_to_string(readline) {
-            LineResult::Success(_) => {
-                process_script(
-                    &session_text[line_start..],
-                    &context,
-                    false,
-                    line_start,
-                    true,
-                )
-                .await
-            }
+            LineResult::Success(_) => process_script(
+                &session_text[line_start..],
+                &context,
+                false,
+                line_start,
+                true,
+            ),
             x => x,
         };
 
         // Store cmd duration in an env var
-        context
-            .scope
-            .add_env_var("CMD_DURATION", format!("{:?}", cmd_start_time.elapsed()));
-
-        // Check the config to see if we need to update the path
-        // TODO: make sure config is cached so we don't path this load every call
-        // FIXME: we probably want to be a bit more graceful if we can't set the environment
-
-        context.configure(&configuration, |config, ctx| {
-            if syncer.did_config_change() {
-                syncer.reload();
-                syncer.sync_env_vars(ctx);
-                syncer.sync_path_vars(ctx);
-            }
-
-            if let Err(reason) = syncer.autoenv(ctx) {
-                ctx.with_host(|host| host.print_err(reason, &Text::from("")));
-            }
-
-            let _ = configure_rustyline_editor(&mut rl, config);
-        });
+        context.scope.add_env_var(
+            "CMD_DURATION_MS",
+            format!("{}", cmd_start_time.elapsed().as_millis()),
+        );
 
         match line {
             LineResult::Success(line) => {
-                options.history(|file| {
+                if options.save_history && !line.trim().is_empty() {
                     rl.add_history_entry(&line);
-                    let _ = rl.save_history(&file);
-                });
-
-                evaluation_context::maybe_print_errors(&context, Text::from(session_text.clone()));
+                    let _ = rl.append_history(&history_path);
+                }
+                maybe_print_errors(&context, Text::from(session_text.clone()));
             }
 
             LineResult::ClearHistory => {
-                options.history(|file| {
+                if options.save_history {
                     rl.clear_history();
-                    let _ = rl.save_history(&file);
-                });
+                    let _ = rl.append_history(&history_path);
+                }
             }
 
-            LineResult::Error(line, reason) => {
-                options.history(|file| {
+            LineResult::Error(line, err) => {
+                if options.save_history && !line.trim().is_empty() {
                     rl.add_history_entry(&line);
-                    let _ = rl.save_history(&file);
-                });
+                    let _ = rl.append_history(&history_path);
+                }
 
-                context.with_host(|host| host.print_err(reason, &Text::from(session_text.clone())));
+                context
+                    .host()
+                    .lock()
+                    .print_err(err, &Text::from(session_text.clone()));
+
+                // I am not so sure, we don't need maybe_print_errors here (as we printed an err
+                // above), because maybe_print_errors also clears the errors.
+                // TODO Analyze where above err comes from, and whether we need to clear
+                // context.errors here
+                // Or just be consistent and return errors always in context.errors...
+                maybe_print_errors(&context, Text::from(session_text.clone()));
             }
 
             LineResult::CtrlC => {
-                let config_ctrlc_exit = configuration
-                    .var("ctrlc_exit")
-                    .map(|s| s.value.is_true())
+                let config_ctrlc_exit = context
+                    .configs()
+                    .lock()
+                    .global_config
+                    .as_ref()
+                    .map(|cfg| cfg.var("ctrlc_exit"))
+                    .flatten()
+                    .map(|ctrl_c| ctrl_c.is_true())
                     .unwrap_or(false); // default behavior is to allow CTRL-C spamming similar to other shells
 
                 if !config_ctrlc_exit {
@@ -436,10 +399,9 @@ pub async fn cli(
                 }
 
                 if ctrlcbreak {
-                    options.history(|file| {
-                        let _ = rl.save_history(&file);
-                    });
-
+                    if options.save_history {
+                        let _ = rl.append_history(&history_path);
+                    }
                     std::process::exit(0);
                 } else {
                     context.with_host(|host| host.stdout("CTRL-C pressed (again to quit)"));
@@ -449,8 +411,8 @@ pub async fn cli(
             }
 
             LineResult::CtrlD => {
-                context.shell_manager.remove_at_current();
-                if context.shell_manager.is_empty() {
+                context.shell_manager().remove_at_current();
+                if context.shell_manager().is_empty() {
                     break;
                 }
             }
@@ -463,14 +425,49 @@ pub async fn cli(
     }
 
     // we are ok if we can not save history
-    options.history(|file| {
-        let _ = rl.save_history(&file);
-    });
+    if options.save_history {
+        let _ = rl.append_history(&history_path);
+    }
 
     Ok(())
 }
 
-pub fn register_plugins(context: &mut EvaluationContext) -> Result<(), ShellError> {
+pub fn load_local_cfg_if_present(context: &EvaluationContext) {
+    trace!("Loading local cfg if present");
+    match config::loadable_cfg_exists_in_dir(PathBuf::from(context.shell_manager().path())) {
+        Ok(Some(cfg_path)) => {
+            if let Err(err) = context.load_config(&ConfigPath::Local(cfg_path)) {
+                context.host().lock().print_err(err, &Text::from(""))
+            }
+        }
+        Err(e) => {
+            //Report error while checking for local cfg file
+            context.host().lock().print_err(e, &Text::from(""))
+        }
+        Ok(None) => {
+            //No local cfg file present in start dir
+        }
+    }
+}
+
+fn load_cfg_as_global_cfg(context: &EvaluationContext, path: PathBuf) {
+    if let Err(err) = context.load_config(&ConfigPath::Global(path)) {
+        context.host().lock().print_err(err, &Text::from(""));
+    }
+}
+
+pub fn load_global_cfg(context: &EvaluationContext) {
+    match config::default_path() {
+        Ok(path) => {
+            load_cfg_as_global_cfg(context, path);
+        }
+        Err(e) => {
+            context.host().lock().print_err(e, &Text::from(""));
+        }
+    }
+}
+
+pub fn register_plugins(context: &EvaluationContext) -> Result<(), ShellError> {
     if let Ok(plugins) = nu_engine::plugin::build_plugin::scan(search_paths()) {
         context.add_commands(
             plugins
@@ -483,35 +480,7 @@ pub fn register_plugins(context: &mut EvaluationContext) -> Result<(), ShellErro
     Ok(())
 }
 
-async fn run_startup_commands(
-    context: &mut EvaluationContext,
-    config: &dyn nu_data::config::Conf,
-) -> Result<(), ShellError> {
-    if let Some(commands) = config.var("startup") {
-        match commands {
-            Value {
-                value: UntaggedValue::Table(pipelines),
-                ..
-            } => {
-                let mut script_file = String::new();
-                for pipeline in pipelines {
-                    script_file.push_str(&pipeline.as_string()?);
-                    script_file.push('\n');
-                }
-                let _ = run_script_standalone(script_file, false, context, false).await;
-            }
-            _ => {
-                return Err(ShellError::untagged_runtime_error(
-                    "expected a table of pipeline strings as startup commands",
-                ));
-            }
-        }
-    }
-
-    Ok(())
-}
-
-pub async fn parse_and_eval(line: &str, ctx: &EvaluationContext) -> Result<String, ShellError> {
+pub fn parse_and_eval(line: &str, ctx: &EvaluationContext) -> Result<String, ShellError> {
     // FIXME: do we still need this?
     let line = if let Some(s) = line.strip_suffix('\n') {
         s
@@ -521,20 +490,23 @@ pub async fn parse_and_eval(line: &str, ctx: &EvaluationContext) -> Result<Strin
 
     // TODO ensure the command whose examples we're testing is actually in the pipeline
     ctx.scope.enter_scope();
-    let (classified_block, err) = nu_parser::parse(&line, 0, &ctx.scope);
+    let (classified_block, err) = nu_parser::parse(line, 0, &ctx.scope);
     if let Some(err) = err {
         ctx.scope.exit_scope();
         return Err(err.into());
     }
 
     let input_stream = InputStream::empty();
-    let env = ctx.get_env();
-    ctx.scope.add_env(env);
 
-    let result = run_block(&classified_block, ctx, input_stream).await;
+    let result = run_block(
+        &classified_block,
+        ctx,
+        input_stream,
+        ExternalRedirection::Stdout,
+    );
     ctx.scope.exit_scope();
 
-    result?.collect_string(Tag::unknown()).await.map(|x| x.item)
+    result?.collect_string(Tag::unknown()).map(|x| x.item)
 }
 
 #[allow(dead_code)]
@@ -552,19 +524,3 @@ fn current_branch() -> String {
         "".to_string()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use nu_engine::EvaluationContext;
-
-    #[quickcheck]
-    fn quickcheck_parse(data: String) -> bool {
-        let (tokens, err) = nu_parser::lex(&data, 0);
-        let (lite_block, err2) = nu_parser::parse_block(tokens);
-        if err.is_none() && err2.is_none() {
-            let context = EvaluationContext::basic().unwrap();
-            let _ = nu_parser::classify_block(&lite_block, &context.scope);
-        }
-        true
-    }
-}

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

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

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

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

crates/nu-cli/src/env.rs

@@ -1,3 +0,0 @@
-pub(crate) mod directory_specific_environment;
-pub(crate) mod environment;
-pub(crate) mod environment_syncer;

crates/nu-cli/src/env/directory_specific_environment.rs

@@ -1,259 +0,0 @@
-use indexmap::{IndexMap, IndexSet};
-use nu_command::commands::autoenv;
-use nu_errors::ShellError;
-use serde::Deserialize;
-use std::env::*;
-use std::process::Command;
-
-use std::{
-    ffi::OsString,
-    fmt::Debug,
-    path::{Path, PathBuf},
-};
-
-//Tests reside in /nushell/tests/shell/pipeline/commands/internal.rs
-
-type EnvKey = String;
-type EnvVal = OsString;
-#[derive(Debug, Default)]
-pub struct DirectorySpecificEnvironment {
-    pub last_seen_directory: PathBuf,
-    //If an environment var has been added from a .nu in a directory, we track it here so we can remove it when the user leaves the directory.
-    //If setting the var overwrote some value, we save the old value in an option so we can restore it later.
-    added_vars: IndexMap<PathBuf, IndexMap<EnvKey, Option<EnvVal>>>,
-
-    //We track directories that we have read .nu-env from. This is different from the keys in added_vars since sometimes a file only wants to run scripts.
-    visited_dirs: IndexSet<PathBuf>,
-    exitscripts: IndexMap<PathBuf, Vec<String>>,
-}
-
-#[derive(Deserialize, Debug, Default)]
-pub struct NuEnvDoc {
-    pub env: Option<IndexMap<String, String>>,
-    pub scriptvars: Option<IndexMap<String, String>>,
-    pub scripts: Option<IndexMap<String, Vec<String>>>,
-    pub entryscripts: Option<Vec<String>>,
-    pub exitscripts: Option<Vec<String>>,
-}
-
-impl DirectorySpecificEnvironment {
-    pub fn new() -> DirectorySpecificEnvironment {
-        let root_dir = if cfg!(target_os = "windows") {
-            PathBuf::from("c:\\")
-        } else {
-            PathBuf::from("/")
-        };
-        DirectorySpecificEnvironment {
-            last_seen_directory: root_dir,
-            added_vars: IndexMap::new(),
-            visited_dirs: IndexSet::new(),
-            exitscripts: IndexMap::new(),
-        }
-    }
-
-    fn toml_if_trusted(&mut self, nu_env_file: &Path) -> Result<NuEnvDoc, ShellError> {
-        let content = std::fs::read(&nu_env_file)?;
-
-        if autoenv::file_is_trusted(&nu_env_file, &content)? {
-            let mut doc: NuEnvDoc = toml::de::from_slice(&content)
-                .map_err(|e| ShellError::untagged_runtime_error(format!("{:?}", e)))?;
-
-            if let Some(scripts) = doc.scripts.as_ref() {
-                for (k, v) in scripts {
-                    if k == "entryscripts" {
-                        doc.entryscripts = Some(v.clone());
-                    } else if k == "exitscripts" {
-                        doc.exitscripts = Some(v.clone());
-                    }
-                }
-            }
-            return Ok(doc);
-        }
-        Err(ShellError::untagged_runtime_error(
-                format!("{:?} is untrusted. Run 'autoenv trust {:?}' to trust it.\nThis needs to be done after each change to the file.", nu_env_file, nu_env_file.parent().unwrap_or_else(|| &Path::new("")))))
-    }
-
-    pub fn maintain_autoenv(&mut self) -> Result<(), ShellError> {
-        let mut dir = current_dir()?;
-
-        if self.last_seen_directory == dir {
-            return Ok(());
-        }
-
-        //We track which keys we set as we go up the directory hierarchy, so that we don't overwrite a value we set in a subdir.
-        let mut added_keys = IndexSet::new();
-
-        let mut new_visited_dirs = IndexSet::new();
-        let mut popped = true;
-        while popped {
-            let nu_env_file = dir.join(".nu-env");
-            if nu_env_file.exists() && !self.visited_dirs.contains(&dir) {
-                let nu_env_doc = self.toml_if_trusted(&nu_env_file)?;
-
-                //add regular variables from the [env section]
-                if let Some(env) = nu_env_doc.env {
-                    for (env_key, env_val) in env {
-                        self.maybe_add_key(&mut added_keys, &dir, &env_key, &env_val);
-                    }
-                }
-
-                //Add variables that need to evaluate scripts to run, from [scriptvars] section
-                if let Some(sv) = nu_env_doc.scriptvars {
-                    for (key, script) in sv {
-                        self.maybe_add_key(
-                            &mut added_keys,
-                            &dir,
-                            &key,
-                            value_from_script(&script)?.as_str(),
-                        );
-                    }
-                }
-
-                if let Some(es) = nu_env_doc.entryscripts {
-                    for s in es {
-                        run(s.as_str(), None)?;
-                    }
-                }
-
-                if let Some(es) = nu_env_doc.exitscripts {
-                    self.exitscripts.insert(dir.clone(), es);
-                }
-            }
-            new_visited_dirs.insert(dir.clone());
-            popped = dir.pop();
-        }
-
-        //Time to clear out vars set by directories that we have left.
-        let mut new_vars = IndexMap::new();
-        for (dir, dirmap) in self.added_vars.drain(..) {
-            if new_visited_dirs.contains(&dir) {
-                new_vars.insert(dir, dirmap);
-            } else {
-                for (k, v) in dirmap {
-                    if let Some(v) = v {
-                        std::env::set_var(k, v);
-                    } else {
-                        std::env::remove_var(k);
-                    }
-                }
-            }
-        }
-
-        //Run exitscripts, can not be done in same loop as new vars as some files can contain only exitscripts
-        let mut new_exitscripts = IndexMap::new();
-        for (dir, scripts) in self.exitscripts.drain(..) {
-            if new_visited_dirs.contains(&dir) {
-                new_exitscripts.insert(dir, scripts);
-            } else {
-                for s in scripts {
-                    run(s.as_str(), Some(&dir))?;
-                }
-            }
-        }
-
-        self.visited_dirs = new_visited_dirs;
-        self.exitscripts = new_exitscripts;
-        self.added_vars = new_vars;
-        self.last_seen_directory = current_dir()?;
-        Ok(())
-    }
-
-    pub fn maybe_add_key(
-        &mut self,
-        seen_vars: &mut IndexSet<EnvKey>,
-        dir: &Path,
-        key: &str,
-        val: &str,
-    ) {
-        //This condition is to make sure variables in parent directories don't overwrite variables set by subdirectories.
-        if !seen_vars.contains(key) {
-            seen_vars.insert(key.to_string());
-            self.added_vars
-                .entry(PathBuf::from(dir))
-                .or_insert(IndexMap::new())
-                .insert(key.to_string(), var_os(key));
-
-            std::env::set_var(key, val);
-        }
-    }
-
-    // If the user recently ran autoenv untrust on a file, we clear the environment variables it set and make sure to not run any possible exitscripts.
-    pub fn clear_recently_untrusted_file(&mut self) -> Result<(), ShellError> {
-        // Figure out which file was untrusted
-        // Remove all vars set by it
-        let current_trusted_files: IndexSet<PathBuf> = autoenv::read_trusted()?
-            .files
-            .iter()
-            .map(|(k, _)| PathBuf::from(k))
-            .collect();
-
-        // We figure out which file(s) the user untrusted by taking the set difference of current trusted files in .config/nu/nu-env.toml and the files tracked by self.added_env_vars
-        // If a file is in self.added_env_vars but not in nu-env.toml, it was just untrusted.
-        let untrusted_files: IndexSet<PathBuf> = self
-            .added_vars
-            .iter()
-            .filter_map(|(path, _)| {
-                if !current_trusted_files.contains(path) {
-                    return Some(path.clone());
-                }
-                None
-            })
-            .collect();
-
-        for path in untrusted_files {
-            if let Some(added_keys) = self.added_vars.get(&path) {
-                for (key, _) in added_keys {
-                    remove_var(key);
-                }
-            }
-            self.exitscripts.remove(&path);
-            self.added_vars.remove(&path);
-        }
-
-        Ok(())
-    }
-}
-
-fn run(cmd: &str, dir: Option<&PathBuf>) -> Result<(), ShellError> {
-    if cfg!(target_os = "windows") {
-        if let Some(dir) = dir {
-            let command = format!("cd {} & {}", dir.to_string_lossy(), cmd);
-            Command::new("cmd")
-                .args(&["/C", command.as_str()])
-                .output()?
-        } else {
-            Command::new("cmd").args(&["/C", cmd]).output()?
-        }
-    } else if let Some(dir) = dir {
-        // FIXME: When nu scripting is added, cding like might not be a good idea. If nu decides to execute entryscripts when entering the dir this way, it will cause troubles.
-        // For now only standard shell scripts are used, so this is an issue for the future.
-        Command::new("sh")
-            .arg("-c")
-            .arg(format!("cd {:?}; {}", dir, cmd))
-            .output()?
-    } else {
-        Command::new("sh").arg("-c").arg(&cmd).output()?
-    };
-    Ok(())
-}
-fn value_from_script(cmd: &str) -> Result<String, ShellError> {
-    let command = if cfg!(target_os = "windows") {
-        Command::new("cmd").args(&["/C", cmd]).output()?
-    } else {
-        Command::new("sh").arg("-c").arg(&cmd).output()?
-    };
-    if command.stdout.is_empty() {
-        return Err(ShellError::untagged_runtime_error(format!(
-            "{:?} did not return any output",
-            cmd
-        )));
-    }
-    let response = std::str::from_utf8(&command.stdout[..command.stdout.len()]).map_err(|e| {
-        ShellError::untagged_runtime_error(format!(
-            "Couldn't parse stdout from command {:?}: {:?}",
-            command, e
-        ))
-    })?;
-
-    Ok(response.trim().to_string())
-}

crates/nu-cli/src/env/environment.rs

@@ -1,274 +0,0 @@
-use crate::env::directory_specific_environment::*;
-use indexmap::{indexmap, IndexSet};
-use nu_data::config::Conf;
-use nu_engine::Env;
-use nu_errors::ShellError;
-use nu_protocol::{UntaggedValue, Value};
-
-#[derive(Debug, Default)]
-pub struct Environment {
-    environment_vars: Option<Value>,
-    path_vars: Option<Value>,
-    pub autoenv: DirectorySpecificEnvironment,
-}
-
-impl Environment {
-    pub fn new() -> Environment {
-        Environment {
-            environment_vars: None,
-            path_vars: None,
-            autoenv: DirectorySpecificEnvironment::new(),
-        }
-    }
-
-    pub fn from_config<T: Conf>(configuration: &T) -> Environment {
-        let env = configuration.env();
-        let path = configuration.path();
-        Environment {
-            environment_vars: env,
-            path_vars: path,
-            autoenv: DirectorySpecificEnvironment::new(),
-        }
-    }
-
-    pub fn autoenv(&mut self, reload_trusted: bool) -> Result<(), ShellError> {
-        self.autoenv.maintain_autoenv()?;
-        if reload_trusted {
-            self.autoenv.clear_recently_untrusted_file()?;
-        }
-        Ok(())
-    }
-
-    pub fn morph<T: Conf>(&mut self, configuration: &T) {
-        self.environment_vars = configuration.env();
-        self.path_vars = configuration.path();
-    }
-}
-
-impl Env for Environment {
-    fn env(&self) -> Option<Value> {
-        if let Some(vars) = &self.environment_vars {
-            return Some(vars.clone());
-        }
-
-        None
-    }
-
-    fn path(&self) -> Option<Value> {
-        if let Some(vars) = &self.path_vars {
-            return Some(vars.clone());
-        }
-
-        None
-    }
-
-    fn add_env(&mut self, key: &str, value: &str) {
-        let value = UntaggedValue::string(value);
-
-        let new_envs = {
-            if let Some(Value {
-                value: UntaggedValue::Row(ref envs),
-                ref tag,
-            }) = self.environment_vars
-            {
-                let mut new_envs = envs.clone();
-
-                if !new_envs.contains_key(key) {
-                    new_envs.insert_data_at_key(key, value.into_value(tag.clone()));
-                }
-
-                Value {
-                    value: UntaggedValue::Row(new_envs),
-                    tag: tag.clone(),
-                }
-            } else {
-                UntaggedValue::Row(indexmap! { key.into() => value.into_untagged_value() }.into())
-                    .into_untagged_value()
-            }
-        };
-
-        self.environment_vars = Some(new_envs);
-    }
-
-    fn add_path(&mut self, paths: std::ffi::OsString) {
-        let new_paths = {
-            if let Some(Value {
-                value: UntaggedValue::Table(ref current_paths),
-                ref tag,
-            }) = self.path_vars
-            {
-                let mut new_paths = current_paths.clone();
-
-                let new_path_candidates = std::env::split_paths(&paths).map(|path| {
-                    UntaggedValue::string(path.to_string_lossy()).into_value(tag.clone())
-                });
-
-                new_paths.extend(new_path_candidates);
-
-                let paths: IndexSet<Value> = new_paths.into_iter().collect();
-
-                Value {
-                    value: UntaggedValue::Table(paths.into_iter().collect()),
-                    tag: tag.clone(),
-                }
-            } else {
-                let p = paths.into_string().unwrap_or_else(|_| String::from(""));
-                let p = UntaggedValue::string(p).into_untagged_value();
-                UntaggedValue::Table(vec![p]).into_untagged_value()
-            }
-        };
-
-        self.path_vars = Some(new_paths);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Env, Environment};
-    use nu_data::config::{tests::FakeConfig, Conf};
-    use nu_protocol::UntaggedValue;
-    use nu_test_support::fs::Stub::FileWithContent;
-    use nu_test_support::playground::Playground;
-
-    #[test]
-    fn picks_up_environment_variables_from_configuration() {
-        Playground::setup("environment_test_1", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    [env]
-                    mosquetero_1 = "Andrés N. Robalino"
-                    mosquetero_2 = "Jonathan Turner"
-                    mosquetero_3 = "Yehuda katz"
-                    mosquetero_4 = "Jason Gedge"
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let actual = Environment::from_config(&fake_config);
-
-            assert_eq!(actual.env(), fake_config.env());
-        });
-    }
-
-    #[test]
-    fn picks_up_path_variables_from_configuration() {
-        Playground::setup("environment_test_2", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    path = ["/Users/andresrobalino/.volta/bin", "/users/mosqueteros/bin"]
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let actual = Environment::from_config(&fake_config);
-
-            assert_eq!(actual.path(), fake_config.path());
-        });
-    }
-
-    #[test]
-    fn updates_env_variable() {
-        Playground::setup("environment_test_3", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    [env]
-                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = Environment::from_config(&fake_config);
-
-            actual.add_env("USER", "NUNO");
-
-            assert_eq!(
-                actual.env(),
-                Some(
-                    UntaggedValue::row(
-                        indexmap! {
-                            "USER".into() => UntaggedValue::string("NUNO").into_untagged_value(),
-                            "SHELL".into() => UntaggedValue::string("/usr/bin/you_already_made_the_nu_choice").into_untagged_value(),
-                        }
-                    ).into_untagged_value()
-                )
-            );
-        });
-    }
-
-    #[test]
-    fn does_not_update_env_variable_if_it_exists() {
-        Playground::setup("environment_test_4", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    [env]
-                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = Environment::from_config(&fake_config);
-
-            actual.add_env("SHELL", "/usr/bin/sh");
-
-            assert_eq!(
-                actual.env(),
-                Some(
-                    UntaggedValue::row(
-                        indexmap! {
-                            "SHELL".into() => UntaggedValue::string("/usr/bin/you_already_made_the_nu_choice").into_untagged_value(),
-                        }
-                    ).into_untagged_value()
-                )
-            );
-        });
-    }
-
-    #[test]
-    fn updates_path_variable() {
-        Playground::setup("environment_test_5", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    path = ["/Users/andresrobalino/.volta/bin", "/users/mosqueteros/bin"]
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = Environment::from_config(&fake_config);
-
-            actual.add_path(std::ffi::OsString::from("/path/to/be/added"));
-
-            assert_eq!(
-                actual.path(),
-                Some(
-                    UntaggedValue::table(&[
-                        UntaggedValue::string("/Users/andresrobalino/.volta/bin")
-                            .into_untagged_value(),
-                        UntaggedValue::string("/users/mosqueteros/bin").into_untagged_value(),
-                        UntaggedValue::string("/path/to/be/added").into_untagged_value(),
-                    ])
-                    .into_untagged_value()
-                )
-            );
-        });
-    }
-}

crates/nu-cli/src/env/environment_syncer.rs

@@ -1,617 +0,0 @@
-use crate::env::environment::Environment;
-use nu_data::config::{Conf, NuConfig};
-use nu_engine::Env;
-use nu_engine::EvaluationContext;
-use nu_errors::ShellError;
-use parking_lot::Mutex;
-use std::sync::{atomic::Ordering, Arc};
-
-pub struct EnvironmentSyncer {
-    pub env: Arc<Mutex<Box<Environment>>>,
-    pub config: Arc<Mutex<Box<dyn Conf>>>,
-}
-
-impl Default for EnvironmentSyncer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl EnvironmentSyncer {
-    pub fn with_config(config: Box<dyn Conf>) -> Self {
-        EnvironmentSyncer {
-            env: Arc::new(Mutex::new(Box::new(Environment::new()))),
-            config: Arc::new(Mutex::new(config)),
-        }
-    }
-
-    pub fn new() -> EnvironmentSyncer {
-        EnvironmentSyncer {
-            env: Arc::new(Mutex::new(Box::new(Environment::new()))),
-            config: Arc::new(Mutex::new(Box::new(NuConfig::new()))),
-        }
-    }
-
-    #[cfg(test)]
-    pub fn set_config(&mut self, config: Box<dyn Conf>) {
-        self.config = Arc::new(Mutex::new(config));
-    }
-
-    pub fn get_config(&self) -> Box<dyn Conf> {
-        let config = self.config.lock();
-
-        config.clone_box()
-    }
-
-    pub fn load_environment(&mut self) {
-        let config = self.config.lock();
-
-        self.env = Arc::new(Mutex::new(Box::new(Environment::from_config(&*config))));
-    }
-
-    pub fn did_config_change(&mut self) -> bool {
-        let config = self.config.lock();
-        config.is_modified().unwrap_or(false)
-    }
-
-    pub fn reload(&mut self) {
-        let mut config = self.config.lock();
-        config.reload();
-
-        let mut environment = self.env.lock();
-        environment.morph(&*config);
-    }
-
-    pub fn autoenv(&self, ctx: &mut EvaluationContext) -> Result<(), ShellError> {
-        let mut environment = self.env.lock();
-        let recently_used = ctx
-            .user_recently_used_autoenv_untrust
-            .load(Ordering::SeqCst);
-        let auto = environment.autoenv(recently_used);
-        ctx.user_recently_used_autoenv_untrust
-            .store(false, Ordering::SeqCst);
-        auto
-    }
-
-    pub fn sync_env_vars(&mut self, ctx: &mut EvaluationContext) {
-        let mut environment = self.env.lock();
-
-        if environment.env().is_some() {
-            for (name, value) in ctx.with_host(|host| host.vars()) {
-                if name != "path" && name != "PATH" {
-                    // account for new env vars present in the current session
-                    // that aren't loaded from config.
-                    environment.add_env(&name, &value);
-
-                    // clear the env var from the session
-                    // we are about to replace them
-                    ctx.with_host(|host| host.env_rm(std::ffi::OsString::from(name)));
-                }
-            }
-
-            if let Some(variables) = environment.env() {
-                for var in variables.row_entries() {
-                    if let Ok(string) = var.1.as_string() {
-                        ctx.with_host(|host| {
-                            host.env_set(
-                                std::ffi::OsString::from(var.0),
-                                std::ffi::OsString::from(&string),
-                            )
-                        });
-
-                        ctx.scope.add_env_var_to_base(var.0, string);
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn sync_path_vars(&mut self, ctx: &mut EvaluationContext) {
-        let mut environment = self.env.lock();
-
-        if environment.path().is_some() {
-            let native_paths = ctx.with_host(|host| host.env_get(std::ffi::OsString::from("PATH")));
-
-            if let Some(native_paths) = native_paths {
-                environment.add_path(native_paths);
-
-                ctx.with_host(|host| {
-                    host.env_rm(std::ffi::OsString::from("PATH"));
-                });
-            }
-
-            if let Some(new_paths) = environment.path() {
-                let prepared = std::env::join_paths(
-                    new_paths
-                        .table_entries()
-                        .map(|p| p.as_string())
-                        .filter_map(Result::ok),
-                );
-
-                if let Ok(paths_ready) = prepared {
-                    ctx.with_host(|host| {
-                        host.env_set(
-                            std::ffi::OsString::from("PATH"),
-                            std::ffi::OsString::from(&paths_ready),
-                        );
-                    });
-
-                    ctx.scope
-                        .add_env_var_to_base("PATH", paths_ready.to_string_lossy().to_string());
-                }
-            }
-        }
-    }
-
-    #[cfg(test)]
-    pub fn clear_env_vars(&mut self, ctx: &mut EvaluationContext) {
-        for (key, _value) in ctx.with_host(|host| host.vars()) {
-            if key != "path" && key != "PATH" {
-                ctx.with_host(|host| host.env_rm(std::ffi::OsString::from(key)));
-            }
-        }
-    }
-
-    #[cfg(test)]
-    pub fn clear_path_var(&mut self, ctx: &mut EvaluationContext) {
-        ctx.with_host(|host| host.env_rm(std::ffi::OsString::from("PATH")));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::EnvironmentSyncer;
-    use indexmap::IndexMap;
-    use nu_data::config::tests::FakeConfig;
-    use nu_engine::Env;
-    use nu_engine::EvaluationContext;
-    use nu_errors::ShellError;
-    use nu_test_support::fs::Stub::FileWithContent;
-    use nu_test_support::playground::Playground;
-    use parking_lot::Mutex;
-    use std::path::PathBuf;
-    use std::sync::Arc;
-
-    // This test fails on Linux.
-    // It's possible it has something to do with the fake configuration
-    // TODO: More tests.
-    #[cfg(not(target_os = "linux"))]
-    #[test]
-    fn syncs_env_if_new_env_entry_is_added_to_an_existing_configuration() -> Result<(), ShellError>
-    {
-        let mut ctx = EvaluationContext::basic()?;
-        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
-
-        let mut expected = IndexMap::new();
-        expected.insert(
-            "SHELL".to_string(),
-            "/usr/bin/you_already_made_the_nu_choice".to_string(),
-        );
-
-        Playground::setup("syncs_env_from_config_updated_test_1", |dirs, sandbox| {
-            sandbox.with_files(vec![
-                FileWithContent(
-                    "configuration.toml",
-                    r#"
-                    [env]
-                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
-                "#,
-                ),
-                FileWithContent(
-                    "updated_configuration.toml",
-                    r#"
-                    [env]
-                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
-                    USER = "NUNO"
-                "#,
-                ),
-            ]);
-
-            let file = dirs.test().join("configuration.toml");
-            let new_file = dirs.test().join("updated_configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = EnvironmentSyncer::with_config(Box::new(fake_config));
-
-            // Here, the environment variables from the current session
-            // are cleared since we will load and set them from the
-            // configuration file
-            actual.clear_env_vars(&mut ctx);
-
-            // Nu loads the environment variables from the configuration file
-            actual.load_environment();
-            actual.sync_env_vars(&mut ctx);
-
-            {
-                let environment = actual.env.lock();
-                let mut vars = IndexMap::new();
-                environment
-                    .env()
-                    .expect("No variables in the environment.")
-                    .row_entries()
-                    .for_each(|(name, value)| {
-                        vars.insert(
-                            name.to_string(),
-                            value.as_string().expect("Couldn't convert to string"),
-                        );
-                    });
-
-                for k in expected.keys() {
-                    assert!(vars.contains_key(k));
-                }
-            }
-
-            assert!(!actual.did_config_change());
-
-            // Replacing the newer configuration file to the existing one.
-            let new_config_contents = std::fs::read_to_string(new_file).expect("Failed");
-            std::fs::write(&file, &new_config_contents).expect("Failed");
-
-            // A change has happened
-            assert!(actual.did_config_change());
-
-            // Syncer should reload and add new envs
-            actual.reload();
-            actual.sync_env_vars(&mut ctx);
-
-            expected.insert("USER".to_string(), "NUNO".to_string());
-
-            {
-                let environment = actual.env.lock();
-                let mut vars = IndexMap::new();
-                environment
-                    .env()
-                    .expect("No variables in the environment.")
-                    .row_entries()
-                    .for_each(|(name, value)| {
-                        vars.insert(
-                            name.to_string(),
-                            value.as_string().expect("Couldn't convert to string"),
-                        );
-                    });
-
-                for k in expected.keys() {
-                    assert!(vars.contains_key(k));
-                }
-            }
-        });
-
-        Ok(())
-    }
-
-    #[test]
-    fn syncs_env_if_new_env_entry_in_session_is_not_in_configuration_file() -> Result<(), ShellError>
-    {
-        let mut ctx = EvaluationContext::basic()?;
-        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
-
-        let mut expected = IndexMap::new();
-        expected.insert(
-            "SHELL".to_string(),
-            "/usr/bin/you_already_made_the_nu_choice".to_string(),
-        );
-        expected.insert("USER".to_string(), "NUNO".to_string());
-
-        Playground::setup("syncs_env_test_1", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    [env]
-                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = EnvironmentSyncer::new();
-            actual.set_config(Box::new(fake_config));
-
-            // Here, the environment variables from the current session
-            // are cleared since we will load and set them from the
-            // configuration file (if any)
-            actual.clear_env_vars(&mut ctx);
-
-            // We explicitly simulate and add the USER variable to the current
-            // session's environment variables with the value "NUNO".
-            ctx.with_host(|test_host| {
-                test_host.env_set(
-                    std::ffi::OsString::from("USER"),
-                    std::ffi::OsString::from("NUNO"),
-                )
-            });
-
-            // Nu loads the environment variables from the configuration file (if any)
-            actual.load_environment();
-
-            // By this point, Nu has already loaded the environment variables
-            // stored in the configuration file. Before continuing we check
-            // if any new environment variables have been added from the ones loaded
-            // in the configuration file.
-            //
-            // Nu sees the missing "USER" variable and accounts for it.
-            actual.sync_env_vars(&mut ctx);
-
-            // Confirms session environment variables are replaced from Nu configuration file
-            // including the newer one accounted for.
-            ctx.with_host(|test_host| {
-                let var_user = test_host
-                    .env_get(std::ffi::OsString::from("USER"))
-                    .expect("Couldn't get USER var from host.")
-                    .into_string()
-                    .expect("Couldn't convert to string.");
-
-                let var_shell = test_host
-                    .env_get(std::ffi::OsString::from("SHELL"))
-                    .expect("Couldn't get SHELL var from host.")
-                    .into_string()
-                    .expect("Couldn't convert to string.");
-
-                let mut found = IndexMap::new();
-                found.insert("SHELL".to_string(), var_shell);
-                found.insert("USER".to_string(), var_user);
-
-                for k in found.keys() {
-                    assert!(expected.contains_key(k));
-                }
-            });
-
-            // Now confirm in-memory environment variables synced appropriately
-            // including the newer one accounted for.
-            let environment = actual.env.lock();
-
-            let mut vars = IndexMap::new();
-            environment
-                .env()
-                .expect("No variables in the environment.")
-                .row_entries()
-                .for_each(|(name, value)| {
-                    vars.insert(
-                        name.to_string(),
-                        value.as_string().expect("Couldn't convert to string"),
-                    );
-                });
-            for k in expected.keys() {
-                assert!(vars.contains_key(k));
-            }
-        });
-        Ok(())
-    }
-
-    #[test]
-    fn nu_envs_have_higher_priority_and_does_not_get_overwritten() -> Result<(), ShellError> {
-        let mut ctx = EvaluationContext::basic()?;
-        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
-
-        let mut expected = IndexMap::new();
-        expected.insert(
-            "SHELL".to_string(),
-            "/usr/bin/you_already_made_the_nu_choice".to_string(),
-        );
-
-        Playground::setup("syncs_env_test_2", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    [env]
-                    SHELL = "/usr/bin/you_already_made_the_nu_choice"
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = EnvironmentSyncer::new();
-            actual.set_config(Box::new(fake_config));
-
-            actual.clear_env_vars(&mut ctx);
-
-            ctx.with_host(|test_host| {
-                test_host.env_set(
-                    std::ffi::OsString::from("SHELL"),
-                    std::ffi::OsString::from("/usr/bin/sh"),
-                )
-            });
-
-            actual.load_environment();
-            actual.sync_env_vars(&mut ctx);
-
-            ctx.with_host(|test_host| {
-                let var_shell = test_host
-                    .env_get(std::ffi::OsString::from("SHELL"))
-                    .expect("Couldn't get SHELL var from host.")
-                    .into_string()
-                    .expect("Couldn't convert to string.");
-
-                let mut found = IndexMap::new();
-                found.insert("SHELL".to_string(), var_shell);
-
-                for k in found.keys() {
-                    assert!(expected.contains_key(k));
-                }
-            });
-
-            let environment = actual.env.lock();
-
-            let mut vars = IndexMap::new();
-            environment
-                .env()
-                .expect("No variables in the environment.")
-                .row_entries()
-                .for_each(|(name, value)| {
-                    vars.insert(
-                        name.to_string(),
-                        value.as_string().expect("couldn't convert to string"),
-                    );
-                });
-            for k in expected.keys() {
-                assert!(vars.contains_key(k));
-            }
-        });
-
-        Ok(())
-    }
-
-    #[test]
-    fn syncs_path_if_new_path_entry_in_session_is_not_in_configuration_file(
-    ) -> Result<(), ShellError> {
-        let mut ctx = EvaluationContext::basic()?;
-        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
-
-        let expected = std::env::join_paths(vec![
-            PathBuf::from("/Users/andresrobalino/.volta/bin"),
-            PathBuf::from("/Users/mosqueteros/bin"),
-            PathBuf::from("/path/to/be/added"),
-        ])
-        .expect("Couldn't join paths.")
-        .into_string()
-        .expect("Couldn't convert to string.");
-
-        Playground::setup("syncs_path_test_1", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    path = ["/Users/andresrobalino/.volta/bin", "/Users/mosqueteros/bin"]
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = EnvironmentSyncer::new();
-            actual.set_config(Box::new(fake_config));
-
-            // Here, the environment variables from the current session
-            // are cleared since we will load and set them from the
-            // configuration file (if any)
-            actual.clear_path_var(&mut ctx);
-
-            // We explicitly simulate and add the PATH variable to the current
-            // session with the path "/path/to/be/added".
-            ctx.with_host(|test_host| {
-                test_host.env_set(
-                    std::ffi::OsString::from("PATH"),
-                    std::env::join_paths(vec![PathBuf::from("/path/to/be/added")])
-                        .expect("Couldn't join paths."),
-                )
-            });
-
-            // Nu loads the path variables from the configuration file (if any)
-            actual.load_environment();
-
-            // By this point, Nu has already loaded environment path variable
-            // stored in the configuration file. Before continuing we check
-            // if any new paths have been added from the ones loaded in the
-            // configuration file.
-            //
-            // Nu sees the missing "/path/to/be/added" and accounts for it.
-            actual.sync_path_vars(&mut ctx);
-
-            ctx.with_host(|test_host| {
-                let actual = test_host
-                    .env_get(std::ffi::OsString::from("PATH"))
-                    .expect("Couldn't get PATH var from host.")
-                    .into_string()
-                    .expect("Couldn't convert to string.");
-
-                assert_eq!(actual, expected);
-            });
-
-            let environment = actual.env.lock();
-
-            let paths = std::env::join_paths(
-                &environment
-                    .path()
-                    .expect("No path variable in the environment.")
-                    .table_entries()
-                    .map(|value| value.as_string().expect("Couldn't convert to string"))
-                    .map(PathBuf::from)
-                    .collect::<Vec<_>>(),
-            )
-            .expect("Couldn't join paths.")
-            .into_string()
-            .expect("Couldn't convert to string.");
-
-            assert_eq!(paths, expected);
-        });
-
-        Ok(())
-    }
-
-    #[test]
-    fn nu_paths_have_higher_priority_and_new_paths_get_appended_to_the_end(
-    ) -> Result<(), ShellError> {
-        let mut ctx = EvaluationContext::basic()?;
-        ctx.host = Arc::new(Mutex::new(Box::new(nu_engine::FakeHost::new())));
-
-        let expected = std::env::join_paths(vec![
-            PathBuf::from("/Users/andresrobalino/.volta/bin"),
-            PathBuf::from("/Users/mosqueteros/bin"),
-            PathBuf::from("/path/to/be/added"),
-        ])
-        .expect("Couldn't join paths.")
-        .into_string()
-        .expect("Couldn't convert to string.");
-
-        Playground::setup("syncs_path_test_2", |dirs, sandbox| {
-            sandbox.with_files(vec![FileWithContent(
-                "configuration.toml",
-                r#"
-                    path = ["/Users/andresrobalino/.volta/bin", "/Users/mosqueteros/bin"]
-                "#,
-            )]);
-
-            let mut file = dirs.test().clone();
-            file.push("configuration.toml");
-
-            let fake_config = FakeConfig::new(&file);
-            let mut actual = EnvironmentSyncer::new();
-            actual.set_config(Box::new(fake_config));
-
-            actual.clear_path_var(&mut ctx);
-
-            ctx.with_host(|test_host| {
-                test_host.env_set(
-                    std::ffi::OsString::from("PATH"),
-                    std::env::join_paths(vec![PathBuf::from("/path/to/be/added")])
-                        .expect("Couldn't join paths."),
-                )
-            });
-
-            actual.load_environment();
-            actual.sync_path_vars(&mut ctx);
-
-            ctx.with_host(|test_host| {
-                let actual = test_host
-                    .env_get(std::ffi::OsString::from("PATH"))
-                    .expect("Couldn't get PATH var from host.")
-                    .into_string()
-                    .expect("Couldn't convert to string.");
-
-                assert_eq!(actual, expected);
-            });
-
-            let environment = actual.env.lock();
-
-            let paths = std::env::join_paths(
-                &environment
-                    .path()
-                    .expect("No path variable in the environment.")
-                    .table_entries()
-                    .map(|value| value.as_string().expect("Couldn't convert to string"))
-                    .map(PathBuf::from)
-                    .collect::<Vec<_>>(),
-            )
-            .expect("Couldn't join paths.")
-            .into_string()
-            .expect("Couldn't convert to string.");
-
-            assert_eq!(paths, expected);
-        });
-
-        Ok(())
-    }
-}

crates/nu-cli/src/format.rs

@@ -1,6 +0,0 @@
-use crate::prelude::*;
-use nu_errors::ShellError;
-
-pub(crate) trait RenderView {
-    fn render_view(&self, host: &mut dyn Host) -> Result<(), ShellError>;
-}

crates/nu-cli/src/keybinding.rs

@@ -1,63 +1,42 @@
-use rustyline::{KeyCode, Modifiers};
+use rustyline::{KeyCode as RustyKeyCode, Modifiers};
 use serde::{Deserialize, Serialize};
 
-pub fn convert_keyevent(key_event: KeyEvent) -> rustyline::KeyEvent {
+pub fn convert_keyevent(key_event: KeyCode, modifiers: Option<Modifiers>) -> rustyline::KeyEvent {
     match key_event {
-        KeyEvent::UnknownEscSeq => convert_to_rl_keyevent(rustyline::KeyCode::UnknownEscSeq, None),
-        KeyEvent::Backspace => convert_to_rl_keyevent(rustyline::KeyCode::Backspace, None),
-        KeyEvent::BackTab => convert_to_rl_keyevent(rustyline::KeyCode::BackTab, None),
-        KeyEvent::BracketedPasteStart => {
-            convert_to_rl_keyevent(rustyline::KeyCode::BracketedPasteStart, None)
+        KeyCode::UnknownEscSeq => convert_to_rl_keyevent(RustyKeyCode::UnknownEscSeq, modifiers),
+        KeyCode::Backspace => convert_to_rl_keyevent(RustyKeyCode::Backspace, modifiers),
+        KeyCode::BackTab => convert_to_rl_keyevent(RustyKeyCode::BackTab, modifiers),
+        KeyCode::BracketedPasteStart => {
+            convert_to_rl_keyevent(RustyKeyCode::BracketedPasteStart, modifiers)
         }
-        KeyEvent::BracketedPasteEnd => {
-            convert_to_rl_keyevent(rustyline::KeyCode::BracketedPasteEnd, None)
+        KeyCode::BracketedPasteEnd => {
+            convert_to_rl_keyevent(RustyKeyCode::BracketedPasteEnd, modifiers)
         }
-        KeyEvent::Char(c) => convert_to_rl_keyevent(rustyline::KeyCode::Char(c), None),
-        KeyEvent::ControlDown => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Down, Some(Modifiers::CTRL))
-        }
-        KeyEvent::ControlLeft => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Left, Some(Modifiers::CTRL))
-        }
-        KeyEvent::ControlRight => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Right, Some(Modifiers::CTRL))
-        }
-        KeyEvent::ControlUp => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Up, Some(Modifiers::CTRL))
-        }
-        KeyEvent::Ctrl(c) => rustyline::KeyEvent::ctrl(c),
-        KeyEvent::Delete => convert_to_rl_keyevent(rustyline::KeyCode::Delete, None),
-        KeyEvent::Down => convert_to_rl_keyevent(rustyline::KeyCode::Down, None),
-        KeyEvent::End => convert_to_rl_keyevent(rustyline::KeyCode::End, None),
-        KeyEvent::Enter => convert_to_rl_keyevent(rustyline::KeyCode::Enter, None),
-        KeyEvent::Esc => convert_to_rl_keyevent(rustyline::KeyCode::Esc, None),
-        KeyEvent::F(u) => convert_to_rl_keyevent(rustyline::KeyCode::F(u), None),
-        KeyEvent::Home => convert_to_rl_keyevent(rustyline::KeyCode::Home, None),
-        KeyEvent::Insert => convert_to_rl_keyevent(rustyline::KeyCode::Insert, None),
-        KeyEvent::Left => convert_to_rl_keyevent(rustyline::KeyCode::Left, None),
-        KeyEvent::Meta(c) => rustyline::KeyEvent::new(c, Modifiers::NONE),
-        KeyEvent::Null => convert_to_rl_keyevent(rustyline::KeyCode::Null, None),
-        KeyEvent::PageDown => convert_to_rl_keyevent(rustyline::KeyCode::PageDown, None),
-        KeyEvent::PageUp => convert_to_rl_keyevent(rustyline::KeyCode::PageUp, None),
-        KeyEvent::Right => convert_to_rl_keyevent(rustyline::KeyCode::Right, None),
-        KeyEvent::ShiftDown => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Down, Some(Modifiers::SHIFT))
-        }
-        KeyEvent::ShiftLeft => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Left, Some(Modifiers::SHIFT))
-        }
-        KeyEvent::ShiftRight => {
-            convert_to_rl_keyevent(rustyline::KeyCode::Right, Some(Modifiers::SHIFT))
-        }
-        KeyEvent::ShiftUp => convert_to_rl_keyevent(rustyline::KeyCode::Up, Some(Modifiers::SHIFT)),
-        KeyEvent::Tab => convert_to_rl_keyevent(rustyline::KeyCode::Tab, None),
-        KeyEvent::Up => convert_to_rl_keyevent(rustyline::KeyCode::Up, None),
+        KeyCode::Char(c) => convert_to_rl_keyevent(RustyKeyCode::Char(c), modifiers),
+        KeyCode::Delete => convert_to_rl_keyevent(RustyKeyCode::Delete, modifiers),
+        KeyCode::Down => convert_to_rl_keyevent(RustyKeyCode::Down, modifiers),
+        KeyCode::End => convert_to_rl_keyevent(RustyKeyCode::End, modifiers),
+        KeyCode::Enter => convert_to_rl_keyevent(RustyKeyCode::Enter, modifiers),
+        KeyCode::Esc => convert_to_rl_keyevent(RustyKeyCode::Esc, modifiers),
+        KeyCode::F(u) => convert_to_rl_keyevent(RustyKeyCode::F(u), modifiers),
+        KeyCode::Home => convert_to_rl_keyevent(RustyKeyCode::Home, modifiers),
+        KeyCode::Insert => convert_to_rl_keyevent(RustyKeyCode::Insert, modifiers),
+        KeyCode::Left => convert_to_rl_keyevent(RustyKeyCode::Left, modifiers),
+        KeyCode::Null => convert_to_rl_keyevent(RustyKeyCode::Null, modifiers),
+        KeyCode::PageDown => convert_to_rl_keyevent(RustyKeyCode::PageDown, modifiers),
+        KeyCode::PageUp => convert_to_rl_keyevent(RustyKeyCode::PageUp, modifiers),
+        KeyCode::Right => convert_to_rl_keyevent(RustyKeyCode::Right, modifiers),
+        KeyCode::Tab => convert_to_rl_keyevent(RustyKeyCode::Tab, modifiers),
+        KeyCode::Up => convert_to_rl_keyevent(RustyKeyCode::Up, modifiers),
     }
 }
 
-fn convert_to_rl_keyevent(key_event: KeyCode, modifier: Option<Modifiers>) -> rustyline::KeyEvent {
+fn convert_to_rl_keyevent(
+    key_code: RustyKeyCode,
+    modifier: Option<Modifiers>,
+) -> rustyline::KeyEvent {
     rustyline::KeyEvent {
-        0: key_event,
+        0: key_code,
         1: modifier.unwrap_or(Modifiers::NONE),
     }
 }
@@ -132,12 +111,14 @@ fn convert_cmd(cmd: Cmd) -> rustyline::Cmd {
         Cmd::Complete => rustyline::Cmd::Complete,
         Cmd::CompleteBackward => rustyline::Cmd::CompleteBackward,
         Cmd::CompleteHint => rustyline::Cmd::CompleteHint,
+        Cmd::Dedent(movement) => rustyline::Cmd::Dedent(convert_movement(movement)),
         Cmd::DowncaseWord => rustyline::Cmd::DowncaseWord,
         Cmd::EndOfFile => rustyline::Cmd::EndOfFile,
         Cmd::EndOfHistory => rustyline::Cmd::EndOfHistory,
         Cmd::ForwardSearchHistory => rustyline::Cmd::ForwardSearchHistory,
         Cmd::HistorySearchBackward => rustyline::Cmd::HistorySearchBackward,
         Cmd::HistorySearchForward => rustyline::Cmd::HistorySearchForward,
+        Cmd::Indent(movement) => rustyline::Cmd::Indent(convert_movement(movement)),
         Cmd::Insert { repeat, string } => rustyline::Cmd::Insert(repeat, string),
         Cmd::Interrupt => rustyline::Cmd::Interrupt,
         Cmd::Kill(movement) => rustyline::Cmd::Kill(convert_movement(movement)),
@@ -145,8 +126,11 @@ fn convert_cmd(cmd: Cmd) -> rustyline::Cmd {
         Cmd::LineUpOrPreviousHistory(u) => rustyline::Cmd::LineUpOrPreviousHistory(u),
         Cmd::Move(movement) => rustyline::Cmd::Move(convert_movement(movement)),
         Cmd::NextHistory => rustyline::Cmd::NextHistory,
+        Cmd::Newline => rustyline::Cmd::Newline,
         Cmd::Noop => rustyline::Cmd::Noop,
         Cmd::Overwrite(c) => rustyline::Cmd::Overwrite(c),
+        #[cfg(windows)]
+        Cmd::PasteFromClipboard => rustyline::Cmd::PasteFromClipboard,
         Cmd::PreviousHistory => rustyline::Cmd::PreviousHistory,
         Cmd::QuotedInsert => rustyline::Cmd::QuotedInsert,
         Cmd::Replace {
@@ -169,14 +153,28 @@ fn convert_cmd(cmd: Cmd) -> rustyline::Cmd {
 }
 
 fn convert_keybinding(keybinding: Keybinding) -> (rustyline::KeyEvent, rustyline::Cmd) {
+    let rusty_modifiers = match keybinding.modifiers {
+        Some(mods) => match mods {
+            NuModifiers::Ctrl => Some(Modifiers::CTRL),
+            NuModifiers::Alt => Some(Modifiers::ALT),
+            NuModifiers::Shift => Some(Modifiers::SHIFT),
+            NuModifiers::None => Some(Modifiers::NONE),
+            NuModifiers::CtrlShift => Some(Modifiers::CTRL_SHIFT),
+            NuModifiers::AltShift => Some(Modifiers::ALT_SHIFT),
+            NuModifiers::CtrlAlt => Some(Modifiers::CTRL_ALT),
+            NuModifiers::CtrlAltShift => Some(Modifiers::CTRL_ALT_SHIFT),
+            // _ => None,
+        },
+        None => None,
+    };
     (
-        convert_keyevent(keybinding.key),
+        convert_keyevent(keybinding.key, rusty_modifiers),
         convert_cmd(keybinding.binding),
     )
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum KeyEvent {
+pub enum KeyCode {
     /// Unsupported escape sequence (on unix platform)
     UnknownEscSeq,
     /// ⌫ or `KeyEvent::Ctrl('H')`
@@ -189,16 +187,6 @@ pub enum KeyEvent {
     BracketedPasteEnd,
     /// Single char
     Char(char),
-    /// Ctrl-↓
-    ControlDown,
-    /// Ctrl-←
-    ControlLeft,
-    /// Ctrl-→
-    ControlRight,
-    /// Ctrl-↑
-    ControlUp,
-    /// Ctrl-char
-    Ctrl(char),
     /// ⌦
     Delete,
     /// ↓ arrow key
@@ -217,9 +205,7 @@ pub enum KeyEvent {
     Insert,
     /// ← arrow key
     Left,
-    /// Escape-char or Alt-char
-    Meta(char),
-    /// `KeyEvent::Char('\0')`
+    // /// `KeyEvent::Char('\0')`
     Null,
     /// ⇟
     PageDown,
@@ -227,14 +213,6 @@ pub enum KeyEvent {
     PageUp,
     /// → arrow key
     Right,
-    /// Shift-↓
-    ShiftDown,
-    /// Shift-←
-    ShiftLeft,
-    /// Shift-→
-    ShiftRight,
-    /// Shift-↑
-    ShiftUp,
     /// ⇥ or `KeyEvent::Ctrl('I')`
     Tab,
     /// ↑ arrow key
@@ -259,6 +237,8 @@ pub enum Cmd {
     CompleteBackward,
     /// complete-hint
     CompleteHint,
+    /// Dedent current line
+    Dedent(Movement),
     /// downcase-word
     DowncaseWord,
     /// vi-eof-maybe
@@ -271,6 +251,8 @@ pub enum Cmd {
     HistorySearchBackward,
     /// history-search-forward
     HistorySearchForward,
+    /// Indent current line
+    Indent(Movement),
     /// Insert text
     Insert { repeat: RepeatCount, string: String },
     /// Interrupt signal (Ctrl-C)
@@ -283,12 +265,17 @@ pub enum Cmd {
     /// forward-char, forward-word, vi-char-search, vi-end-word, vi-next-word,
     /// vi-prev-word
     Move(Movement),
+    /// Inserts a newline
+    Newline,
     /// next-history
     NextHistory,
     /// No action
     Noop,
     /// vi-replace
     Overwrite(char),
+    /// Paste from the clipboard
+    #[cfg(windows)]
+    PasteFromClipboard,
     /// previous-history
     PreviousHistory,
     /// quoted-insert
@@ -422,12 +409,43 @@ pub enum CharSearch {
     BackwardAfter(char),
 }
 
+/// The set of modifier keys that were triggered along with a key press.
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(non_camel_case_types)]
+pub enum NuModifiers {
+    /// Control modifier
+    #[serde(alias = "CTRL")]
+    Ctrl = 8,
+    /// Escape or Alt modifier
+    #[serde(alias = "ALT")]
+    Alt = 4,
+    /// Shift modifier
+    #[serde(alias = "SHIFT")]
+    Shift = 2,
+    /// No modifier
+    #[serde(alias = "NONE")]
+    None = 0,
+    /// Ctrl + Shift
+    #[serde(alias = "CTRL_SHIFT")]
+    CtrlShift = 10,
+    /// Alt + Shift
+    #[serde(alias = "ALT_SHIFT")]
+    AltShift = 6,
+    /// Ctrl + Alt
+    #[serde(alias = "CTRL_ALT")]
+    CtrlAlt = 12,
+    /// Ctrl + Alt + Shift
+    #[serde(alias = "CTRL_ALT_SHIFT")]
+    CtrlAltShift = 14,
+}
+
 /// The number of times one command should be repeated.
 pub type RepeatCount = usize;
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Keybinding {
-    key: KeyEvent,
+    key: KeyCode,
+    modifiers: Option<NuModifiers>,
     binding: Cmd,
 }
 
@@ -442,9 +460,10 @@ pub(crate) fn load_keybindings(
     // Silently fail if there is no file there
     if let Ok(contents) = contents {
         let keybindings: Keybindings = serde_yaml::from_str(&contents)?;
-
+        // eprintln!("{:#?}", keybindings);
         for keybinding in keybindings.into_iter() {
             let (k, b) = convert_keybinding(keybinding);
+            // eprintln!("{:?} {:?}", k, b);
 
             rl.bind_sequence(k, b);
         }

crates/nu-cli/src/lib.rs

@@ -1,44 +1,15 @@
-#![recursion_limit = "2048"]
-
-#[cfg(test)]
-#[macro_use]
-extern crate indexmap;
-
-#[macro_use]
-mod prelude;
-
-#[cfg(test)]
-extern crate quickcheck;
-#[cfg(test)]
-#[macro_use(quickcheck)]
-extern crate quickcheck_macros;
-
+pub mod app;
 mod cli;
 #[cfg(feature = "rustyline-support")]
-mod completion;
-mod env;
-mod format;
-#[cfg(feature = "rustyline-support")]
 mod keybinding;
 mod line_editor;
+#[cfg(feature = "rustyline-support")]
 mod shell;
-pub mod types;
 
 #[cfg(feature = "rustyline-support")]
 pub use crate::cli::cli;
 
+pub use crate::app::App;
 pub use crate::cli::{parse_and_eval, register_plugins, run_script_file};
-pub use crate::cli::{NuScript, Options};
 
-pub use crate::env::environment_syncer::EnvironmentSyncer;
-pub use nu_command::commands::default_context::create_default_context;
-pub use nu_data::config;
-pub use nu_data::dict::TaggedListBuilder;
-pub use nu_data::primitive;
-pub use nu_data::value;
-pub use nu_stream::{InputStream, InterruptibleStream, OutputStream};
-pub use nu_value_ext::ValueExt;
-pub use num_traits::cast::ToPrimitive;
-
-// TODO: Temporary redirect
-pub use nu_protocol::{did_you_mean, TaggedDictBuilder};
+pub use nu_command::create_default_context;

crates/nu-cli/src/line_editor.rs

@@ -1,14 +1,15 @@
 use nu_engine::EvaluationContext;
+use nu_errors::ShellError;
 use std::error::Error;
 
 #[allow(unused_imports)]
-use crate::prelude::*;
+use std::sync::atomic::Ordering;
 
 #[allow(unused_imports)]
 use nu_engine::script::LineResult;
 
 #[cfg(feature = "rustyline-support")]
-use crate::keybinding::{convert_keyevent, KeyEvent};
+use crate::keybinding::{convert_keyevent, KeyCode};
 
 #[cfg(feature = "rustyline-support")]
 use crate::shell::Helper;
@@ -19,7 +20,8 @@ use rustyline::{
     config::Configurer,
     config::{ColorMode, CompletionType, Config},
     error::ReadlineError,
-    At, Cmd, Editor, Movement, Word,
+    line_buffer::LineBuffer,
+    At, Cmd, ConditionalEventHandler, Editor, EventHandler, Modifiers, Movement, Word,
 };
 
 #[cfg(feature = "rustyline-support")]
@@ -30,12 +32,40 @@ pub fn convert_rustyline_result_to_string(input: Result<String, ReadlineError>)
         Err(ReadlineError::Interrupted) => LineResult::CtrlC,
         Err(ReadlineError::Eof) => LineResult::CtrlD,
         Err(err) => {
-            outln!("Error: {:?}", err);
+            eprintln!("Error: {:?}", err);
             LineResult::Break
         }
     }
 }
 
+#[derive(Clone)]
+#[cfg(feature = "rustyline-support")]
+struct PartialCompleteHintHandler;
+
+#[cfg(feature = "rustyline-support")]
+impl ConditionalEventHandler for PartialCompleteHintHandler {
+    fn handle(
+        &self,
+        _evt: &rustyline::Event,
+        _n: rustyline::RepeatCount,
+        _positive: bool,
+        ctx: &rustyline::EventContext,
+    ) -> Option<Cmd> {
+        Some(match ctx.hint_text() {
+            Some(hint_text) if ctx.pos() == ctx.line().len() => {
+                let mut line_buffer = LineBuffer::with_capacity(hint_text.len());
+                line_buffer.update(hint_text, 0);
+                line_buffer.move_to_next_word(At::AfterEnd, Word::Vi, 1);
+
+                let text = hint_text[0..line_buffer.pos()].to_string();
+
+                Cmd::Insert(1, text)
+            }
+            _ => Cmd::Move(Movement::ForwardWord(1, At::AfterEnd, Word::Vi)),
+        })
+    }
+}
+
 #[cfg(feature = "rustyline-support")]
 pub fn default_rustyline_editor_configuration() -> Editor<Helper> {
     #[cfg(windows)]
@@ -50,18 +80,20 @@ pub fn default_rustyline_editor_configuration() -> Editor<Helper> {
     let mut rl: Editor<_> = Editor::with_config(config);
 
     // add key bindings to move over a whole word with Ctrl+ArrowLeft and Ctrl+ArrowRight
+    //M modifier, E KeyEvent, K KeyCode
     rl.bind_sequence(
-        convert_keyevent(KeyEvent::ControlLeft),
+        convert_keyevent(KeyCode::Left, Some(Modifiers::CTRL)),
         Cmd::Move(Movement::BackwardWord(1, Word::Vi)),
     );
+
     rl.bind_sequence(
-        convert_keyevent(KeyEvent::ControlRight),
-        Cmd::Move(Movement::ForwardWord(1, At::AfterEnd, Word::Vi)),
+        convert_keyevent(KeyCode::Right, Some(Modifiers::CTRL)),
+        EventHandler::Conditional(Box::new(PartialCompleteHintHandler)),
     );
 
     // workaround for multiline-paste hang in rustyline (see https://github.com/kkawakam/rustyline/issues/202)
     rl.bind_sequence(
-        convert_keyevent(KeyEvent::BracketedPasteStart),
+        convert_keyevent(KeyCode::BracketedPasteStart, None),
         rustyline::Cmd::Noop,
     );
     // Let's set the defaults up front and then override them later if the user indicates
@@ -202,7 +234,7 @@ pub fn configure_rustyline_editor(
 
 #[cfg(feature = "rustyline-support")]
 pub fn nu_line_editor_helper(
-    context: &mut EvaluationContext,
+    context: &EvaluationContext,
     config: &dyn nu_data::config::Conf,
 ) -> crate::shell::Helper {
     let hinter = rustyline_hinter(config);
@@ -215,7 +247,7 @@ pub fn rustyline_hinter(
 ) -> Option<rustyline::hint::HistoryHinter> {
     if let Some(line_editor_vars) = config.var("line_editor") {
         for (idx, value) in line_editor_vars.row_entries() {
-            if idx == "show_hints" && value.expect_string() == "false" {
+            if idx == "show_hints" && value.as_bool() == Ok(false) {
                 return None;
             }
         }
@@ -224,17 +256,17 @@ pub fn rustyline_hinter(
     Some(rustyline::hint::HistoryHinter {})
 }
 
-pub fn configure_ctrl_c(_context: &mut EvaluationContext) -> Result<(), Box<dyn Error>> {
+pub fn configure_ctrl_c(_context: &EvaluationContext) -> Result<(), Box<dyn Error>> {
     #[cfg(feature = "ctrlc")]
     {
-        let cc = _context.ctrl_c.clone();
+        let cc = _context.ctrl_c().clone();
 
         ctrlc::set_handler(move || {
             cc.store(true, Ordering::SeqCst);
         })?;
 
-        if _context.ctrl_c.load(Ordering::SeqCst) {
-            _context.ctrl_c.store(false, Ordering::SeqCst);
+        if _context.ctrl_c().load(Ordering::SeqCst) {
+            _context.ctrl_c().store(false, Ordering::SeqCst);
         }
     }
 

crates/nu-cli/src/prelude.rs

@@ -1,92 +0,0 @@
-#[macro_export]
-macro_rules! return_err {
-    ($expr:expr) => {
-        match $expr {
-            Err(_) => return,
-            Ok(expr) => expr,
-        };
-    };
-}
-
-#[macro_export]
-macro_rules! stream {
-    ($($expr:expr),*) => {{
-        let mut v = VecDeque::new();
-
-        $(
-            v.push_back($expr);
-        )*
-
-        v
-    }}
-}
-
-#[macro_export]
-macro_rules! trace_out_stream {
-    (target: $target:tt, $desc:tt = $expr:expr) => {{
-        if log::log_enabled!(target: $target, log::Level::Trace) {
-            use futures::stream::StreamExt;
-
-            let objects = $expr.inspect(move |o| {
-                trace!(
-                    target: $target,
-                    "{} = {}",
-                    $desc,
-                    match o {
-                        Err(err) => format!("{:?}", err),
-                        Ok(value) => value.display(),
-                    }
-                );
-            });
-
-            nu_stream::OutputStream::new(objects)
-        } else {
-            $expr
-        }
-    }};
-}
-
-pub(crate) use futures::{Stream, StreamExt};
-pub(crate) use nu_engine::Host;
-#[allow(unused_imports)]
-pub(crate) use nu_errors::ShellError;
-#[allow(unused_imports)]
-pub(crate) use nu_protocol::outln;
-pub(crate) use nu_stream::OutputStream;
-#[allow(unused_imports)]
-pub(crate) use nu_value_ext::ValueExt;
-#[allow(unused_imports)]
-pub(crate) use std::sync::atomic::Ordering;
-
-#[allow(clippy::clippy::wrong_self_convention)]
-pub trait FromInputStream {
-    fn from_input_stream(self) -> OutputStream;
-}
-
-impl<T> FromInputStream for T
-where
-    T: Stream<Item = nu_protocol::Value> + Send + 'static,
-{
-    fn from_input_stream(self) -> OutputStream {
-        OutputStream {
-            values: self.map(nu_protocol::ReturnSuccess::value).boxed(),
-        }
-    }
-}
-
-#[allow(clippy::clippy::wrong_self_convention)]
-pub trait ToOutputStream {
-    fn to_output_stream(self) -> OutputStream;
-}
-
-impl<T, U> ToOutputStream for T
-where
-    T: Stream<Item = U> + Send + 'static,
-    U: Into<nu_protocol::ReturnValue>,
-{
-    fn to_output_stream(self) -> OutputStream {
-        OutputStream {
-            values: self.map(|item| item.into()).boxed(),
-        }
-    }
-}

crates/nu-cli/src/shell.rs

@@ -1,9 +1,234 @@
-#![allow(clippy::module_inception)]
+use nu_ansi_term::Color;
+use nu_completion::NuCompleter;
+use nu_engine::{DefaultPalette, EvaluationContext, Painter};
+use nu_source::{Tag, Tagged};
+use std::borrow::Cow::{self, Owned};
 
-#[cfg(feature = "rustyline-support")]
-pub(crate) mod completer;
-#[cfg(feature = "rustyline-support")]
-pub(crate) mod helper;
+pub struct Helper {
+    completer: NuCompleter,
+    hinter: Option<rustyline::hint::HistoryHinter>,
+    context: EvaluationContext,
+    pub colored_prompt: String,
+    validator: NuValidator,
+}
 
-#[cfg(feature = "rustyline-support")]
-pub(crate) use helper::Helper;
+impl Helper {
+    pub(crate) fn new(
+        context: EvaluationContext,
+        hinter: Option<rustyline::hint::HistoryHinter>,
+    ) -> Helper {
+        Helper {
+            completer: NuCompleter {},
+            hinter,
+            context,
+            colored_prompt: String::new(),
+            validator: NuValidator {},
+        }
+    }
+}
+
+use nu_protocol::{SignatureRegistry, VariableRegistry};
+struct CompletionContext<'a>(&'a EvaluationContext);
+
+impl<'a> nu_completion::CompletionContext for CompletionContext<'a> {
+    fn signature_registry(&self) -> &dyn SignatureRegistry {
+        &self.0.scope
+    }
+
+    fn scope(&self) -> &dyn nu_parser::ParserScope {
+        &self.0.scope
+    }
+
+    fn source(&self) -> &EvaluationContext {
+        self.as_ref()
+    }
+
+    fn variable_registry(&self) -> &dyn VariableRegistry {
+        self.0
+    }
+}
+
+impl<'a> AsRef<EvaluationContext> for CompletionContext<'a> {
+    fn as_ref(&self) -> &EvaluationContext {
+        self.0
+    }
+}
+
+pub struct CompletionSuggestion(nu_completion::Suggestion);
+
+impl rustyline::completion::Candidate for CompletionSuggestion {
+    fn display(&self) -> &str {
+        &self.0.display
+    }
+
+    fn replacement(&self) -> &str {
+        &self.0.replacement
+    }
+}
+
+impl rustyline::completion::Completer for Helper {
+    type Candidate = CompletionSuggestion;
+
+    fn complete(
+        &self,
+        line: &str,
+        pos: usize,
+        _ctx: &rustyline::Context<'_>,
+    ) -> Result<(usize, Vec<Self::Candidate>), rustyline::error::ReadlineError> {
+        let ctx = CompletionContext(&self.context);
+        let (position, suggestions) = self.completer.complete(line, pos, &ctx);
+        let suggestions = suggestions.into_iter().map(CompletionSuggestion).collect();
+        Ok((position, suggestions))
+    }
+
+    fn update(&self, line: &mut rustyline::line_buffer::LineBuffer, start: usize, elected: &str) {
+        let end = line.pos();
+        line.replace(start..end, elected)
+    }
+}
+
+impl rustyline::hint::Hinter for Helper {
+    type Hint = String;
+    fn hint(&self, line: &str, pos: usize, ctx: &rustyline::Context<'_>) -> Option<String> {
+        match &self.hinter {
+            Some(the_hinter) => the_hinter.hint(line, pos, ctx),
+            None => Some("".to_string()),
+        }
+    }
+}
+
+impl rustyline::highlight::Highlighter for Helper {
+    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
+        &'s self,
+        prompt: &'p str,
+        default: bool,
+    ) -> Cow<'b, str> {
+        use std::borrow::Cow::Borrowed;
+
+        if default {
+            Borrowed(&self.colored_prompt)
+        } else {
+            Borrowed(prompt)
+        }
+    }
+
+    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
+        Owned(Color::DarkGray.prefix().to_string() + hint + nu_ansi_term::ansi::RESET)
+    }
+
+    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
+        let cfg = &self.context.configs().lock();
+        if let Some(palette) = &cfg.syntax_config {
+            Painter::paint_string(line, &self.context.scope, palette)
+        } else {
+            Painter::paint_string(line, &self.context.scope, &DefaultPalette {})
+        }
+    }
+
+    fn highlight_char(&self, _line: &str, _pos: usize) -> bool {
+        true
+    }
+}
+
+impl rustyline::validate::Validator for Helper {
+    fn validate(
+        &self,
+        ctx: &mut rustyline::validate::ValidationContext,
+    ) -> rustyline::Result<rustyline::validate::ValidationResult> {
+        self.validator.validate(ctx)
+    }
+
+    fn validate_while_typing(&self) -> bool {
+        self.validator.validate_while_typing()
+    }
+}
+
+struct NuValidator {}
+
+impl rustyline::validate::Validator for NuValidator {
+    fn validate(
+        &self,
+        ctx: &mut rustyline::validate::ValidationContext,
+    ) -> rustyline::Result<rustyline::validate::ValidationResult> {
+        let src = ctx.input();
+
+        let (tokens, err) = nu_parser::lex(src, 0, nu_parser::NewlineMode::Normal);
+        if let Some(err) = err {
+            if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
+                return Ok(rustyline::validate::ValidationResult::Incomplete);
+            }
+        }
+
+        let (_, err) = nu_parser::parse_block(tokens);
+
+        if let Some(err) = err {
+            if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
+                return Ok(rustyline::validate::ValidationResult::Incomplete);
+            }
+        }
+
+        Ok(rustyline::validate::ValidationResult::Valid(None))
+    }
+}
+
+#[allow(unused)]
+fn vec_tag<T>(input: Vec<Tagged<T>>) -> Option<Tag> {
+    let mut iter = input.iter();
+    let first = iter.next()?.tag.clone();
+    let last = iter.last();
+
+    Some(match last {
+        None => first,
+        Some(last) => first.until(&last.tag),
+    })
+}
+
+impl rustyline::Helper for Helper {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use nu_engine::EvaluationContext;
+    use rustyline::completion::Completer;
+    use rustyline::line_buffer::LineBuffer;
+
+    #[ignore]
+    #[test]
+    fn closing_quote_should_replaced() {
+        let text = "cd \"folder with spaces\\subdirectory\\\"";
+        let replacement = "\"folder with spaces\\subdirectory\\subsubdirectory\\\"";
+
+        let mut buffer = LineBuffer::with_capacity(256);
+        buffer.insert_str(0, text);
+        buffer.set_pos(text.len() - 1);
+
+        let helper = Helper::new(EvaluationContext::basic(), None);
+
+        helper.update(&mut buffer, "cd ".len(), replacement);
+
+        assert_eq!(
+            buffer.as_str(),
+            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
+        );
+    }
+
+    #[ignore]
+    #[test]
+    fn replacement_with_cursor_in_text() {
+        let text = "cd \"folder with spaces\\subdirectory\\\"";
+        let replacement = "\"folder with spaces\\subdirectory\\subsubdirectory\\\"";
+
+        let mut buffer = LineBuffer::with_capacity(256);
+        buffer.insert_str(0, text);
+        buffer.set_pos(text.len() - 30);
+
+        let helper = Helper::new(EvaluationContext::basic(), None);
+
+        helper.update(&mut buffer, "cd ".len(), replacement);
+
+        assert_eq!(
+            buffer.as_str(),
+            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
+        );
+    }
+}

crates/nu-cli/src/shell/helper.rs

@@ -1,194 +0,0 @@
-use crate::completion;
-use crate::shell::completer::NuCompleter;
-use nu_engine::{DefaultPalette, EvaluationContext, Painter};
-use nu_source::{Tag, Tagged};
-use std::borrow::Cow::{self, Owned};
-
-pub struct Helper {
-    completer: NuCompleter,
-    hinter: Option<rustyline::hint::HistoryHinter>,
-    context: EvaluationContext,
-    pub colored_prompt: String,
-    validator: NuValidator,
-}
-
-impl Helper {
-    pub(crate) fn new(
-        context: EvaluationContext,
-        hinter: Option<rustyline::hint::HistoryHinter>,
-    ) -> Helper {
-        Helper {
-            completer: NuCompleter {},
-            hinter,
-            context,
-            colored_prompt: String::new(),
-            validator: NuValidator {},
-        }
-    }
-}
-
-impl rustyline::completion::Candidate for completion::Suggestion {
-    fn display(&self) -> &str {
-        &self.display
-    }
-
-    fn replacement(&self) -> &str {
-        &self.replacement
-    }
-}
-
-impl rustyline::completion::Completer for Helper {
-    type Candidate = completion::Suggestion;
-
-    fn complete(
-        &self,
-        line: &str,
-        pos: usize,
-        _ctx: &rustyline::Context<'_>,
-    ) -> Result<(usize, Vec<Self::Candidate>), rustyline::error::ReadlineError> {
-        let ctx = completion::CompletionContext::new(&self.context);
-        Ok(self.completer.complete(line, pos, &ctx))
-    }
-
-    fn update(&self, line: &mut rustyline::line_buffer::LineBuffer, start: usize, elected: &str) {
-        let end = line.pos();
-        line.replace(start..end, elected)
-    }
-}
-
-impl rustyline::hint::Hinter for Helper {
-    type Hint = String;
-    fn hint(&self, line: &str, pos: usize, ctx: &rustyline::Context<'_>) -> Option<String> {
-        self.hinter.as_ref().and_then(|h| h.hint(line, pos, &ctx))
-    }
-}
-
-impl rustyline::highlight::Highlighter for Helper {
-    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
-        &'s self,
-        prompt: &'p str,
-        default: bool,
-    ) -> Cow<'b, str> {
-        use std::borrow::Cow::Borrowed;
-
-        if default {
-            Borrowed(&self.colored_prompt)
-        } else {
-            Borrowed(prompt)
-        }
-    }
-
-    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
-        Owned("\x1b[1m".to_owned() + hint + "\x1b[m")
-    }
-
-    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
-        Painter::paint_string(line, &self.context.scope, &DefaultPalette {})
-    }
-
-    fn highlight_char(&self, _line: &str, _pos: usize) -> bool {
-        true
-    }
-}
-
-impl rustyline::validate::Validator for Helper {
-    fn validate(
-        &self,
-        ctx: &mut rustyline::validate::ValidationContext,
-    ) -> rustyline::Result<rustyline::validate::ValidationResult> {
-        self.validator.validate(ctx)
-    }
-
-    fn validate_while_typing(&self) -> bool {
-        self.validator.validate_while_typing()
-    }
-}
-
-struct NuValidator {}
-
-impl rustyline::validate::Validator for NuValidator {
-    fn validate(
-        &self,
-        ctx: &mut rustyline::validate::ValidationContext,
-    ) -> rustyline::Result<rustyline::validate::ValidationResult> {
-        let src = ctx.input();
-
-        let (tokens, err) = nu_parser::lex(src, 0);
-        if let Some(err) = err {
-            if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
-                return Ok(rustyline::validate::ValidationResult::Incomplete);
-            }
-        }
-
-        let (_, err) = nu_parser::parse_block(tokens);
-
-        if let Some(err) = err {
-            if let nu_errors::ParseErrorReason::Eof { .. } = err.reason() {
-                return Ok(rustyline::validate::ValidationResult::Incomplete);
-            }
-        }
-
-        Ok(rustyline::validate::ValidationResult::Valid(None))
-    }
-}
-
-#[allow(unused)]
-fn vec_tag<T>(input: Vec<Tagged<T>>) -> Option<Tag> {
-    let mut iter = input.iter();
-    let first = iter.next()?.tag.clone();
-    let last = iter.last();
-
-    Some(match last {
-        None => first,
-        Some(last) => first.until(&last.tag),
-    })
-}
-
-impl rustyline::Helper for Helper {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use rustyline::completion::Completer;
-    use rustyline::line_buffer::LineBuffer;
-
-    #[ignore]
-    #[test]
-    fn closing_quote_should_replaced() {
-        let text = "cd \"folder with spaces\\subdirectory\\\"";
-        let replacement = "\"folder with spaces\\subdirectory\\subsubdirectory\\\"";
-
-        let mut buffer = LineBuffer::with_capacity(256);
-        buffer.insert_str(0, text);
-        buffer.set_pos(text.len() - 1);
-
-        let helper = Helper::new(EvaluationContext::basic().unwrap(), None);
-
-        helper.update(&mut buffer, "cd ".len(), &replacement);
-
-        assert_eq!(
-            buffer.as_str(),
-            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
-        );
-    }
-
-    #[ignore]
-    #[test]
-    fn replacement_with_cursor_in_text() {
-        let text = "cd \"folder with spaces\\subdirectory\\\"";
-        let replacement = "\"folder with spaces\\subdirectory\\subsubdirectory\\\"";
-
-        let mut buffer = LineBuffer::with_capacity(256);
-        buffer.insert_str(0, text);
-        buffer.set_pos(text.len() - 30);
-
-        let helper = Helper::new(EvaluationContext::basic().unwrap(), None);
-
-        helper.update(&mut buffer, "cd ".len(), &replacement);
-
-        assert_eq!(
-            buffer.as_str(),
-            "cd \"folder with spaces\\subdirectory\\subsubdirectory\\\""
-        );
-    }
-}

crates/nu-command/Cargo.toml

@@ -5,104 +5,103 @@ description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
 name = "nu-command"
-version = "0.29.0"
+version = "0.35.0"
 
 [lib]
 doctest = false
 
 [dependencies]
-nu-data = { version = "0.29.0", path = "../nu-data" }
-nu-engine = { version = "0.29.0", path = "../nu-engine" }
-nu-errors = { version = "0.29.0", path = "../nu-errors" }
-nu-json = { version = "0.29.0", path = "../nu-json" }
-nu-parser = { version = "0.29.0", path = "../nu-parser" }
-nu-plugin = { version = "0.29.0", path = "../nu-plugin" }
-nu-protocol = { version = "0.29.0", path = "../nu-protocol" }
-nu-source = { version = "0.29.0", path = "../nu-source" }
-nu-stream = { version = "0.29.0", path = "../nu-stream" }
-nu-table = { version = "0.29.0", path = "../nu-table" }
-nu-test-support = { version = "0.29.0", path = "../nu-test-support" }
-nu-value-ext = { version = "0.29.0", path = "../nu-value-ext" }
-nu-ansi-term = { version = "0.29.0", path = "../nu-ansi-term" }
+nu-data = { version = "0.35.0", path="../nu-data" }
+nu-engine = { version = "0.35.0", path="../nu-engine" }
+nu-errors = { version = "0.35.0", path="../nu-errors" }
+nu-json = { version = "0.35.0", path="../nu-json" }
+nu-path = { version = "0.35.0", path="../nu-path" }
+nu-parser = { version = "0.35.0", path="../nu-parser" }
+nu-plugin = { version = "0.35.0", path="../nu-plugin" }
+nu-protocol = { version = "0.35.0", path="../nu-protocol" }
+nu-source = { version = "0.35.0", path="../nu-source" }
+nu-stream = { version = "0.35.0", path="../nu-stream" }
+nu-table = { version = "0.35.0", path="../nu-table" }
+nu-test-support = { version = "0.35.0", path="../nu-test-support" }
+nu-value-ext = { version = "0.35.0", path="../nu-value-ext" }
+nu-ansi-term = { version = "0.35.0", path="../nu-ansi-term" }
+nu-pretty-hex = { version = "0.35.0", path="../nu-pretty-hex" }
 
 Inflector = "0.11"
-arboard = { version = "1.1.0", optional = true }
-async-recursion = "0.3.2"
-async-trait = "0.1.42"
+arboard = { version="1.1.0", optional=true }
 base64 = "0.13.0"
-bigdecimal = { version = "0.2.0", features = ["serde"] }
+bigdecimal = { version="0.2.0", features=["serde"] }
 byte-unit = "4.0.9"
 bytes = "1.0.1"
-calamine = "0.17.0"
-chrono = { version = "0.4.19", features = ["serde"] }
+calamine = "0.18.0"
+chrono = { version="0.4.19", features=["serde"] }
 chrono-tz = "0.5.3"
-clap = "2.33.3"
 codespan-reporting = "0.11.0"
-crossterm = { version = "0.19.0", optional = true }
+crossterm = { version="0.19.0", optional=true }
 csv = "1.1.3"
-ctrlc = { version = "3.1.7", optional = true }
+ctrlc = { version="3.1.7", optional=true }
 derive-new = "0.5.8"
-directories-next = { version = "2.0.0", optional = true }
-dirs-next = { version = "2.0.0", optional = true }
+directories-next = "2.0.0"
+dirs-next = "2.0.0"
 dtparse = "1.2.0"
 dunce = "1.0.1"
 eml-parser = "0.1.0"
 encoding_rs = "0.8.28"
 filesize = "0.2.0"
 fs_extra = "1.2.0"
-futures = { version = "0.3.12", features = ["compat", "io-compat"] }
-futures-util = "0.3.12"
-futures_codec = "0.4.1"
+futures = { version="0.3.12", features=["compat", "io-compat"] }
 getset = "0.1.1"
 glob = "0.3.0"
 htmlescape = "0.3.1"
 ical = "0.7.0"
-ichwh = { version = "0.3.4", optional = true }
-indexmap = { version = "1.6.1", features = ["serde-1"] }
+indexmap = { version="1.7", features=["serde-1"] }
 itertools = "0.10.0"
 lazy_static = "1.*"
 log = "0.4.14"
-md5 = "0.7.0"
+md-5 = "0.9.1"
 meval = "0.2.0"
-minus = { version = "3.3.0", optional = true, features = ["async_std_lib", "search"] }
-num-bigint = { version = "0.3.1", features = ["serde"] }
-num-format = { version = "0.4.0", features = ["with-num-bigint"] }
+minus = { version="3.4.0", optional=true, features=["async_std_lib", "search"] }
+num-bigint = { version="0.3.1", features=["serde"] }
+num-format = { version="0.4.0", features=["with-num-bigint"] }
 num-traits = "0.2.14"
 parking_lot = "0.11.1"
 pin-utils = "0.1.0"
-pretty-hex = "0.2.1"
-ptree = { version = "0.3.1", optional = true }
 query_interface = "0.3.5"
-quick-xml = "0.21.0"
-rand = "0.7.3"
+quick-xml = "0.22"
+rand = "0.8"
 rayon = "1.5.0"
 regex = "1.4.3"
 roxmltree = "0.14.0"
 rust-embed = "5.9.0"
-rustyline = { version = "8.0.0", optional = true }
-serde = { version = "1.0.123", features = ["derive"] }
+rustyline = { version="8.1.0", optional=true }
+serde = { version="1.0.123", features=["derive"] }
 serde_bytes = "0.11.5"
 serde_ini = "0.2.0"
 serde_json = "1.0.61"
 serde_urlencoded = "0.7.0"
 serde_yaml = "0.8.16"
 sha2 = "0.9.3"
-shellexpand = "2.1.0"
 strip-ansi-escapes = "0.1.0"
 sxd-document = "0.3.2"
 sxd-xpath = "0.4.2"
 tempfile = "3.2.0"
-term = { version = "0.7.0", optional = true }
+term = { version="0.7.0", optional=true }
 term_size = "0.3.2"
 termcolor = "1.1.2"
 titlecase = "1.1.0"
 toml = "0.5.8"
-trash = { version = "1.3.0", optional = true }
-unicode-segmentation = "1.7.1"
+trash = { version="1.3.0", optional=true }
+unicode-segmentation = "1.8"
 url = "2.2.0"
-uuid_crate = { package = "uuid", version = "0.8.2", features = ["v4"], optional = true }
-which = { version = "4.0.2", optional = true }
-zip = { version = "0.5.9", optional = true }
+uuid_crate = { package="uuid", version="0.8.2", features=["v4"], optional=true }
+which = { version="4.1.0", optional=true }
+zip = { version="0.5.9", optional=true }
+digest = "0.9.0"
+
+[dependencies.polars]
+version = "0.14.8"
+optional = true
+features = ["parquet", "json", "random", "pivot", "strings", "is_in"]
 
 [target.'cfg(unix)'.dependencies]
 umask = "1.0.0"
@@ -117,10 +116,10 @@ users = "0.11.0"
 [dependencies.rusqlite]
 features = ["bundled", "blob"]
 optional = true
-version = "0.24.2"
+version = "0.25.3"
 
 [build-dependencies]
-shadow-rs = "0.5"
+shadow-rs = "0.6"
 
 [dev-dependencies]
 quickcheck = "1.0.3"
@@ -132,6 +131,5 @@ clipboard-cli = ["arboard"]
 rustyline-support = ["rustyline"]
 stable = []
 trash-support = ["trash"]
-directories = ["directories-next"]
-dirs = ["dirs-next"]
 table-pager = ["minus", "crossterm"]
+dataframe = ["nu-protocol/dataframe", "polars"]

crates/nu-command/README.md

@@ -0,0 +1,7 @@
+# nu-command
+
+The Nu command crate contains the full set of internal commands, that is, the commands that can be form the set of built-in commands in a Nushell engine.
+
+The default set of commands that Nushell ships with can be found in the [default context](src/default_context.rs).
+
+The commands themselves live in the [commands module](src/commands/).

crates/nu-command/src/classified/external.rs

@@ -0,0 +1,658 @@
+use crate::prelude::*;
+use nu_engine::{evaluate_baseline_expr, BufCodecReader};
+use nu_engine::{MaybeTextCodec, StringOrBinary};
+use nu_test_support::NATIVE_PATH_ENV_VAR;
+use parking_lot::Mutex;
+
+use std::io::Write;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+use std::{borrow::Cow, io::BufReader};
+
+use log::trace;
+
+use nu_errors::ShellError;
+use nu_protocol::hir::Expression;
+use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
+use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
+use nu_source::Tag;
+
+pub(crate) fn run_external_command(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    trace!(target: "nu::run::external", "-> {}", command.name);
+
+    context.sync_path_to_env();
+    if !context.host().lock().is_external_cmd(&command.name) {
+        return Err(ShellError::labeled_error(
+            "Command not found",
+            format!("command {} not found", &command.name),
+            &command.name_tag,
+        ));
+    }
+
+    run_with_stdin(command, context, input, external_redirection)
+}
+
+#[allow(unused)]
+fn trim_double_quotes(input: &str) -> String {
+    let mut chars = input.chars();
+
+    match (chars.next(), chars.next_back()) {
+        (Some('"'), Some('"')) => chars.collect(),
+        _ => input.to_string(),
+    }
+}
+
+#[allow(unused)]
+fn escape_where_needed(input: &str) -> String {
+    input.split(' ').join("\\ ").split('\'').join("\\'")
+}
+
+fn run_with_stdin(
+    command: ExternalCommand,
+    context: &mut EvaluationContext,
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+) -> Result<InputStream, ShellError> {
+    let path = context.shell_manager().path();
+
+    let mut command_args = vec![];
+    for arg in command.args.iter() {
+        let is_literal = matches!(arg.expr, Expression::Literal(_));
+        let value = evaluate_baseline_expr(arg, context)?;
+
+        // 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(),
+                                is_literal,
+                            ));
+                        }
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Could not convert to positional arguments",
+                                "could not convert to positional arguments",
+                                value.tag(),
+                            ));
+                        }
+                    }
+                }
+            }
+            _ => {
+                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
+                //let trimmed_value_string = trim_quotes(&trimmed_value_string);
+                command_args.push((trimmed_value_string, is_literal));
+            }
+        }
+    }
+
+    let process_args = command_args
+        .iter()
+        .map(|(arg, _is_literal)| {
+            let arg = nu_path::expand_tilde_string(Cow::Borrowed(arg));
+
+            #[cfg(not(windows))]
+            {
+                if !_is_literal {
+                    let escaped = escape_double_quotes(&arg);
+                    add_double_quotes(&escaped)
+                } else {
+                    let trimmed = trim_double_quotes(&arg);
+                    if trimmed != arg {
+                        escape_where_needed(&trimmed)
+                    } else {
+                        trimmed
+                    }
+                }
+            }
+            #[cfg(windows)]
+            {
+                if let Some(unquoted) = remove_quotes(&arg) {
+                    unquoted.to_string()
+                } else {
+                    arg.to_string()
+                }
+            }
+        })
+        .collect::<Vec<String>>();
+
+    spawn(
+        &command,
+        &path,
+        &process_args[..],
+        input,
+        external_redirection,
+        &context.scope,
+    )
+}
+
+fn spawn(
+    command: &ExternalCommand,
+    path: &str,
+    args: &[String],
+    input: InputStream,
+    external_redirection: ExternalRedirection,
+    scope: &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:
+                // https://stackoverflow.com/questions/1200235/how-to-pass-a-quoted-pipe-character-to-cmd-exe
+                // cmd.exe needs to have a caret to escape a pipe
+                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.get_env_vars());
+
+    // 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
+    match process.spawn() {
+        Ok(mut child) => {
+            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 input {
+                        match &value.value {
+                            UntaggedValue::Primitive(Primitive::Nothing) => continue,
+                            UntaggedValue::Primitive(Primitive::String(s)) => {
+                                if stdin_write.write(s.as_bytes()).is_err() {
+                                    // Other side has closed, so exit
+                                    return Ok(());
+                                }
+                            }
+                            UntaggedValue::Primitive(Primitive::Binary(b)) => {
+                                if stdin_write.write(b).is_err() {
+                                    // Other side has closed, so exit
+                                    return Ok(());
+                                }
+                            }
+                            unsupported => {
+                                println!("Unsupported: {:?}", unsupported);
+                                let _ = stdin_write_tx.send(Ok(Value {
+                                    value: UntaggedValue::Error(ShellError::labeled_error(
+                                        format!(
+                                            "Received unexpected type from pipeline ({})",
+                                            unsupported.type_name()
+                                        ),
+                                        format!(
+                                            "expected a string, got {} as input",
+                                            unsupported.type_name()
+                                        ),
+                                        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());
+                    let buf_read = BufReader::new(stdout);
+                    let buf_codec = BufCodecReader::new(buf_read, MaybeTextCodec::default());
+
+                    for line in buf_codec {
+                        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());
+                    let buf_reader = BufReader::new(stderr);
+                    let buf_codec = BufCodecReader::new(buf_reader, MaybeTextCodec::default());
+
+                    for line in buf_codec {
+                        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::nothing(),
+                        tag: stdout_name_tag,
+                    }));
+                }
+
+                Ok(())
+            });
+
+            let stream = ChannelReceiver::new(rx);
+            Ok(stream.into_input_stream())
+        }
+        Err(e) => Err(ShellError::labeled_error(
+            format!("{}", e),
+            "failed to spawn",
+            &command.name_tag,
+        )),
+    }
+}
+
+struct ChannelReceiver {
+    rx: Arc<Mutex<mpsc::Receiver<Result<Value, ShellError>>>>,
+}
+
+impl ChannelReceiver {
+    pub fn new(rx: mpsc::Receiver<Result<Value, ShellError>>) -> Self {
+        Self {
+            rx: Arc::new(Mutex::new(rx)),
+        }
+    }
+}
+
+impl Iterator for ChannelReceiver {
+    type Item = Result<Value, ShellError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let rx = self.rx.lock();
+        match rx.recv() {
+            Ok(v) => Some(v),
+            Err(_) => None,
+        }
+    }
+}
+
+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_double_quotes(argument: &str) -> String {
+    format!("\"{}\"", argument)
+}
+
+#[allow(unused)]
+fn escape_double_quotes(argument: &str) -> Cow<'_, str> {
+    // allocate new string only if required
+    if argument.contains('"') {
+        Cow::Owned(argument.replace('"', r#"\""#))
+    } else {
+        Cow::Borrowed(argument)
+    }
+}
+
+#[allow(unused)]
+fn remove_quotes(argument: &str) -> Option<&str> {
+    if !argument_is_quoted(argument) {
+        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(NATIVE_PATH_ENV_VAR) {
+        original_paths = std::env::split_paths(&paths).collect::<Vec<_>>();
+    }
+
+    original_paths
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{add_double_quotes, argument_is_quoted, escape_double_quotes, remove_quotes};
+    #[cfg(feature = "which")]
+    use super::{run_external_command, InputStream};
+
+    #[cfg(feature = "which")]
+    use nu_engine::EvaluationContext;
+
+    #[cfg(feature = "which")]
+    use nu_test_support::commands::ExternalBuilder;
+    // fn read(mut stream: OutputStream) -> Option<Value> {
+    //     match stream.try_next() {
+    //         Ok(val) => {
+    //             if let Some(val) = val {
+    //                 val.raw_value()
+    //             } else {
+    //                 None
+    //             }
+    //         }
+    //         Err(_) => None,
+    //     }
+    // }
+
+    #[cfg(feature = "which")]
+    fn non_existent_run() {
+        use nu_protocol::hir::ExternalRedirection;
+        let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
+
+        let input = InputStream::empty();
+        let mut ctx = EvaluationContext::basic();
+
+        assert!(run_external_command(cmd, &mut ctx, input, ExternalRedirection::Stdout).is_err());
+    }
+
+    // fn failure_run() -> Result<(), ShellError> {
+    //     let cmd = ExternalBuilder::for_name("fail").build();
+
+    //     let mut ctx = crate::cli::EvaluationContext::basic().expect("There was a problem creating a basic context.");
+    //     let stream = run_external_command(cmd, &mut ctx, None, false)
+    //         ?
+    //         .expect("There was a problem running the external command.");
+
+    //     match read(stream.into()) {
+    //         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() {
+        non_existent_run()
+    }
+
+    #[test]
+    fn checks_escape_double_quotes() {
+        assert_eq!(escape_double_quotes("andrés"), "andrés");
+        assert_eq!(escape_double_quotes(r#"an"drés"#), r#"an\"drés"#);
+        assert_eq!(escape_double_quotes(r#""an"drés""#), r#"\"an\"drés\""#);
+    }
+
+    #[test]
+    fn checks_quotes_from_argument_to_be_passed_in() {
+        assert!(!argument_is_quoted(""));
+
+        assert!(!argument_is_quoted("'"));
+        assert!(!argument_is_quoted("'a"));
+        assert!(!argument_is_quoted("a"));
+        assert!(!argument_is_quoted("a'"));
+        assert!(argument_is_quoted("''"));
+
+        assert!(!argument_is_quoted(r#"""#));
+        assert!(!argument_is_quoted(r#""a"#));
+        assert!(!argument_is_quoted(r#"a"#));
+        assert!(!argument_is_quoted(r#"a""#));
+        assert!(argument_is_quoted(r#""""#));
+
+        assert!(!argument_is_quoted("'andrés"));
+        assert!(!argument_is_quoted("andrés'"));
+        assert!(!argument_is_quoted(r#""andrés"#));
+        assert!(!argument_is_quoted(r#"andrés""#));
+        assert!(argument_is_quoted("'andrés'"));
+        assert!(argument_is_quoted(r#""andrés""#));
+    }
+
+    #[test]
+    fn adds_double_quotes_to_argument_to_be_passed_in() {
+        assert_eq!(add_double_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"));
+    }
+}

crates/nu-command/src/commands.rs

@@ -1,365 +0,0 @@
-#[macro_use]
-pub(crate) mod macros;
-
-mod from_delimited_data;
-mod to_delimited_data;
-
-pub(crate) mod ansi;
-pub(crate) mod append;
-pub(crate) mod args;
-pub 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 compact;
-pub(crate) mod config;
-pub(crate) mod constants;
-pub(crate) mod cp;
-pub(crate) mod date;
-pub(crate) mod debug;
-pub(crate) mod def;
-pub(crate) mod default;
-pub mod default_context;
-pub(crate) mod describe;
-pub(crate) mod do_;
-pub(crate) mod drop;
-pub(crate) mod du;
-pub(crate) mod each;
-pub(crate) mod echo;
-pub(crate) mod empty;
-pub(crate) mod enter;
-pub(crate) mod every;
-pub(crate) mod exec;
-pub(crate) mod exit;
-pub(crate) mod first;
-pub(crate) mod flatten;
-pub(crate) mod format;
-pub(crate) mod from;
-pub(crate) mod from_csv;
-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 hash_;
-pub(crate) mod headers;
-pub(crate) mod help;
-pub(crate) mod histogram;
-pub(crate) mod history;
-pub(crate) mod if_;
-pub(crate) mod insert;
-pub(crate) mod into_int;
-pub(crate) mod keep;
-pub(crate) mod last;
-pub(crate) mod length;
-pub(crate) mod let_;
-pub(crate) mod let_env;
-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 roll;
-pub(crate) mod rotate;
-pub(crate) mod run_external;
-pub(crate) mod save;
-pub(crate) mod select;
-pub(crate) mod seq;
-pub(crate) mod seq_dates;
-pub(crate) mod shells;
-pub(crate) mod shuffle;
-pub(crate) mod size;
-pub(crate) mod skip;
-pub(crate) mod sleep;
-pub(crate) mod sort_by;
-pub(crate) mod source;
-pub(crate) mod split;
-pub(crate) mod split_by;
-pub(crate) mod str_;
-pub(crate) mod table;
-pub(crate) mod tags;
-pub(crate) mod termsize;
-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 ansi::Ansi;
-pub(crate) use ansi::AnsiStrip;
-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, ConfigPath, ConfigRemove, ConfigSet, ConfigSetInto,
-};
-pub(crate) use cp::Cpy;
-pub(crate) use date::{Date, DateFormat, DateListTimeZone, DateNow, DateToTable, DateToTimeZone};
-pub(crate) use debug::Debug;
-pub(crate) use def::Def;
-pub(crate) use default::Default;
-pub(crate) use describe::Describe;
-pub(crate) use do_::Do;
-pub(crate) use drop::{Drop, DropColumn};
-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 flatten::Command as Flatten;
-pub(crate) use format::{FileSize, Format};
-pub(crate) use from::From;
-pub(crate) use from_csv::FromCsv;
-pub(crate) use from_eml::FromEml;
-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::Command as Get;
-pub(crate) use group_by::Command as GroupBy;
-pub(crate) use group_by_date::GroupByDate;
-pub(crate) use hash_::{Hash, HashBase64, HashMd5};
-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 length::Length;
-pub(crate) use let_::Let;
-pub(crate) use let_env::LetEnv;
-pub(crate) use lines::Lines;
-pub(crate) use ls::Ls;
-pub(crate) use math::{
-    Math, MathAbs, MathAverage, MathCeil, MathEval, MathFloor, MathMaximum, MathMedian,
-    MathMinimum, MathMode, MathProduct, MathRound, MathStddev, MathSummation, MathVariance,
-};
-pub(crate) use merge::Merge;
-pub(crate) use mkdir::Mkdir;
-pub(crate) use move_::{Move, 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,
-    PathJoin, 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, RandomChars, RandomDecimal, RandomDice, RandomInteger,
-};
-pub(crate) use range::Range;
-pub(crate) use reduce::Reduce;
-pub(crate) use reject::Reject;
-pub(crate) use rename::Rename;
-pub(crate) use reverse::Reverse;
-pub(crate) use rm::Remove;
-pub(crate) use roll::{Roll, RollColumn, RollUp};
-pub(crate) use rotate::{Rotate, RotateCounterClockwise};
-pub(crate) use run_external::RunExternalCommand;
-pub(crate) use save::Save;
-pub(crate) use select::Command as Select;
-pub(crate) use seq::Seq;
-pub(crate) use seq_dates::SeqDates;
-pub(crate) use shells::Shells;
-pub(crate) use shuffle::Shuffle;
-pub(crate) use size::Size;
-pub(crate) use skip::{Skip, SkipUntil, SkipWhile};
-pub(crate) use sleep::Sleep;
-pub(crate) use sort_by::SortBy;
-pub(crate) use source::Source;
-pub(crate) use split::{Split, SplitChars, SplitColumn, SplitRow};
-pub(crate) use split_by::SplitBy;
-pub(crate) use str_::{
-    Str, StrCamelCase, StrCapitalize, StrCollect, StrContains, StrDowncase, StrEndsWith,
-    StrFindReplace, StrFrom, StrIndexOf, StrKebabCase, StrLPad, StrLength, StrPascalCase, StrRPad,
-    StrReverse, StrScreamingSnakeCase, StrSnakeCase, StrStartsWith, StrSubstring, StrToDatetime,
-    StrToDecimal, StrToInteger, StrTrim, StrTrimLeft, StrTrimRight, StrUpcase,
-};
-pub(crate) use table::Table;
-pub(crate) use tags::Tags;
-pub(crate) use termsize::TermSize;
-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::Command as 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::examples::{test_anchors, test_examples};
-    use nu_engine::{whole_stream_command, Command};
-    use nu_errors::ShellError;
-
-    fn full_tests() -> Vec<Command> {
-        vec![
-            whole_stream_command(Append),
-            whole_stream_command(GroupBy),
-            whole_stream_command(Insert),
-            whole_stream_command(Move),
-            whole_stream_command(Update),
-            whole_stream_command(Empty),
-            // whole_stream_command(Select),
-            // whole_stream_command(Get),
-            // Str Command Suite
-            whole_stream_command(Str),
-            whole_stream_command(StrToDecimal),
-            whole_stream_command(StrToInteger),
-            whole_stream_command(StrDowncase),
-            whole_stream_command(StrUpcase),
-            whole_stream_command(StrCapitalize),
-            whole_stream_command(StrFindReplace),
-            whole_stream_command(StrFrom),
-            whole_stream_command(StrSubstring),
-            whole_stream_command(StrToDatetime),
-            whole_stream_command(StrContains),
-            whole_stream_command(StrIndexOf),
-            whole_stream_command(StrTrim),
-            whole_stream_command(StrTrimLeft),
-            whole_stream_command(StrTrimRight),
-            whole_stream_command(StrStartsWith),
-            whole_stream_command(StrEndsWith),
-            //whole_stream_command(StrCollect),
-            whole_stream_command(StrLength),
-            whole_stream_command(StrLPad),
-            whole_stream_command(StrReverse),
-            whole_stream_command(StrRPad),
-            whole_stream_command(StrCamelCase),
-            whole_stream_command(StrPascalCase),
-            whole_stream_command(StrKebabCase),
-            whole_stream_command(StrSnakeCase),
-            whole_stream_command(StrScreamingSnakeCase),
-            whole_stream_command(ToMarkdown),
-        ]
-    }
-
-    fn only_examples() -> Vec<Command> {
-        let mut commands = full_tests();
-        commands.extend(vec![whole_stream_command(Flatten)]);
-        commands
-    }
-
-    #[test]
-    fn examples_work_as_expected() -> Result<(), ShellError> {
-        for cmd in only_examples() {
-            test_examples(cmd)?;
-        }
-
-        Ok(())
-    }
-
-    #[test]
-    fn tracks_metadata() -> Result<(), ShellError> {
-        for cmd in full_tests() {
-            test_anchors(cmd)?;
-        }
-
-        Ok(())
-    }
-}

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

@@ -1,91 +0,0 @@
-use crate::prelude::*;
-use nu_engine::WholeStreamCommand;
-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::{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: &Path, 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 {
-        "Manage directory specific environment variables and scripts."
-    }
-
-    fn extra_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#"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) -> Result<OutputStream, ShellError> {
-        Ok(OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::string(get_full_help(&Autoenv, &args.scope)).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-command/src/commands/char_.rs

@@ -1,199 +0,0 @@
-use crate::prelude::*;
-use nu_engine::WholeStreamCommand;
-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>,
-    rest: Vec<Tagged<String>>,
-    unicode: bool,
-}
-
-#[async_trait]
-impl WholeStreamCommand for Char {
-    fn name(&self) -> &str {
-        "char"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("char")
-            .required(
-                "character",
-                SyntaxShape::Any,
-                "the name of the character to output",
-            )
-            .rest(SyntaxShape::String, "multiple unicode bytes")
-            .switch("unicode", "unicode string i.e. 1f378", Some('u'))
-    }
-
-    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(),
-                ]),
-            },
-            Example {
-                description: "Output unicode character",
-                example: r#"char -u 1f378"#,
-                result: Some(vec![Value::from("\u{1f378}")]),
-            },
-            Example {
-                description: "Output multi-byte unicode character",
-                example: r#"char -u 1F468 200D 1F466 200D 1F466"#,
-                result: Some(vec![Value::from(
-                    "\u{1F468}\u{200D}\u{1F466}\u{200D}\u{1F466}",
-                )]),
-            },
-        ]
-    }
-
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        let (
-            CharArgs {
-                name,
-                rest,
-                unicode,
-            },
-            _,
-        ) = args.process().await?;
-
-        if unicode {
-            if !rest.is_empty() {
-                // Setup a new buffer to put all the unicode bytes in
-                let mut multi_byte = String::new();
-                // Get the first byte
-                let decoded_char = string_to_unicode_char(&name.item, &name.tag);
-                match decoded_char {
-                    Ok(ch) => multi_byte.push(ch),
-                    Err(e) => return Err(e),
-                }
-                // Get the rest of the bytes
-                for byte_part in rest {
-                    let decoded_char = string_to_unicode_char(&byte_part, &byte_part.tag);
-                    match decoded_char {
-                        Ok(ch) => multi_byte.push(ch),
-                        Err(e) => return Err(e),
-                    }
-                }
-                Ok(OutputStream::one(ReturnSuccess::value(
-                    UntaggedValue::string(multi_byte).into_value(name.tag),
-                )))
-            } else {
-                let decoded_char = string_to_unicode_char(&name.item, &name.tag);
-                if let Ok(ch) = decoded_char {
-                    Ok(OutputStream::one(ReturnSuccess::value(
-                        UntaggedValue::string(ch).into_value(name.tag()),
-                    )))
-                } else {
-                    Err(ShellError::labeled_error(
-                        "error decoding unicode character",
-                        "error decoding unicode character",
-                        name.tag(),
-                    ))
-                }
-            }
-        } else {
-            let special_character = str_to_character(&name.item);
-            if let Some(output) = special_character {
-                Ok(OutputStream::one(ReturnSuccess::value(
-                    UntaggedValue::string(output).into_value(name.tag()),
-                )))
-            } else {
-                Err(ShellError::labeled_error(
-                    "error finding named character",
-                    "error finding named character",
-                    name.tag(),
-                ))
-            }
-        }
-    }
-}
-
-fn string_to_unicode_char(s: &str, t: &Tag) -> Result<char, ShellError> {
-    let decoded_char = u32::from_str_radix(s, 16)
-        .ok()
-        .and_then(std::char::from_u32);
-
-    if let Some(ch) = decoded_char {
-        Ok(ch)
-    } else {
-        Err(ShellError::labeled_error(
-            "error decoding unicode character",
-            "error decoding unicode character",
-            t,
-        ))
-    }
-}
-
-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)
-        // Unicode can't be mixed with Ansi or it will break width calculation
-        "branch" => Some('\u{e0a0}'.to_string()),  // 
-        "segment" => Some('\u{e0b0}'.to_string()), // 
-
-        "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" | "sunny" | "sunrise" => Some("☀️".to_string()),
-        "moon" => Some("🌛".to_string()),
-        "cloudy" | "cloud" | "clouds" => Some("☁️".to_string()),
-        "rainy" | "rain" => Some("🌦️".to_string()),
-        "foggy" | "fog" => Some("🌫️".to_string()),
-        "mist" | "haze" => Some("\u{2591}".to_string()),
-        "snowy" | "snow" => Some("❄️".to_string()),
-        "thunderstorm" | "thunder" => Some("🌩️".to_string()),
-
-        "bel" => Some('\x07'.to_string()),       // Terminal Bell
-        "backspace" => Some('\x08'.to_string()), // Backspace
-
-        _ => 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;
-
-        test_examples(Char {})
-    }
-}

crates/nu-command/src/commands/charting/chart.rs

@@ -6,7 +6,6 @@ use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
 #[derive(Clone)]
 pub struct Chart;
 
-#[async_trait]
 impl WholeStreamCommand for Chart {
     fn name(&self) -> &str {
         "chart"
@@ -20,15 +19,15 @@ impl WholeStreamCommand for Chart {
         "Displays charts."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        if args.scope.get_command("chart bar").is_none() {
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        if args.scope().get_command("chart bar").is_none() {
             return Err(ShellError::untagged_runtime_error(
                 "nu_plugin_chart not installed.",
             ));
         }
 
-        Ok(OutputStream::one(Ok(ReturnSuccess::Value(
-            UntaggedValue::string(get_full_help(&Chart, &args.scope)).into_value(Tag::unknown()),
+        Ok(ActionStream::one(Ok(ReturnSuccess::Value(
+            UntaggedValue::string(get_full_help(&Chart, args.scope())).into_value(Tag::unknown()),
         ))))
     }
 }

crates/nu-command/src/commands/charting/histogram.rs

@@ -8,7 +8,6 @@ use nu_source::Tagged;
 
 pub struct Histogram;
 
-#[async_trait]
 impl WholeStreamCommand for Histogram {
     fn name(&self) -> &str {
         "histogram"
@@ -32,8 +31,8 @@ impl WholeStreamCommand for Histogram {
         "Creates a new table with a histogram based on the column name passed in."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        histogram(args).await
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        histogram(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -58,29 +57,18 @@ impl WholeStreamCommand for Histogram {
     }
 }
 
-pub async fn histogram(args: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn histogram(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let (input, args) = args.evaluate_once().await?.parts();
 
-    let values: Vec<Value> = input.collect().await;
-
-    let mut columns = args
-        .positional_iter()
-        .map(|c| c.as_column_path())
-        .filter_map(Result::ok)
-        .collect::<Vec<_>>();
-
-    let evaluate_with = if let Some(path) = args.get("use") {
-        Some(evaluator(path.as_column_path()?.item))
-    } else {
-        None
-    };
+    let mut columns = args.rest::<ColumnPath>(0)?;
+    let evaluate_with = args.get_flag::<ColumnPath>("use")?.map(evaluator);
+    let values: Vec<Value> = args.input.collect();
 
     let column_grouper = if !columns.is_empty() {
-        match columns.remove(0).split_last() {
-            Some((key, _)) => Some(key.as_string().tagged(&name)),
-            None => None,
-        }
+        columns
+            .remove(0)
+            .split_last()
+            .map(|(key, _)| key.as_string().tagged(&name))
     } else {
         None
     };
@@ -114,73 +102,74 @@ pub async fn histogram(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let labels = results.labels.y.clone();
     let mut idx = 0;
 
-    Ok(futures::stream::iter(
-        results
-            .data
-            .table_entries()
-            .cloned()
-            .collect::<Vec<_>>()
-            .into_iter()
-            .zip(
-                results
-                    .percentages
-                    .table_entries()
-                    .cloned()
-                    .collect::<Vec<_>>()
-                    .into_iter(),
-            )
-            .map(move |(counts, percentages)| {
-                let percentage = percentages
-                    .table_entries()
-                    .cloned()
-                    .last()
-                    .unwrap_or_else(|| {
-                        UntaggedValue::decimal_from_float(0.0, name.span).into_value(&name)
-                    });
-                let value = counts
-                    .table_entries()
-                    .cloned()
-                    .last()
-                    .unwrap_or_else(|| UntaggedValue::int(0).into_value(&name));
+    Ok(results
+        .data
+        .table_entries()
+        .cloned()
+        .collect::<Vec<_>>()
+        .into_iter()
+        .zip(
+            results
+                .percentages
+                .table_entries()
+                .cloned()
+                .collect::<Vec<_>>()
+                .into_iter(),
+        )
+        .map(move |(counts, percentages)| {
+            let percentage = percentages
+                .table_entries()
+                .cloned()
+                .last()
+                .unwrap_or_else(|| {
+                    UntaggedValue::decimal_from_float(0.0, name.span).into_value(&name)
+                });
+            let value = counts
+                .table_entries()
+                .cloned()
+                .last()
+                .unwrap_or_else(|| UntaggedValue::int(0).into_value(&name));
 
-                let mut fact = TaggedDictBuilder::new(&name);
-                let column_value = labels
-                    .get(idx)
-                    .ok_or_else(|| {
-                        ShellError::labeled_error(
-                            "Unable to load group labels",
-                            "unable to load group labels",
-                            &name,
-                        )
-                    })?
-                    .clone();
+            let mut fact = TaggedDictBuilder::new(&name);
+            let column_value = labels
+                .get(idx)
+                .ok_or_else(|| {
+                    ShellError::labeled_error(
+                        "Unable to load group labels",
+                        "unable to load group labels",
+                        &name,
+                    )
+                })?
+                .clone();
 
-                fact.insert_value(&column.item, column_value);
-                fact.insert_untagged("count", value);
+            fact.insert_value(&column.item, column_value);
+            fact.insert_untagged("count", value);
 
-                let fmt_percentage = format!(
-                    "{}%",
-                    // Some(2) < the number of digits
-                    // true < group the digits
-                    crate::commands::str_::from::action(&percentage, &name, Some(2), true)?
-                        .as_string()?
-                );
-                fact.insert_untagged("percentage", UntaggedValue::string(fmt_percentage));
+            let fmt_percentage = format!(
+                "{}%",
+                // Some(2) < the number of digits
+                // true < group the digits
+                crate::commands::conversions::into::string::action(
+                    &percentage,
+                    &name,
+                    Some(2),
+                    true
+                )?
+                .as_string()?
+            );
+            fact.insert_untagged("percentage", UntaggedValue::string(fmt_percentage));
 
-                let string = std::iter::repeat("*")
-                    .take(percentage.as_u64().map_err(|_| {
-                        ShellError::labeled_error("expected a number", "expected a number", &name)
-                    })? as usize)
-                    .collect::<String>();
+            let string = "*".repeat(percentage.as_u64().map_err(|_| {
+                ShellError::labeled_error("expected a number", "expected a number", &name)
+            })? as usize);
 
-                fact.insert_untagged(&frequency_column_name, UntaggedValue::string(string));
+            fact.insert_untagged(&frequency_column_name, UntaggedValue::string(string));
 
-                idx += 1;
+            idx += 1;
 
-                ReturnSuccess::value(fact.into_value())
-            }),
-    )
-    .to_output_stream())
+            ReturnSuccess::value(fact.into_value())
+        })
+        .into_action_stream())
 }
 
 fn evaluator(by: ColumnPath) -> Box<dyn Fn(usize, &Value) -> Result<Value, ShellError> + Send> {
@@ -212,7 +201,7 @@ fn splitter(
                 )),
             }
         }),
-        None => Box::new(move |_, row: &Value| nu_value_ext::as_string(&row)),
+        None => Box::new(move |_, row: &Value| nu_value_ext::as_string(row)),
     }
 }
 

crates/nu-command/src/commands/charting/mod.rs

@@ -0,0 +1,5 @@
+mod chart;
+mod histogram;
+
+pub use chart::Chart;
+pub use histogram::Histogram;

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

@@ -1,653 +0,0 @@
-use crate::futures::ThreadedReceiver;
-use crate::prelude::*;
-use nu_engine::evaluate_baseline_expr;
-use nu_engine::{MaybeTextCodec, StringOrBinary};
-
-use std::borrow::Cow;
-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::Expression;
-use nu_protocol::hir::{ExternalCommand, ExternalRedirection};
-use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
-use nu_source::Tag;
-use nu_stream::trace_stream;
-
-pub(crate) async fn run_external_command(
-    command: ExternalCommand,
-    context: &mut EvaluationContext,
-    input: InputStream,
-    external_redirection: ExternalRedirection,
-) -> Result<InputStream, ShellError> {
-    trace!(target: "nu::run::external", "-> {}", command.name);
-
-    if !context.host.lock().is_external_cmd(&command.name) {
-        return Err(ShellError::labeled_error(
-            "Command not found",
-            "command not found",
-            &command.name_tag,
-        ));
-    }
-
-    run_with_stdin(command, context, input, external_redirection).await
-}
-
-async fn run_with_stdin(
-    command: ExternalCommand,
-    context: &mut EvaluationContext,
-    input: InputStream,
-    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 is_literal = matches!(arg.expr, Expression::Literal(_));
-        let value = evaluate_baseline_expr(arg, context).await?;
-
-        // Skip any arguments that don't really exist, treating them as optional
-        // FIXME: we may want to preserve the gap in the future, though it's hard to say
-        // 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(),
-                                is_literal,
-                            ));
-                        }
-                        _ => {
-                            return Err(ShellError::labeled_error(
-                                "Could not convert to positional arguments",
-                                "could not convert to positional arguments",
-                                value.tag(),
-                            ));
-                        }
-                    }
-                }
-            }
-            _ => {
-                let trimmed_value_string = value.as_string()?.trim_end_matches('\n').to_string();
-                command_args.push((trimmed_value_string, is_literal));
-            }
-        }
-    }
-
-    let process_args = command_args
-        .iter()
-        .map(|(arg, _is_literal)| {
-            let home_dir;
-
-            #[cfg(feature = "dirs")]
-            {
-                home_dir = dirs_next::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 !_is_literal {
-                    let escaped = escape_double_quotes(&arg);
-                    add_double_quotes(&escaped)
-                } 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,
-        &context.scope,
-    )
-}
-
-fn spawn(
-    command: &ExternalCommand,
-    path: &str,
-    args: &[String],
-    input: InputStream,
-    external_redirection: ExternalRedirection,
-    scope: &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.get_env_vars());
-
-    // 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)) => {
-                            if stdin_write.write(s.as_bytes()).is_err() {
-                                // Other side has closed, so exit
-                                return Ok(());
-                            }
-                        }
-                        UntaggedValue::Primitive(Primitive::Binary(b)) => {
-                            if stdin_write.write(b).is_err() {
-                                // Other side has closed, so exit
-                                return Ok(());
-                            }
-                        }
-                        unsupported => {
-                            println!("Unsupported: {:?}", unsupported);
-                            let _ = stdin_write_tx.send(Ok(Value {
-                                value: UntaggedValue::Error(ShellError::labeled_error(
-                                    format!(
-                                        "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,
-        ))
-    }
-}
-
-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)
-}
-
-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_double_quotes(argument: &str) -> String {
-    format!("\"{}\"", argument)
-}
-
-#[allow(unused)]
-fn escape_double_quotes(argument: &str) -> Cow<'_, str> {
-    // allocate new string only if required
-    if argument.contains('"') {
-        Cow::Owned(argument.replace('"', r#"\""#))
-    } else {
-        Cow::Borrowed(argument)
-    }
-}
-
-#[allow(unused)]
-fn remove_quotes(argument: &str) -> Option<&str> {
-    if !argument_is_quoted(argument) {
-        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_double_quotes, argument_is_quoted, escape_double_quotes, expand_tilde, remove_quotes,
-    };
-    #[cfg(feature = "which")]
-    use super::{run_external_command, InputStream};
-
-    #[cfg(feature = "which")]
-    use futures::executor::block_on;
-    #[cfg(feature = "which")]
-    use nu_engine::EvaluationContext;
-    #[cfg(feature = "which")]
-    use nu_errors::ShellError;
-    #[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, ExternalRedirection::Stdout)
-                .await
-                .is_err()
-        );
-
-        Ok(())
-    }
-
-    // async fn failure_run() -> Result<(), ShellError> {
-    //     let cmd = ExternalBuilder::for_name("fail").build();
-
-    //     let mut ctx = crate::cli::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_escape_double_quotes() {
-        assert_eq!(escape_double_quotes("andrés"), "andrés");
-        assert_eq!(escape_double_quotes(r#"an"drés"#), r#"an\"drés"#);
-        assert_eq!(escape_double_quotes(r#""an"drés""#), r#"\"an\"drés\""#);
-    }
-
-    #[test]
-    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_double_quotes_to_argument_to_be_passed_in() {
-        assert_eq!(add_double_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-command/src/commands/compact.rs

@@ -1,86 +0,0 @@
-use crate::prelude::*;
-use futures::future;
-use futures::stream::StreamExt;
-use nu_engine::WholeStreamCommand;
-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) -> Result<OutputStream, ShellError> {
-        compact(args).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) -> Result<OutputStream, ShellError> {
-    let (CompactArgs { rest: columns }, input) = args.process().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;
-
-        test_examples(Compact {})
-    }
-}

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

@@ -1,11 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use nu_protocol::{Signature, UntaggedValue};
 
 pub struct SubCommand;
 
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "config clear"
@@ -19,8 +18,8 @@ impl WholeStreamCommand for SubCommand {
         "clear the config"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        clear(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        clear(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -32,24 +31,23 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn clear(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
+pub fn clear(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
 
-    let path = match args.scope.get_var("config-path") {
-        Some(Value {
-            value: UntaggedValue::Primitive(Primitive::FilePath(path)),
-            ..
-        }) => Some(path),
-        _ => nu_data::config::default_path().ok(),
+    let result = if let Some(global_cfg) = &mut args.configs().lock().global_config {
+        global_cfg.vars.clear();
+        global_cfg.write()?;
+        ctx.reload_config(global_cfg)?;
+
+        let value = UntaggedValue::Row(global_cfg.vars.clone().into()).into_value(name);
+        Ok(OutputStream::one(value))
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
     };
 
-    let mut result = nu_data::config::read(name_span, &path)?;
-
-    result.clear();
-
-    config::write(&result, &path)?;
-
-    Ok(OutputStream::one(ReturnSuccess::value(
-        UntaggedValue::Row(result.into()).into_value(args.call_info.name_tag),
-    )))
+    result
 }

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

@@ -2,12 +2,10 @@ use crate::prelude::*;
 use nu_engine::CommandArgs;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
-use nu_stream::OutputStream;
+use nu_protocol::{Signature, UntaggedValue};
 
 pub struct Command;
 
-#[async_trait]
 impl WholeStreamCommand for Command {
     fn name(&self) -> &str {
         "config"
@@ -21,21 +19,19 @@ impl WholeStreamCommand for Command {
         "Configuration management."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         let name = args.call_info.name_tag.clone();
 
-        let path = match args.scope.get_var("config-path") {
-            Some(Value {
-                value: UntaggedValue::Primitive(Primitive::FilePath(path)),
-                ..
-            }) => Some(path),
-            _ => nu_data::config::default_path().ok(),
-        };
-        let result = nu_data::config::read(&name, &path)?;
+        if let Some(global_cfg) = &args.configs().lock().global_config {
+            let result = global_cfg.vars.clone();
+            let value = UntaggedValue::Row(result.into()).into_value(name);
 
-        Ok(futures::stream::iter(vec![ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(name),
-        )])
-        .to_output_stream())
+            Ok(OutputStream::one(value))
+        } else {
+            let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+                .into_value(name);
+
+            Ok(OutputStream::one(value))
+        }
     }
 }

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

@@ -1,18 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{
-    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
 
 pub struct SubCommand;
 
-#[derive(Deserialize)]
-pub struct Arguments {
-    column_path: ColumnPath,
-}
-
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "config get"
@@ -30,8 +22,8 @@ impl WholeStreamCommand for SubCommand {
         "Gets a value from the config"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        get(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        get(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -43,35 +35,28 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn get(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let scope = args.scope.clone();
-    let (Arguments { column_path }, _) = args.process().await?;
+    let ctx = &args.context;
 
-    let path = match scope.get_var("config-path") {
-        Some(Value {
-            value: UntaggedValue::Primitive(Primitive::FilePath(path)),
-            ..
-        }) => Some(path),
-        _ => nu_data::config::default_path().ok(),
+    let column_path = args.req(0)?;
+
+    let result = if let Some(global_cfg) = &ctx.configs().lock().global_config {
+        let result = UntaggedValue::row(global_cfg.vars.clone()).into_value(&name);
+        let value = crate::commands::filters::get::get_column_path(&column_path, &result)?;
+        Ok(match value {
+            Value {
+                value: UntaggedValue::Table(list),
+                ..
+            } => OutputStream::from_stream(list.into_iter()),
+            x => OutputStream::one(x),
+        })
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
     };
 
-    let result = UntaggedValue::row(nu_data::config::read(&name, &path)?).into_value(&name);
-
-    let value = crate::commands::get::get_column_path(&column_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)),
-    })
+    result
 }

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

@@ -13,3 +13,9 @@ pub use path::SubCommand as ConfigPath;
 pub use remove::SubCommand as ConfigRemove;
 pub use set::SubCommand as ConfigSet;
 pub use set_into::SubCommand as ConfigSetInto;
+
+use nu_errors::ShellError;
+
+pub fn err_no_global_cfg_present() -> ShellError {
+    ShellError::untagged_runtime_error("No global config found!")
+}

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

@@ -1,11 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use nu_protocol::{Primitive, Signature, UntaggedValue};
 
 pub struct SubCommand;
 
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "config path"
@@ -19,8 +18,8 @@ impl WholeStreamCommand for SubCommand {
         "return the path to the config file"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        path(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        path(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -32,19 +31,18 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn path(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    Ok(OutputStream::one(ReturnSuccess::value(
-        match args.scope.get_var("config-path") {
-            Some(
-                path
-                @
-                Value {
-                    value: UntaggedValue::Primitive(Primitive::FilePath(_)),
-                    ..
-                },
-            ) => path,
-            _ => UntaggedValue::Primitive(Primitive::FilePath(nu_data::config::default_path()?))
-                .into_value(args.call_info.name_tag),
-        },
-    )))
+pub fn path(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+
+    if let Some(global_cfg) = &mut args.configs().lock().global_config {
+        let value = UntaggedValue::Primitive(Primitive::FilePath(global_cfg.file_path.clone()))
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    }
 }

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

@@ -1,17 +1,11 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 
 pub struct SubCommand;
 
-#[derive(Deserialize)]
-pub struct Arguments {
-    remove: Tagged<String>,
-}
-
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "config remove"
@@ -29,8 +23,8 @@ impl WholeStreamCommand for SubCommand {
         "Removes a value from the config"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        remove(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        remove(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -42,35 +36,35 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn remove(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let name_span = args.call_info.name_tag.clone();
-    let scope = args.scope.clone();
-    let (Arguments { remove }, _) = args.process().await?;
-
-    let path = match scope.get_var("config-path") {
-        Some(Value {
-            value: UntaggedValue::Primitive(Primitive::FilePath(path)),
-            ..
-        }) => Some(path),
-        _ => nu_data::config::default_path().ok(),
-    };
-
-    let mut result = nu_data::config::read(name_span, &path)?;
+pub fn remove(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let name = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+    let remove: Tagged<String> = args.req(0)?;
 
     let key = remove.to_string();
 
-    if result.contains_key(&key) {
-        result.swap_remove(&key);
-        config::write(&result, &path)?;
-        Ok(futures::stream::iter(vec![ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(remove.tag()),
-        )])
-        .to_output_stream())
+    let result = if let Some(global_cfg) = &mut ctx.configs().lock().global_config {
+        if global_cfg.vars.contains_key(&key) {
+            global_cfg.vars.swap_remove(&key);
+            global_cfg.write()?;
+            ctx.reload_config(global_cfg)?;
+
+            let value: Value = UntaggedValue::row(global_cfg.vars.clone()).into_value(remove.tag);
+
+            Ok(OutputStream::one(value))
+        } else {
+            Err(ShellError::labeled_error(
+                "Key does not exist in config",
+                "key",
+                remove.tag(),
+            ))
+        }
     } else {
-        Err(ShellError::labeled_error(
-            "Key does not exist in config",
-            "key",
-            remove.tag(),
-        ))
-    }
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
+    };
+
+    result
 }

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

@@ -1,19 +1,10 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{
-    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
 
 pub struct SubCommand;
 
-#[derive(Deserialize)]
-pub struct Arguments {
-    column_path: ColumnPath,
-    value: Value,
-}
-
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "config set"
@@ -29,8 +20,8 @@ impl WholeStreamCommand for SubCommand {
         "Sets a value in the config"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        set(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -59,46 +50,43 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn set(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let scope = args.scope.clone();
-    let (
-        Arguments {
-            column_path,
-            mut value,
-        },
-        _,
-    ) = args.process().await?;
+    let ctx = &args.context;
 
-    let path = match scope.get_var("config-path") {
-        Some(Value {
-            value: UntaggedValue::Primitive(Primitive::FilePath(path)),
-            ..
-        }) => Some(path),
-        _ => nu_data::config::default_path().ok(),
+    let column_path = args.req(0)?;
+    let mut value: Value = args.req(1)?;
+
+    let result = if let Some(global_cfg) = &mut ctx.configs().lock().global_config {
+        let configuration = UntaggedValue::row(global_cfg.vars.clone()).into_value(&name);
+
+        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(&column_path, value) {
+            Ok(Value {
+                value: UntaggedValue::Row(changes),
+                ..
+            }) => {
+                global_cfg.vars = changes.entries;
+                global_cfg.write()?;
+                ctx.reload_config(global_cfg)?;
+
+                let value = UntaggedValue::row(global_cfg.vars.clone()).into_value(name);
+                Ok(OutputStream::one(value))
+            }
+            Ok(_) => Ok(OutputStream::empty()),
+            Err(reason) => Err(reason),
+        }
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
     };
 
-    let raw_entries = nu_data::config::read(&name, &path)?;
-    let configuration = UntaggedValue::row(raw_entries).into_value(&name);
-
-    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(&column_path, value) {
-        Ok(Value {
-            value: UntaggedValue::Row(changes),
-            ..
-        }) => {
-            config::write(&changes.entries, &path)?;
-
-            Ok(OutputStream::one(ReturnSuccess::value(
-                UntaggedValue::Row(changes).into_value(name),
-            )))
-        }
-        Ok(_) => Ok(OutputStream::empty()),
-        Err(reason) => Err(reason),
-    }
+    result
 }

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

@@ -1,17 +1,11 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 
 pub struct SubCommand;
 
-#[derive(Deserialize)]
-pub struct Arguments {
-    set_into: Tagged<String>,
-}
-
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "config set_into"
@@ -29,8 +23,8 @@ impl WholeStreamCommand for SubCommand {
         "Sets a value in the config"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        set_into(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        set_into(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -42,51 +36,46 @@ impl WholeStreamCommand for SubCommand {
     }
 }
 
-pub async fn set_into(args: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn set_into(args: CommandArgs) -> Result<OutputStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let scope = args.scope.clone();
-    let (Arguments { set_into: v }, input) = args.process().await?;
+    let ctx = &args.context;
 
-    let path = match scope.get_var("config-path") {
-        Some(Value {
-            value: UntaggedValue::Primitive(Primitive::FilePath(path)),
-            ..
-        }) => Some(path),
-        _ => nu_data::config::default_path().ok(),
+    let set_into: Tagged<String> = args.req(0)?;
+
+    let rows: Vec<Value> = args.input.collect();
+    let key = set_into.to_string();
+
+    let result = if let Some(global_cfg) = &mut ctx.configs().lock().global_config {
+        if rows.is_empty() {
+            return Err(ShellError::labeled_error(
+                "No values given for set_into",
+                "needs value(s) from pipeline",
+                set_into.tag(),
+            ));
+        } else if rows.len() == 1 {
+            // A single value
+            let value = &rows[0];
+
+            global_cfg.vars.insert(key, value.clone());
+        } else {
+            // Take in the pipeline as a table
+            let value = UntaggedValue::Table(rows).into_value(name.clone());
+
+            global_cfg.vars.insert(key, value);
+        }
+
+        global_cfg.write()?;
+        ctx.reload_config(global_cfg)?;
+
+        let value = UntaggedValue::row(global_cfg.vars.clone()).into_value(name);
+
+        Ok(OutputStream::one(value))
+    } else {
+        let value = UntaggedValue::Error(crate::commands::config::err_no_global_cfg_present())
+            .into_value(name);
+
+        Ok(OutputStream::one(value))
     };
 
-    let mut result = nu_data::config::read(&name, &path)?;
-
-    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, &path)?;
-
-        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, &path)?;
-
-        OutputStream::one(ReturnSuccess::value(
-            UntaggedValue::Row(result.into()).into_value(name),
-        ))
-    })
+    result
 }

crates/nu-command/src/commands/conversions/into/binary.rs

@@ -0,0 +1,184 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use num_bigint::{BigInt, ToBigInt};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into binary"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into binary").rest(
+            SyntaxShape::ColumnPath,
+            "column paths to convert to binary (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to a binary primitive"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_binary(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "convert string to a nushell binary primitive",
+                example:
+                    "echo 'This is a string that is exactly 52 characters long.' | into binary",
+                result: Some(vec![UntaggedValue::binary(
+                    "This is a string that is exactly 52 characters long."
+                        .to_string()
+                        .as_bytes()
+                        .to_vec(),
+                )
+                .into()]),
+            },
+            Example {
+                description: "convert a number to a nushell binary primitive",
+                example: "echo 1 | into binary",
+                result: Some(vec![UntaggedValue::binary(
+                    i64::from(1).to_le_bytes().to_vec(),
+                )
+                .into()]),
+            },
+            Example {
+                description: "convert a boolean to a nushell binary primitive",
+                example: "echo $true | into binary",
+                result: Some(vec![UntaggedValue::binary(
+                    i64::from(1).to_le_bytes().to_vec(),
+                )
+                .into()]),
+            },
+            Example {
+                description: "convert a filesize to a nushell binary primitive",
+                example: "ls | where name == LICENSE | get size | into binary",
+                result: None,
+            },
+            Example {
+                description: "convert a filepath to a nushell binary primitive",
+                example: "ls | where name == LICENSE | get name | path expand | into binary",
+                result: None,
+            },
+            Example {
+                description: "convert a decimal to a nushell binary primitive",
+                example: "echo 1.234 | into binary",
+                result: Some(vec![
+                    UntaggedValue::binary(BigInt::from(1).to_bytes_le().1).into()
+                ]),
+            },
+        ]
+    }
+}
+
+fn into_binary(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+fn int_to_endian(n: i64) -> Vec<u8> {
+    if cfg!(target_endian = "little") {
+        n.to_le_bytes().to_vec()
+    } else {
+        n.to_be_bytes().to_vec()
+    }
+}
+
+fn bigint_to_endian(n: &BigInt) -> Vec<u8> {
+    if cfg!(target_endian = "little") {
+        n.to_bytes_le().1
+    } else {
+        n.to_bytes_be().1
+    }
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::binary(match prim {
+            Primitive::Binary(b) => b.to_vec(),
+            Primitive::Int(n_ref) => int_to_endian(*n_ref),
+            Primitive::BigInt(n_ref) => bigint_to_endian(n_ref),
+            Primitive::Decimal(dec) => match dec.to_bigint() {
+                Some(n) => bigint_to_endian(&n),
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert decimal to int",
+                    ));
+                }
+            },
+            Primitive::Filesize(a_filesize) => match a_filesize.to_bigint() {
+                Some(n) => bigint_to_endian(&n),
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert filesize to bigint",
+                    ));
+                }
+            },
+            Primitive::String(a_string) => a_string.as_bytes().to_vec(),
+            Primitive::Boolean(a_bool) => match a_bool {
+                false => int_to_endian(0),
+                true => int_to_endian(1),
+            },
+            Primitive::Date(a_date) => a_date.format("%c").to_string().as_bytes().to_vec(),
+            Primitive::FilePath(a_filepath) => a_filepath
+                .as_path()
+                .display()
+                .to_string()
+                .as_bytes()
+                .to_vec(),
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into binary' for non-numeric primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into binary COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into binary' for unsupported type",
+        )),
+    }
+}
+
+#[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;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/command.rs

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

crates/nu-command/src/commands/conversions/into/filepath.rs

@@ -0,0 +1,126 @@
+use std::path::PathBuf;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into path"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into path").rest(
+            SyntaxShape::ColumnPath,
+            "column paths to convert to filepath (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to filepath"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_filepath(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to filepath in table",
+                example: "echo [[name]; ['/dev/null'] ['C:\\Program Files'] ['../../Cargo.toml']] | into path name",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("/dev/null").into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("C:\\Program Files").into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "name".to_string() => UntaggedValue::filepath("../../Cargo.toml").into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to filepath",
+                example: "echo 'Cargo.toml' | into path",
+                result: Some(vec![UntaggedValue::filepath("Cargo.toml").into()]),
+            },
+        ]
+    }
+}
+
+fn into_filepath(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::filepath(match prim {
+            Primitive::String(a_string) => match filepath_from_string(a_string, &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::FilePath(a_filepath) => a_filepath.clone(),
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into path' for non-string primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into path COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented(
+            "'into path' for unsupported type",
+        )),
+    }
+}
+
+fn filepath_from_string(a_string: &str, _tag: &Tag) -> Result<PathBuf, ShellError> {
+    Ok(PathBuf::from(a_string))
+}
+
+#[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;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/int.rs

@@ -0,0 +1,197 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
+use num_bigint::ToBigInt;
+
+pub struct SubCommand;
+
+impl WholeStreamCommand for SubCommand {
+    fn name(&self) -> &str {
+        "into int"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("into int").rest(
+            SyntaxShape::ColumnPath,
+            "column paths to convert to int (for table input)",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Convert value to integer"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_int(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Convert string to integer in table",
+                example: "echo [[num]; ['-5'] [4] [1.5]] | into int num",
+                result: Some(vec![
+                    UntaggedValue::row(indexmap! {
+                        "num".to_string() => UntaggedValue::int(-5).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "num".to_string() => UntaggedValue::int(4).into(),
+                    })
+                    .into(),
+                    UntaggedValue::row(indexmap! {
+                        "num".to_string() => UntaggedValue::int(1).into(),
+                    })
+                    .into(),
+                ]),
+            },
+            Example {
+                description: "Convert string to integer",
+                example: "echo '2' | into int",
+                result: Some(vec![UntaggedValue::int(2).into()]),
+            },
+            Example {
+                description: "Convert decimal to integer",
+                example: "echo 5.9 | into int",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Convert decimal string to integer",
+                example: "echo '5.9' | into int",
+                result: Some(vec![UntaggedValue::int(5).into()]),
+            },
+            Example {
+                description: "Convert file size to integer",
+                example: "echo 4KB | into int",
+                result: Some(vec![UntaggedValue::int(4000).into()]),
+            },
+            Example {
+                description: "Convert bool to integer",
+                example: "echo $false $true | into int",
+                result: Some(vec![
+                    UntaggedValue::int(0).into(),
+                    UntaggedValue::int(1).into(),
+                ]),
+            },
+        ]
+    }
+}
+
+fn into_int(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
+
+    Ok(args
+        .input
+        .map(move |v| {
+            if column_paths.is_empty() {
+                action(&v, v.tag())
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    ret = ret.swap_data_by_column_path(
+                        path,
+                        Box::new(move |old| action(old, old.tag())),
+                    )?;
+                }
+
+                Ok(ret)
+            }
+        })
+        .into_input_stream())
+}
+
+pub fn action(input: &Value, tag: impl Into<Tag>) -> Result<Value, ShellError> {
+    let tag = tag.into();
+    match &input.value {
+        UntaggedValue::Primitive(prim) => Ok(UntaggedValue::int(match prim {
+            Primitive::String(a_string) => match int_from_string(a_string, &tag) {
+                Ok(n) => n,
+                Err(e) => {
+                    return Err(e);
+                }
+            },
+            Primitive::Decimal(dec) => match dec.to_bigint() {
+                Some(n) => match n.to_i64() {
+                    Some(i) => i,
+                    None => {
+                        return Err(ShellError::unimplemented(
+                            "failed to convert decimal to int",
+                        ));
+                    }
+                },
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert decimal to int",
+                    ));
+                }
+            },
+            Primitive::Int(n_ref) => *n_ref,
+            Primitive::Boolean(a_bool) => match a_bool {
+                false => 0,
+                true => 1,
+            },
+            Primitive::Filesize(a_filesize) => match a_filesize.to_bigint() {
+                Some(n) => match n.to_i64() {
+                    Some(i) => i,
+                    None => {
+                        return Err(ShellError::unimplemented(
+                            "failed to convert filesize to bigint",
+                        ));
+                    }
+                },
+                None => {
+                    return Err(ShellError::unimplemented(
+                        "failed to convert filesize to bigint",
+                    ));
+                }
+            },
+            _ => {
+                return Err(ShellError::unimplemented(
+                    "'into int' for non-numeric primitives",
+                ))
+            }
+        })
+        .into_value(&tag)),
+        UntaggedValue::Row(_) => Err(ShellError::labeled_error(
+            "specify column name to use, with 'into int COLUMN'",
+            "found table",
+            tag,
+        )),
+        _ => Err(ShellError::unimplemented("'into int' for unsupported type")),
+    }
+}
+
+fn int_from_string(a_string: &str, tag: &Tag) -> Result<i64, ShellError> {
+    match a_string.parse::<i64>() {
+        Ok(n) => Ok(n),
+        Err(_) => match a_string.parse::<f64>() {
+            Ok(f) => match f.to_i64() {
+                Some(i) => Ok(i),
+                None => Err(ShellError::labeled_error(
+                    "Could not convert string value to int",
+                    "original value",
+                    tag.clone(),
+                )),
+            },
+            Err(_) => Err(ShellError::labeled_error(
+                "Could not convert string value to int",
+                "original value",
+                tag.clone(),
+            )),
+        },
+    }
+}
+
+#[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;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/commands/conversions/into/mod.rs

@@ -0,0 +1,11 @@
+mod binary;
+mod command;
+mod filepath;
+mod int;
+pub mod string;
+
+pub use binary::SubCommand as IntoBinary;
+pub use command::Command as Into;
+pub use filepath::SubCommand as IntoFilepath;
+pub use int::SubCommand as IntoInt;
+pub use string::SubCommand as IntoString;

crates/nu-command/src/commands/conversions/into/string.rs

@@ -1,9 +1,7 @@
 use crate::prelude::*;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{
-    ColumnPath, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
-};
+use nu_protocol::{ColumnPath, Primitive, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 use num_bigint::{BigInt, BigUint, ToBigInt};
 // TODO num_format::SystemLocale once platform-specific dependencies are stable (see Cargo.toml)
@@ -14,25 +12,16 @@ use std::iter;
 
 pub struct SubCommand;
 
-#[derive(Deserialize)]
-struct Arguments {
-    rest: Vec<ColumnPath>,
-    decimals: Option<Tagged<u64>>,
-    #[serde(rename(deserialize = "group-digits"))]
-    group_digits: bool,
-}
-
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
-        "str from"
+        "into string"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("str from")
+        Signature::build("into string")
             .rest(
                 SyntaxShape::ColumnPath,
-                "optionally convert to string by column paths",
+                "column paths to convert to string (for table input)",
             )
             .named(
                 "decimals",
@@ -40,61 +29,69 @@ impl WholeStreamCommand for SubCommand {
                 "decimal digits to which to round",
                 Some('d'),
             )
-        /*
-        FIXME: this isn't currently supported because of num_format being out of date. Once it's updated, re-enable this
-        .switch(
-            "group-digits",
-            // TODO according to system localization
-            "group digits, currently by thousand with commas",
-            Some('g'),
-        )
-        */
     }
 
     fn usage(&self) -> &str {
-        "Converts numeric types to strings. Trims trailing zeros unless decimals parameter is specified."
+        "Convert value to string"
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        operate(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        into_string(args)
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "round to nearest integer",
-                example: "echo 1.7 | str from -d 0",
+                description: "convert decimal to string and round to nearest integer",
+                example: "echo 1.7 | into string -d 0",
                 result: Some(vec![UntaggedValue::string("2").into_untagged_value()]),
             },
-            /*
-            FIXME: this isn't currently supported because of num_format being out of date. Once it's updated, re-enable this
             Example {
-                description: "format large number with localized digit grouping",
-                example: "= 1000000.2 | str from -g",
-                result: Some(vec![
-                    UntaggedValue::string("1,000,000.2").into_untagged_value()
-                ]),
+                description: "convert decimal to string",
+                example: "echo 4.3 | into string",
+                result: Some(vec![UntaggedValue::string("4.3").into_untagged_value()]),
+            },
+            Example {
+                description: "convert string to string",
+                example: "echo '1234' | into string",
+                result: Some(vec![UntaggedValue::string("1234").into_untagged_value()]),
+            },
+            Example {
+                description: "convert boolean to string",
+                example: "echo $true | into string",
+                result: Some(vec![UntaggedValue::string("true").into_untagged_value()]),
+            },
+            Example {
+                description: "convert date to string",
+                example: "date now | into string",
+                result: None,
+            },
+            Example {
+                description: "convert filepath to string",
+                example: "ls Cargo.toml | get name | into string",
+                result: None,
+            },
+            Example {
+                description: "convert filesize to string",
+                example: "ls Cargo.toml | get size | into string",
+                result: None,
             },
-            */
         ]
     }
 }
 
-async fn operate(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let (
-        Arguments {
-            decimals,
-            group_digits,
-            rest: column_paths,
-        },
-        input,
-    ) = args.process().await?;
-    let digits = decimals.map(|tagged| tagged.item);
+fn into_string(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let decimals: Option<Tagged<u64>> = args.get_flag("decimals")?;
+    let column_paths: Vec<ColumnPath> = args.rest(0)?;
 
-    Ok(input
+    let digits = decimals.as_ref().map(|tagged| tagged.item);
+    let group_digits = false;
+
+    Ok(args
+        .input
         .map(move |v| {
             if column_paths.is_empty() {
-                ReturnSuccess::value(action(&v, v.tag(), digits, group_digits)?)
+                action(&v, v.tag(), digits, group_digits)
             } else {
                 let mut ret = v;
                 for path in &column_paths {
@@ -104,13 +101,12 @@ async fn operate(args: CommandArgs) -> Result<OutputStream, ShellError> {
                     )?;
                 }
 
-                ReturnSuccess::value(ret)
+                Ok(ret)
             }
         })
-        .to_output_stream())
+        .into_input_stream())
 }
 
-// TODO If you're using the with-system-locale feature and you're on Windows, Clang 3.9 or higher is also required.
 pub fn action(
     input: &Value,
     tag: impl Into<Tag>,
@@ -120,6 +116,13 @@ pub fn action(
     match &input.value {
         UntaggedValue::Primitive(prim) => Ok(UntaggedValue::string(match prim {
             Primitive::Int(int) => {
+                if group_digits {
+                    format_int(*int) // int.to_formatted_string(*locale)
+                } else {
+                    int.to_string()
+                }
+            }
+            Primitive::BigInt(int) => {
                 if group_digits {
                     format_bigint(int) // int.to_formatted_string(*locale)
                 } else {
@@ -132,27 +135,45 @@ pub fn action(
             Primitive::Date(a_date) => a_date.format("%c").to_string(),
             Primitive::FilePath(a_filepath) => a_filepath.as_path().display().to_string(),
             Primitive::Filesize(a_filesize) => {
-                let byte_string = InlineShape::format_bytes(a_filesize, None);
+                let byte_string = InlineShape::format_bytes(*a_filesize, None);
                 byte_string.1
             }
+            Primitive::Nothing => "nothing".to_string(),
             _ => {
-                return Err(ShellError::unimplemented(
-                    "str from for non-numeric primitives",
-                ))
+                return Err(ShellError::unimplemented(&format!(
+                    "into string for primitive: {:?}",
+                    prim
+                )))
             }
         })
         .into_value(tag)),
         UntaggedValue::Row(_) => Err(ShellError::labeled_error(
-            "specify column to use 'str from'",
+            "specify column to use 'into string'",
             "found table",
             input.tag.clone(),
         )),
-        _ => Err(ShellError::unimplemented(
-            "str from for non-primitive, non-table types",
-        )),
+        UntaggedValue::Table(_) => Err(ShellError::unimplemented("into string for table")),
+        _ => Err(ShellError::unimplemented("into string for non-primitive")),
     }
 }
 
+fn format_int(int: i64) -> String {
+    format!("{}", int)
+
+    // TODO once platform-specific dependencies are stable (see Cargo.toml)
+    // #[cfg(windows)]
+    // {
+    //     int.to_formatted_string(&Locale::en)
+    // }
+    // #[cfg(not(windows))]
+    // {
+    //     match SystemLocale::default() {
+    //         Ok(locale) => int.to_formatted_string(&locale),
+    //         Err(_) => int.to_formatted_string(&Locale::en),
+    //     }
+    // }
+}
+
 fn format_bigint(int: &BigInt) -> String {
     format!("{}", int)
 

crates/nu-command/src/commands/conversions/mod.rs

@@ -0,0 +1,3 @@
+pub(crate) mod into;
+
+pub use into::*;

crates/nu-command/src/commands/core_commands/alias.rs

@@ -0,0 +1,40 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+
+use nu_errors::ShellError;
+use nu_protocol::{Signature, SyntaxShape};
+
+pub struct Alias;
+
+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("equals", SyntaxShape::String, "the equals sign")
+            .rest(SyntaxShape::Any, "the expansion for the alias")
+    }
+
+    fn usage(&self) -> &str {
+        "Alias a command to an expansion."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        alias(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Alias ll to ls -l",
+            example: "alias ll = ls -l",
+            result: None,
+        }]
+    }
+}
+
+pub fn alias(_: CommandArgs) -> Result<OutputStream, ShellError> {
+    Ok(OutputStream::empty())
+}

crates/nu-command/src/commands/core_commands/debug.rs

@@ -5,12 +5,6 @@ use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
 
 pub struct Debug;
 
-#[derive(Deserialize)]
-pub struct DebugArgs {
-    raw: bool,
-}
-
-#[async_trait]
 impl WholeStreamCommand for Debug {
     fn name(&self) -> &str {
         "debug"
@@ -24,13 +18,15 @@ impl WholeStreamCommand for Debug {
         "Print the Rust debug representation of the values."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        debug_value(args).await
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        debug_value(args)
     }
 }
 
-async fn debug_value(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let (DebugArgs { raw }, input) = args.process().await?;
+fn debug_value(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let raw = args.has_flag("raw");
+    let input = args.input;
+
     Ok(input
         .map(move |v| {
             if raw {
@@ -41,7 +37,7 @@ async fn debug_value(args: CommandArgs) -> Result<OutputStream, ShellError> {
                 ReturnSuccess::debug_value(v)
             }
         })
-        .to_output_stream())
+        .into_action_stream())
 }
 
 #[cfg(test)]

crates/nu-command/src/commands/core_commands/def.rs

@@ -14,7 +14,6 @@ pub struct DefArgs {
     pub block: CapturedBlock,
 }
 
-#[async_trait]
 impl WholeStreamCommand for Def {
     fn name(&self) -> &str {
         "def"
@@ -35,11 +34,11 @@ impl WholeStreamCommand for Def {
         "Create a command and set it to a definition."
     }
 
-    async fn run(&self, _args: CommandArgs) -> Result<OutputStream, ShellError> {
+    fn run_with_actions(&self, _args: CommandArgs) -> Result<ActionStream, ShellError> {
         // Currently, we don't do anything here because we should have already
         // installed the definition as we entered the scope
         // We just create a command so that we can get proper coloring
-        Ok(OutputStream::empty())
+        Ok(ActionStream::empty())
     }
 
     fn examples(&self) -> Vec<Example> {

crates/nu-command/src/commands/core_commands/describe.rs

@@ -9,7 +9,6 @@ pub struct Describe;
 #[derive(Deserialize)]
 pub struct DescribeArgs {}
 
-#[async_trait]
 impl WholeStreamCommand for Describe {
     fn name(&self) -> &str {
         "describe"
@@ -23,21 +22,21 @@ impl WholeStreamCommand for Describe {
         "Describes the objects in the stream."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        describe(args).await
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        describe(args)
     }
 }
 
-pub async fn describe(args: CommandArgs) -> Result<OutputStream, ShellError> {
+pub fn describe(args: CommandArgs) -> Result<ActionStream, ShellError> {
     Ok(args
         .input
         .map(|row| {
-            let name = value::format_type(&row, 100);
+            let name = value::plain_type(&row, 100);
             ReturnSuccess::value(
                 UntaggedValue::string(name).into_value(Tag::unknown_anchor(row.tag.span)),
             )
         })
-        .to_output_stream())
+        .into_action_stream())
 }
 
 #[cfg(test)]

crates/nu-command/src/commands/core_commands/do_.rs

@@ -2,17 +2,18 @@ use crate::prelude::*;
 use nu_engine::run_block;
 use nu_engine::WholeStreamCommand;
 use nu_errors::ShellError;
-use nu_protocol::{hir::CapturedBlock, hir::ExternalRedirection, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    hir::CapturedBlock, hir::ExternalRedirection, Signature, SyntaxShape, UntaggedValue, Value,
+};
 
 pub struct Do;
 
-#[derive(Deserialize, Debug)]
 struct DoArgs {
     block: CapturedBlock,
     ignore_errors: bool,
+    rest: Vec<Value>,
 }
 
-#[async_trait]
 impl WholeStreamCommand for Do {
     fn name(&self) -> &str {
         "do"
@@ -22,18 +23,19 @@ impl WholeStreamCommand for Do {
         Signature::build("do")
             .required("block", SyntaxShape::Block, "the block to run ")
             .switch(
-                "ignore_errors",
+                "ignore-errors",
                 "ignore errors as the block runs",
                 Some('i'),
             )
+            .rest(SyntaxShape::Any, "the parameter(s) for the block")
     }
 
     fn usage(&self) -> &str {
         "Runs a block, optionally ignoring errors."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        do_(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        do_(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -48,32 +50,35 @@ impl WholeStreamCommand for Do {
                 example: r#"do -i { thisisnotarealcommand }"#,
                 result: Some(vec![]),
             },
+            Example {
+                description: "Run the block with a parameter",
+                example: r#"do { |x| $x + 100 } 55"#,
+                result: Some(vec![UntaggedValue::int(155).into()]),
+            },
         ]
     }
 }
 
-async fn do_(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let external_redirection = raw_args.call_info.args.external_redirection;
+fn do_(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let external_redirection = args.call_info.args.external_redirection;
 
-    let context = EvaluationContext::from_args(&raw_args);
-    let (
-        DoArgs {
-            ignore_errors,
-            mut block,
-        },
-        input,
-    ) = raw_args.process().await?;
+    let context = args.context().clone();
+    let do_args = DoArgs {
+        block: args.req(0)?,
+        ignore_errors: args.has_flag("ignore-errors"),
+        rest: args.rest(1)?,
+    };
 
     let block_redirection = match external_redirection {
         ExternalRedirection::None => {
-            if ignore_errors {
+            if do_args.ignore_errors {
                 ExternalRedirection::Stderr
             } else {
                 ExternalRedirection::None
             }
         }
         ExternalRedirection::Stdout => {
-            if ignore_errors {
+            if do_args.ignore_errors {
                 ExternalRedirection::StdoutAndStderr
             } else {
                 ExternalRedirection::Stdout
@@ -82,25 +87,43 @@ async fn do_(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
         x => x,
     };
 
-    block.block.set_redirect(block_redirection);
     context.scope.enter_scope();
-    let result = run_block(&block.block, &context, input).await;
+
+    context.scope.add_vars(&do_args.block.captured.entries);
+
+    for (param, value) in do_args
+        .block
+        .block
+        .params
+        .positional
+        .iter()
+        .zip(do_args.rest)
+    {
+        context.scope.add_var(param.0.name(), value.clone());
+    }
+
+    let result = run_block(
+        &do_args.block.block,
+        &context,
+        args.input,
+        block_redirection,
+    );
     context.scope.exit_scope();
 
-    if ignore_errors {
+    if do_args.ignore_errors {
         // To properly ignore errors we need to redirect stderr, consume it, and remove
         // any errors we see in the process.
 
         match result {
             Ok(mut stream) => {
-                let output = stream.drain_vec().await;
+                let output = stream.drain_vec();
                 context.clear_errors();
-                Ok(futures::stream::iter(output).to_output_stream())
+                Ok(output.into_iter().into_output_stream())
             }
             Err(_) => Ok(OutputStream::empty()),
         }
     } else {
-        result.map(|x| x.to_output_stream())
+        result.map(|x| x.into_output_stream())
     }
 }
 

crates/nu-command/src/commands/core_commands/echo.rs

@@ -0,0 +1,207 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::hir::Operator;
+use nu_protocol::{Primitive, Range, RangeInclusion, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Echo;
+
+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."
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<InputStream, ShellError> {
+        echo(args)
+    }
+
+    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,
+            },
+        ]
+    }
+}
+
+pub fn expand_value_to_stream(v: Value) -> InputStream {
+    match v {
+        Value {
+            value: UntaggedValue::Table(table),
+            ..
+        } => InputStream::from_stream(table.into_iter()),
+        Value {
+            value: UntaggedValue::Primitive(Primitive::Range(range)),
+            tag,
+        } => InputStream::from_stream(RangeIterator::new(*range, tag)),
+        x => InputStream::one(x),
+    }
+}
+
+fn echo(args: CommandArgs) -> Result<InputStream, ShellError> {
+    let rest: Vec<Value> = args.rest(0)?;
+
+    let stream = rest.into_iter().map(|i| match i.as_string() {
+        Ok(s) => InputStream::one(UntaggedValue::string(s).into_value(i.tag)),
+        _ => expand_value_to_stream(i),
+    });
+
+    Ok(InputStream::from_stream(stream.flatten()))
+}
+
+struct RangeIterator {
+    curr: UntaggedValue,
+    end: UntaggedValue,
+    tag: Tag,
+    is_end_inclusive: bool,
+    moves_up: bool,
+    one: UntaggedValue,
+    negative_one: UntaggedValue,
+    done: bool,
+}
+
+impl RangeIterator {
+    pub fn new(range: Range, tag: Tag) -> RangeIterator {
+        let start = match range.from.0.item {
+            Primitive::Nothing => Primitive::Int(0.into()),
+            x => x,
+        };
+
+        let end = match range.to.0.item {
+            Primitive::Nothing => Primitive::Int(i64::MAX),
+            x => x,
+        };
+
+        RangeIterator {
+            moves_up: start <= end,
+            curr: UntaggedValue::Primitive(start),
+            end: UntaggedValue::Primitive(end),
+            tag,
+            is_end_inclusive: matches!(range.to.1, RangeInclusion::Inclusive),
+            one: UntaggedValue::int(1),
+            negative_one: UntaggedValue::int(-1),
+            done: false,
+        }
+    }
+}
+
+impl Iterator for RangeIterator {
+    type Item = Value;
+    fn next(&mut self) -> Option<Self::Item> {
+        use std::cmp::Ordering;
+        if self.done {
+            return None;
+        }
+
+        let ordering = if self.end == UntaggedValue::Primitive(Primitive::Nothing) {
+            Ordering::Less
+        } else {
+            match (&self.curr, &self.end) {
+                (
+                    UntaggedValue::Primitive(Primitive::Int(x)),
+                    UntaggedValue::Primitive(Primitive::Int(y)),
+                ) => x.cmp(y),
+                (
+                    UntaggedValue::Primitive(Primitive::Decimal(x)),
+                    UntaggedValue::Primitive(Primitive::Decimal(y)),
+                ) => x.cmp(y),
+                (
+                    UntaggedValue::Primitive(Primitive::Decimal(x)),
+                    UntaggedValue::Primitive(Primitive::Int(y)),
+                ) => x.cmp(&(BigDecimal::from(*y))),
+                (
+                    UntaggedValue::Primitive(Primitive::Int(x)),
+                    UntaggedValue::Primitive(Primitive::Decimal(y)),
+                ) => (BigDecimal::from(*x)).cmp(y),
+                _ => {
+                    self.done = true;
+                    return Some(
+                        UntaggedValue::Error(ShellError::labeled_error(
+                            "Cannot create range",
+                            "unsupported range",
+                            self.tag.span,
+                        ))
+                        .into_untagged_value(),
+                    );
+                }
+            }
+        };
+
+        if self.moves_up
+            && (ordering == Ordering::Less || self.is_end_inclusive && ordering == Ordering::Equal)
+        {
+            let next_value = nu_data::value::compute_values(Operator::Plus, &self.curr, &self.one);
+
+            let mut next = match next_value {
+                Ok(result) => result,
+
+                Err((left_type, right_type)) => {
+                    self.done = true;
+                    return Some(
+                        UntaggedValue::Error(ShellError::coerce_error(
+                            left_type.spanned(self.tag.span),
+                            right_type.spanned(self.tag.span),
+                        ))
+                        .into_untagged_value(),
+                    );
+                }
+            };
+            std::mem::swap(&mut self.curr, &mut next);
+
+            Some(next.into_value(self.tag.clone()))
+        } else if !self.moves_up
+            && (ordering == Ordering::Greater
+                || self.is_end_inclusive && ordering == Ordering::Equal)
+        {
+            let next_value =
+                nu_data::value::compute_values(Operator::Plus, &self.curr, &self.negative_one);
+
+            let mut next = match next_value {
+                Ok(result) => result,
+                Err((left_type, right_type)) => {
+                    self.done = true;
+                    return Some(
+                        UntaggedValue::Error(ShellError::coerce_error(
+                            left_type.spanned(self.tag.span),
+                            right_type.spanned(self.tag.span),
+                        ))
+                        .into_untagged_value(),
+                    );
+                }
+            };
+            std::mem::swap(&mut self.curr, &mut next);
+
+            Some(next.into_value(self.tag.clone()))
+        } else {
+            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;
+
+        test_examples(Echo {})
+    }
+}

crates/nu-command/src/commands/core_commands/help.rs

@@ -1,20 +1,18 @@
 use crate::prelude::*;
-use nu_engine::command_dict;
+use crate::TaggedListBuilder;
 use nu_engine::documentation::generate_docs;
-use nu_engine::WholeStreamCommand;
+use nu_engine::{Command, WholeStreamCommand};
 use nu_errors::ShellError;
-use nu_protocol::{ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value};
+use nu_protocol::{
+    NamedType, PositionalType, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder,
+    UntaggedValue, Value,
+};
+use nu_source::Tag;
 use nu_source::{SpannedItem, Tagged};
 use nu_value_ext::ValueExt;
 
 pub struct Help;
 
-#[derive(Deserialize)]
-pub struct HelpArgs {
-    rest: Vec<Tagged<String>>,
-}
-
-#[async_trait]
 impl WholeStreamCommand for Help {
     fn name(&self) -> &str {
         "help"
@@ -28,15 +26,16 @@ impl WholeStreamCommand for Help {
         "Display help information about commands."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        help(args).await
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        help(args)
     }
 }
 
-async fn help(args: CommandArgs) -> Result<OutputStream, ShellError> {
+fn help(args: CommandArgs) -> Result<ActionStream, ShellError> {
     let name = args.call_info.name_tag.clone();
-    let scope = args.scope.clone();
-    let (HelpArgs { rest }, ..) = args.process().await?;
+    let scope = args.scope().clone();
+
+    let rest: Vec<Tagged<String>> = args.rest(0)?;
 
     if !rest.is_empty() {
         if rest[0].item == "commands" {
@@ -45,11 +44,11 @@ async fn help(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
             let (mut subcommand_names, command_names) = sorted_names
                 .into_iter()
-                // Internal only commands shouldn't be displayed
+                // private only commands shouldn't be displayed
                 .filter(|cmd_name| {
                     scope
-                        .get_command(&cmd_name)
-                        .filter(|command| !command.is_internal())
+                        .get_command(cmd_name)
+                        .filter(|command| !command.is_private())
                         .is_some()
                 })
                 .partition::<Vec<_>, _>(|cmd_name| cmd_name.contains(' '));
@@ -63,7 +62,7 @@ async fn help(args: CommandArgs) -> Result<OutputStream, ShellError> {
             ) -> Result<(), ShellError> {
                 let document_tag = rest[0].tag.clone();
                 let value = command_dict(
-                    scope.get_command(&cmd_name).ok_or_else(|| {
+                    scope.get_command(cmd_name).ok_or_else(|| {
                         ShellError::labeled_error(
                             format!("Could not load {}", cmd_name),
                             "could not load command",
@@ -151,24 +150,24 @@ async fn help(args: CommandArgs) -> Result<OutputStream, ShellError> {
                         ReturnSuccess::value(short_desc.into_value())
                     });
 
-            Ok(futures::stream::iter(iterator).to_output_stream())
+            Ok(iterator.into_action_stream())
         } else if rest[0].item == "generate_docs" {
-            Ok(OutputStream::one(ReturnSuccess::value(generate_docs(
+            Ok(ActionStream::one(ReturnSuccess::value(generate_docs(
                 &scope,
             ))))
         } else if rest.len() == 2 {
             // Check for a subcommand
             let command_name = format!("{} {}", rest[0].item, rest[1].item);
             if let Some(command) = scope.get_command(&command_name) {
-                Ok(OutputStream::one(ReturnSuccess::value(
+                Ok(ActionStream::one(ReturnSuccess::value(
                     UntaggedValue::string(get_full_help(command.stream_command(), &scope))
                         .into_value(Tag::unknown()),
                 )))
             } else {
-                Ok(OutputStream::empty())
+                Ok(ActionStream::empty())
             }
         } else if let Some(command) = scope.get_command(&rest[0].item) {
-            Ok(OutputStream::one(ReturnSuccess::value(
+            Ok(ActionStream::one(ReturnSuccess::value(
                 UntaggedValue::string(get_full_help(command.stream_command(), &scope))
                     .into_value(Tag::unknown()),
             )))
@@ -202,12 +201,68 @@ Get the processes on your system actively using CPU:
 
 You can also learn more at https://www.nushell.sh/book/"#;
 
-        Ok(OutputStream::one(ReturnSuccess::value(
+        Ok(ActionStream::one(ReturnSuccess::value(
             UntaggedValue::string(msg).into_value(Tag::unknown()),
         )))
     }
 }
 
+fn for_spec(name: &str, ty: &str, required: bool, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut spec = TaggedDictBuilder::new(tag);
+
+    spec.insert_untagged("name", UntaggedValue::string(name));
+    spec.insert_untagged("type", UntaggedValue::string(ty));
+    spec.insert_untagged(
+        "required",
+        UntaggedValue::string(if required { "yes" } else { "no" }),
+    );
+
+    spec.into_value()
+}
+
+pub fn signature_dict(signature: Signature, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+    let mut sig = TaggedListBuilder::new(&tag);
+
+    for arg in signature.positional.iter() {
+        let is_required = matches!(arg.0, PositionalType::Mandatory(_, _));
+
+        sig.push_value(for_spec(arg.0.name(), "argument", is_required, &tag));
+    }
+
+    if signature.rest_positional.is_some() {
+        let is_required = false;
+        sig.push_value(for_spec("rest", "argument", is_required, &tag));
+    }
+
+    for (name, ty) in signature.named.iter() {
+        match ty.0 {
+            NamedType::Mandatory(_, _) => sig.push_value(for_spec(name, "flag", true, &tag)),
+            NamedType::Optional(_, _) => sig.push_value(for_spec(name, "flag", false, &tag)),
+            NamedType::Switch(_) => sig.push_value(for_spec(name, "switch", false, &tag)),
+        }
+    }
+
+    sig.into_value()
+}
+
+fn command_dict(command: Command, tag: impl Into<Tag>) -> Value {
+    let tag = tag.into();
+
+    let mut cmd_dict = TaggedDictBuilder::new(&tag);
+
+    cmd_dict.insert_untagged("name", UntaggedValue::string(command.name()));
+
+    cmd_dict.insert_untagged("type", UntaggedValue::string("Command"));
+
+    cmd_dict.insert_value("signature", signature_dict(command.signature(), tag));
+    cmd_dict.insert_untagged("usage", UntaggedValue::string(command.usage()));
+
+    cmd_dict.into_value()
+}
+
 #[cfg(test)]
 mod tests {
     use super::Help;

crates/nu-command/src/commands/core_commands/history.rs

@@ -0,0 +1,74 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue};
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+
+pub struct History;
+
+impl WholeStreamCommand for History {
+    fn name(&self) -> &str {
+        "history"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("history").switch("clear", "Clears out the history entries", Some('c'))
+    }
+
+    fn usage(&self) -> &str {
+        "Display command history."
+    }
+
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        history(args)
+    }
+}
+
+fn history(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let ctx = &args.context;
+
+    let clear = args.has_flag("clear");
+
+    let path = if let Some(global_cfg) = &ctx.configs().lock().global_config {
+        nu_data::config::path::history_path_or_default(global_cfg)
+    } else {
+        nu_data::config::path::default_history_path()
+    };
+
+    if clear {
+        // This is a NOOP, the logic to clear is handled in cli.rs
+        Ok(ActionStream::empty())
+    } else if let Ok(file) = File::open(path) {
+        let reader = BufReader::new(file);
+        // Skips the first line, which is a Rustyline internal
+        let output = reader.lines().skip(1).filter_map(move |line| match line {
+            Ok(line) => Some(ReturnSuccess::value(
+                UntaggedValue::string(line).into_value(tag.clone()),
+            )),
+            Err(_) => None,
+        });
+
+        Ok(output.into_action_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;
+
+        test_examples(History {})
+    }
+}

crates/nu-command/src/commands/core_commands/if_.rs

@@ -6,17 +6,10 @@ use nu_errors::ShellError;
 use nu_protocol::{
     hir::CapturedBlock, hir::ClassifiedCommand, Signature, SyntaxShape, UntaggedValue,
 };
+use nu_stream::OutputStream;
 
 pub struct If;
 
-#[derive(Deserialize)]
-pub struct IfArgs {
-    condition: CapturedBlock,
-    then_case: CapturedBlock,
-    else_case: CapturedBlock,
-}
-
-#[async_trait]
 impl WholeStreamCommand for If {
     fn name(&self) -> &str {
         "if"
@@ -45,8 +38,8 @@ impl WholeStreamCommand for If {
         "Run blocks if a condition is true or false."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        if_command(args).await
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        if_command(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -64,18 +57,16 @@ impl WholeStreamCommand for If {
         ]
     }
 }
-async fn if_command(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let tag = raw_args.call_info.name_tag.clone();
-    let context = Arc::new(EvaluationContext::from_args(&raw_args));
+fn if_command(args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let external_redirection = args.call_info.args.external_redirection;
+    let context = Arc::new(args.context.clone());
+
+    let condition: CapturedBlock = args.req(0)?;
+    let then_case: CapturedBlock = args.req(1)?;
+    let else_case: CapturedBlock = args.req(2)?;
+    let input = args.input;
 
-    let (
-        IfArgs {
-            condition,
-            then_case,
-            else_case,
-        },
-        input,
-    ) = raw_args.process().await?;
     let cond = {
         if condition.block.block.len() != 1 {
             return Err(ShellError::labeled_error(
@@ -86,7 +77,7 @@ async fn if_command(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
         }
         match condition.block.block[0].pipelines.get(0) {
             Some(item) => match item.list.get(0) {
-                Some(ClassifiedCommand::Expr(expr)) => expr.clone(),
+                Some(ClassifiedCommand::Expr(expr)) => expr,
                 _ => {
                     return Err(ShellError::labeled_error(
                         "Expected a condition",
@@ -109,22 +100,26 @@ async fn if_command(raw_args: CommandArgs) -> Result<OutputStream, ShellError> {
     context.scope.add_vars(&condition.captured.entries);
 
     //FIXME: should we use the scope that's brought in as well?
-    let condition = evaluate_baseline_expr(&cond, &*context).await;
+    let condition = evaluate_baseline_expr(cond, &*context);
     match condition {
         Ok(condition) => match condition.as_bool() {
             Ok(b) => {
                 let result = if b {
-                    run_block(&then_case.block, &*context, input).await
+                    run_block(&then_case.block, &*context, input, external_redirection)
                 } else {
-                    run_block(&else_case.block, &*context, input).await
+                    run_block(&else_case.block, &*context, input, external_redirection)
                 };
                 context.scope.exit_scope();
 
-                result.map(|x| x.to_output_stream())
+                result
             }
-            Err(e) => Ok(futures::stream::iter(vec![Err(e)].into_iter()).to_output_stream()),
+            Err(e) => Ok(OutputStream::from_stream(
+                vec![UntaggedValue::Error(e).into_untagged_value()].into_iter(),
+            )),
         },
-        Err(e) => Ok(futures::stream::iter(vec![Err(e)].into_iter()).to_output_stream()),
+        Err(e) => Ok(OutputStream::from_stream(
+            vec![UntaggedValue::Error(e).into_untagged_value()].into_iter(),
+        )),
     }
 }
 

crates/nu-command/src/commands/core_commands/ignore.rs

@@ -0,0 +1,49 @@
+extern crate unicode_segmentation;
+
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::Signature;
+
+pub struct Ignore;
+
+impl WholeStreamCommand for Ignore {
+    fn name(&self) -> &str {
+        "ignore"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("ignore")
+    }
+
+    fn usage(&self) -> &str {
+        "Ignore the output of the previous command in the pipeline"
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        let _: Vec<_> = args.input.collect();
+
+        Ok(OutputStream::empty())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Ignore the output of an echo command",
+            example: r#"echo done | ignore"#,
+            result: None,
+        }]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Ignore;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test as test_examples;
+
+        test_examples(Ignore {})
+    }
+}

crates/nu-command/src/commands/core_commands/let_.rs

@@ -1,20 +1,14 @@
 use crate::prelude::*;
-use nu_engine::{evaluate_baseline_expr, WholeStreamCommand};
+use nu_engine::{evaluate_baseline_expr, FromValue, WholeStreamCommand};
 
 use nu_errors::ShellError;
-use nu_protocol::{hir::CapturedBlock, hir::ClassifiedCommand, Signature, SyntaxShape};
-use nu_source::Tagged;
+use nu_protocol::{
+    hir::{CapturedBlock, ClassifiedCommand},
+    Signature, SyntaxShape, UntaggedValue,
+};
 
 pub struct Let;
 
-#[derive(Deserialize)]
-pub struct LetArgs {
-    pub name: Tagged<String>,
-    pub equals: Tagged<String>,
-    pub rhs: CapturedBlock,
-}
-
-#[async_trait]
 impl WholeStreamCommand for Let {
     fn name(&self) -> &str {
         "let"
@@ -35,22 +29,46 @@ impl WholeStreamCommand for Let {
         "Create a variable and give it a value."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        letcmd(args).await
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        letcmd(args)
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![]
+        vec![
+            Example {
+                description: "Assign a simple value to a variable",
+                example: "let x = 3",
+                result: Some(vec![]),
+            },
+            Example {
+                description: "Assign the result of an expression to a variable",
+                example: "let result = (3 + 7); echo $result",
+                result: Some(vec![UntaggedValue::int(1).into()]),
+            },
+            Example {
+                description: "Create a variable using the full name",
+                example: "let $three = 3",
+                result: Some(vec![]),
+            },
+        ]
     }
 }
 
-pub async fn letcmd(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let tag = args.call_info.name_tag.clone();
-    let ctx = EvaluationContext::from_args(&args);
+pub fn letcmd(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let ctx = &args.context;
+    let positional = args
+        .call_info
+        .args
+        .positional
+        .expect("Internal error: type checker should require args");
 
-    let (LetArgs { name, rhs, .. }, _) = args.process().await?;
+    let var_name = positional[0].var_name()?;
+    let rhs_raw = evaluate_baseline_expr(&positional[2], ctx)?;
+    let tag: Tag = positional[2].span.into();
 
-    let (expr, captured) = {
+    let rhs: CapturedBlock = FromValue::from_value(&rhs_raw)?;
+
+    let (expr, _) = {
         if rhs.block.block.len() != 1 {
             return Err(ShellError::labeled_error(
                 "Expected a value",
@@ -60,7 +78,7 @@ pub async fn letcmd(args: CommandArgs) -> Result<OutputStream, ShellError> {
         }
         match rhs.block.block[0].pipelines.get(0) {
             Some(item) => match item.list.get(0) {
-                Some(ClassifiedCommand::Expr(expr)) => (expr.clone(), rhs.captured.clone()),
+                Some(ClassifiedCommand::Expr(expr)) => (expr, &rhs.captured),
                 _ => {
                     return Err(ShellError::labeled_error(
                         "Expected a value",
@@ -80,24 +98,15 @@ pub async fn letcmd(args: CommandArgs) -> Result<OutputStream, ShellError> {
     };
 
     ctx.scope.enter_scope();
-    ctx.scope.add_vars(&captured.entries);
-
-    let value = evaluate_baseline_expr(&expr, &ctx).await;
-
+    let value = evaluate_baseline_expr(expr, ctx);
     ctx.scope.exit_scope();
 
     let value = value?;
 
-    let name = if name.item.starts_with('$') {
-        name.item.clone()
-    } else {
-        format!("${}", name.item)
-    };
-
     // Note: this is a special case for setting the context from a command
     // In this case, if we don't set it now, we'll lose the scope that this
     // variable should be set into.
-    ctx.scope.add_var(name, value);
+    ctx.scope.add_var(var_name, value);
 
-    Ok(OutputStream::empty())
+    Ok(ActionStream::empty())
 }

crates/nu-command/src/commands/core_commands/mod.rs

@@ -0,0 +1,35 @@
+mod alias;
+mod debug;
+mod def;
+mod describe;
+mod do_;
+pub(crate) mod echo;
+mod help;
+mod history;
+mod if_;
+mod ignore;
+mod let_;
+mod nu_plugin;
+mod nu_signature;
+mod source;
+mod tags;
+mod version;
+
+pub use self::nu_plugin::SubCommand as NuPlugin;
+pub use self::nu_signature::{
+    loglevels, testbins, version as core_version, Command as NuSignature,
+};
+pub use alias::Alias;
+pub use debug::Debug;
+pub use def::Def;
+pub use describe::Describe;
+pub use do_::Do;
+pub use echo::Echo;
+pub use help::Help;
+pub use history::History;
+pub use if_::If;
+pub use ignore::Ignore;
+pub use let_::Let;
+pub use source::Source;
+pub use tags::Tags;
+pub use version::{version, Version};

crates/nu-command/src/commands/core_commands/nu_plugin.rs

@@ -1,10 +1,10 @@
 use std::path::PathBuf;
 
 use crate::prelude::*;
-use nu_engine::filesystem::path::canonicalize;
 use nu_engine::WholeStreamCommand;
 
 use nu_errors::ShellError;
+use nu_path::canonicalize;
 use nu_protocol::{CommandAction, ReturnSuccess, Signature, SyntaxShape, UntaggedValue};
 use nu_source::Tagged;
 
@@ -19,7 +19,6 @@ pub struct Arguments {
     pub load_path: Option<Tagged<PathBuf>>,
 }
 
-#[async_trait]
 impl WholeStreamCommand for SubCommand {
     fn name(&self) -> &str {
         "nu plugin"
@@ -46,10 +45,11 @@ impl WholeStreamCommand for SubCommand {
         }]
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        let scope = args.scope.clone();
-        let shell_manager = args.shell_manager.clone();
-        let (Arguments { load_path }, _) = args.process().await?;
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        let scope = args.scope().clone();
+        let shell_manager = args.shell_manager();
+
+        let load_path: Option<Tagged<PathBuf>> = args.get_flag("load")?;
 
         if let Some(Tagged {
             item: load_path,
@@ -100,7 +100,7 @@ impl WholeStreamCommand for SubCommand {
             .into());
         }
 
-        Ok(OutputStream::one(ReturnSuccess::value(
+        Ok(ActionStream::one(ReturnSuccess::value(
             UntaggedValue::string(get_full_help(&SubCommand, &scope)).into_value(Tag::unknown()),
         )))
     }

crates/nu-command/src/commands/core_commands/nu_signature.rs

@@ -0,0 +1,70 @@
+use nu_engine::WholeStreamCommand;
+use nu_protocol::{Signature, SyntaxShape};
+
+pub struct Command;
+
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "nu"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("nu")
+            .switch("version", "Display Nu version", Some('v'))
+            .switch("stdin", "redirect stdin", None)
+            .switch("skip-plugins", "do not load plugins", None)
+            .switch("no-history", "don't save history", None)
+            .switch("perf", "show startup performance metrics", None)
+            .named(
+                "commands",
+                SyntaxShape::String,
+                "commands to run",
+                Some('c'),
+            )
+            .named(
+                "testbin",
+                SyntaxShape::String,
+                "test bin: echo_env, cococo, iecho, fail, nonu, chop, repeater, meow",
+                None,
+            )
+            .named("develop", SyntaxShape::String, "trace mode", None)
+            .named("debug", SyntaxShape::String, "debug mode", None)
+            .named(
+                "loglevel",
+                SyntaxShape::String,
+                "LEVEL: error, warn, info, debug, trace",
+                Some('l'),
+            )
+            .named(
+                "config-file",
+                SyntaxShape::FilePath,
+                "custom configuration source file",
+                None,
+            )
+            .rest(SyntaxShape::String, "source file(s) to run")
+    }
+
+    fn usage(&self) -> &str {
+        "Nu - A new type of shell."
+    }
+}
+
+pub fn version() -> &'static str {
+    env!("CARGO_PKG_VERSION")
+}
+
+pub fn testbins() -> Vec<String> {
+    vec![
+        "echo_env", "cococo", "iecho", "fail", "nonu", "chop", "repeater", "meow",
+    ]
+    .into_iter()
+    .map(String::from)
+    .collect()
+}
+
+pub fn loglevels() -> Vec<String> {
+    vec!["error", "warn", "info", "debug", "trace"]
+        .into_iter()
+        .map(String::from)
+        .collect()
+}

crates/nu-command/src/commands/core_commands/source.rs

@@ -2,10 +2,12 @@ use crate::prelude::*;
 use nu_engine::{script, WholeStreamCommand};
 
 use nu_errors::ShellError;
-use nu_parser::expand_path;
+use nu_path::expand_path;
 use nu_protocol::{Signature, SyntaxShape};
 use nu_source::Tagged;
 
+use std::{borrow::Cow, path::Path};
+
 pub struct Source;
 
 #[derive(Deserialize)]
@@ -13,7 +15,6 @@ pub struct SourceArgs {
     pub filename: Tagged<String>,
 }
 
-#[async_trait]
 impl WholeStreamCommand for Source {
     fn name(&self) -> &str {
         "source"
@@ -22,7 +23,7 @@ impl WholeStreamCommand for Source {
     fn signature(&self) -> Signature {
         Signature::build("source").required(
             "filename",
-            SyntaxShape::String,
+            SyntaxShape::FilePath,
             "the filepath to the script file to source",
         )
     }
@@ -31,8 +32,8 @@ impl WholeStreamCommand for Source {
         "Runs a script file in the current context."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
-        source(args).await
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
+        source(args)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -40,22 +41,22 @@ impl WholeStreamCommand for Source {
     }
 }
 
-pub async fn source(args: CommandArgs) -> Result<OutputStream, ShellError> {
-    let ctx = EvaluationContext::from_args(&args);
-    let (SourceArgs { filename }, _) = args.process().await?;
+pub fn source(args: CommandArgs) -> Result<ActionStream, ShellError> {
+    let ctx = &args.context;
+    let filename: Tagged<String> = args.req(0)?;
 
     // Note: this is a special case for setting the context from a command
     // In this case, if we don't set it now, we'll lose the scope that this
     // variable should be set into.
-    let contents = std::fs::read_to_string(expand_path(&filename.item).into_owned());
+    let contents = std::fs::read_to_string(&expand_path(Cow::Borrowed(Path::new(&filename.item))));
     match contents {
         Ok(contents) => {
-            let result = script::run_script_standalone(contents, true, &ctx, false).await;
+            let result = script::run_script_standalone(contents, true, ctx, false);
 
             if let Err(err) = result {
-                ctx.error(err.into());
+                ctx.error(err);
             }
-            Ok(OutputStream::empty())
+            Ok(ActionStream::empty())
         }
         Err(_) => {
             ctx.error(ShellError::labeled_error(
@@ -64,7 +65,7 @@ pub async fn source(args: CommandArgs) -> Result<OutputStream, ShellError> {
                 filename.span(),
             ));
 
-            Ok(OutputStream::empty())
+            Ok(ActionStream::empty())
         }
     }
 }

crates/nu-command/src/commands/core_commands/tags.rs

@@ -5,7 +5,6 @@ use nu_protocol::{Signature, TaggedDictBuilder, UntaggedValue};
 
 pub struct Tags;
 
-#[async_trait]
 impl WholeStreamCommand for Tags {
     fn name(&self) -> &str {
         "tags"
@@ -19,12 +18,12 @@ impl WholeStreamCommand for Tags {
         "Read the tags (metadata) for values."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+    fn run_with_actions(&self, args: CommandArgs) -> Result<ActionStream, ShellError> {
         Ok(tags(args))
     }
 }
 
-fn tags(args: CommandArgs) -> OutputStream {
+fn tags(args: CommandArgs) -> ActionStream {
     args.input
         .map(move |v| {
             let mut tags = TaggedDictBuilder::new(v.tag());
@@ -49,7 +48,7 @@ fn tags(args: CommandArgs) -> OutputStream {
 
             tags.into_value()
         })
-        .to_output_stream()
+        .into_action_stream()
 }
 
 #[cfg(test)]

crates/nu-command/src/commands/core_commands/version.rs

@@ -10,7 +10,6 @@ pub mod shadow {
 
 pub struct Version;
 
-#[async_trait]
 impl WholeStreamCommand for Version {
     fn name(&self) -> &str {
         "version"
@@ -24,7 +23,7 @@ impl WholeStreamCommand for Version {
         "Display Nu version."
     }
 
-    async fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
         version(args)
     }
 
@@ -44,7 +43,7 @@ pub fn version(args: CommandArgs) -> Result<OutputStream, ShellError> {
 
     indexmap.insert(
         "version".to_string(),
-        UntaggedValue::string(clap::crate_version!()).into_value(&tag),
+        UntaggedValue::string(super::nu_signature::version()).into_value(&tag),
     );
 
     let branch: Option<&str> = Some(shadow::BRANCH).filter(|x| !x.is_empty());
@@ -141,6 +140,43 @@ pub fn version(args: CommandArgs) -> Result<OutputStream, ShellError> {
         features_enabled().join(", ").to_string_value_create_tag(),
     );
 
+    // Manually create a list of all possible plugin names
+    let all_plugins = vec![
+        "fetch",
+        "inc",
+        "match",
+        "post",
+        "ps",
+        "sys",
+        "textview",
+        "binaryview",
+        "chart bar",
+        "chart line",
+        "from bson",
+        "from sqlite",
+        "query json",
+        "s3",
+        "selector",
+        "start",
+        "to bson",
+        "to sqlite",
+        "tree",
+        "xpath",
+    ];
+
+    // Get a list of command names and check for plugins
+    let installed_plugins = args
+        .scope()
+        .get_command_names()
+        .into_iter()
+        .filter(|cmd| all_plugins.contains(&cmd.as_str()))
+        .collect::<Vec<_>>();
+
+    indexmap.insert(
+        "installed_plugins".to_string(),
+        installed_plugins.join(", ").to_string_value_create_tag(),
+    );
+
     let value = UntaggedValue::Row(Dictionary::from(indexmap)).into_value(&tag);
     Ok(OutputStream::one(value))
 }
@@ -148,26 +184,13 @@ pub fn version(args: CommandArgs) -> Result<OutputStream, ShellError> {
 fn features_enabled() -> Vec<String> {
     let mut names = vec!["default".to_string()];
 
+    // NOTE: There should be another way to know
+    // features on.
     #[cfg(feature = "ctrlc")]
     {
         names.push("ctrlc".to_string());
     }
 
-    #[cfg(feature = "dirs")]
-    {
-        names.push("dirs".to_string());
-    }
-
-    #[cfg(feature = "directories")]
-    {
-        names.push("directories".to_string());
-    }
-
-    #[cfg(feature = "ptree")]
-    {
-        names.push("ptree".to_string());
-    }
-
     // #[cfg(feature = "rich-benchmark")]
     // {
     //     names.push("rich-benchmark".to_string());
@@ -193,11 +216,6 @@ fn features_enabled() -> Vec<String> {
         names.push("which".to_string());
     }
 
-    #[cfg(feature = "ichwh")]
-    {
-        names.push("ichwh".to_string());
-    }
-
     #[cfg(feature = "zip")]
     {
         names.push("zip".to_string());
@@ -213,6 +231,16 @@ fn features_enabled() -> Vec<String> {
         names.push("trash".to_string());
     }
 
+    #[cfg(feature = "dataframe")]
+    {
+        names.push("dataframe".to_string());
+    }
+
+    #[cfg(feature = "table-pager")]
+    {
+        names.push("table-pager".to_string());
+    }
+
     // #[cfg(feature = "binaryview")]
     // {
     //     names.push("binaryview".to_string());

crates/nu-command/src/commands/dataframe/aggregate.rs

@@ -0,0 +1,293 @@
+use crate::{commands::dataframe::utils::parse_polars_error, prelude::*};
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, FrameStruct, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
+use nu_source::Tagged;
+use polars::{frame::groupby::GroupBy, prelude::PolarsError};
+
+enum Operation {
+    Mean,
+    Sum,
+    Min,
+    Max,
+    First,
+    Last,
+    Nunique,
+    Quantile(f64),
+    Median,
+    Var,
+    Std,
+    Count,
+}
+
+impl Operation {
+    fn from_tagged(
+        name: &Tagged<String>,
+        quantile: Option<Tagged<f64>>,
+    ) -> Result<Operation, ShellError> {
+        match name.item.as_ref() {
+            "mean" => Ok(Operation::Mean),
+            "sum" => Ok(Operation::Sum),
+            "min" => Ok(Operation::Min),
+            "max" => Ok(Operation::Max),
+            "first" => Ok(Operation::First),
+            "last" => Ok(Operation::Last),
+            "nunique" => Ok(Operation::Nunique),
+            "quantile" => {
+                match quantile {
+                    None => Err(ShellError::labeled_error(
+                        "Quantile value not fount",
+                        "Quantile operation requires quantile value",
+                        &name.tag,
+                    )),
+                Some(value ) => {
+                    if (value.item < 0.0) | (value.item > 1.0) {
+                        Err(ShellError::labeled_error(
+                            "Inappropriate quantile",
+                            "Quantile value should be between 0.0 and 1.0",
+                            &value.tag,
+                        ))
+                    } else {
+                        Ok(Operation::Quantile(value.item))
+                    }
+                }
+                }
+            }
+            "median" => Ok(Operation::Median),
+            "var" => Ok(Operation::Var),
+            "std" => Ok(Operation::Std),
+            "count" => Ok(Operation::Count),
+            _ => Err(ShellError::labeled_error_with_secondary(
+                "Operation not fount",
+                "Operation does not exist",
+                &name.tag,
+                "Perhaps you want: mean, sum, min, max, first, last, nunique, quantile, median, var, std, or count",
+                &name.tag,
+            )),
+        }
+    }
+}
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe aggregate"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame, GroupBy, Series] Performs an aggregation operation on a dataframe, groupby or series object"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe aggregate")
+            .required("operation", SyntaxShape::String, "aggregate operation")
+            .named(
+                "quantile",
+                SyntaxShape::Number,
+                "quantile value for quantile operation",
+                Some('q'),
+            )
+            .switch(
+                "explicit",
+                "returns explicit names for groupby aggregations",
+                Some('e'),
+            )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Aggregate sum by grouping by column a and summing on col b",
+                example:
+                    "[[a b]; [one 1] [one 2]] | dataframe to-df | dataframe group-by a | dataframe aggregate sum",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("a".to_string(), vec![UntaggedValue::string("one").into()]),
+                        Column::new("b".to_string(), vec![UntaggedValue::int(3).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+            Example {
+                description: "Aggregate sum in dataframe columns",
+                example: "[[a b]; [4 1] [5 2]] | dataframe to-df | dataframe aggregate sum",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("a".to_string(), vec![UntaggedValue::int(9).into()]),
+                        Column::new("b".to_string(), vec![UntaggedValue::int(3).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+            Example {
+                description: "Aggregate sum in series",
+                example: "[4 1 5 6] | dataframe to-df | dataframe aggregate sum",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new("0".to_string(), vec![UntaggedValue::int(16).into()]),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+        ]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let quantile: Option<Tagged<f64>> = args.get_flag("quantile")?;
+    let operation: Tagged<String> = args.req(0)?;
+    let op = Operation::from_tagged(&operation, quantile)?;
+
+    let value = args.input.next().ok_or_else(|| {
+        ShellError::labeled_error("Empty stream", "No value found in the stream", &tag)
+    })?;
+
+    match value.value {
+        UntaggedValue::FrameStruct(FrameStruct::GroupBy(nu_groupby)) => {
+            let groupby = nu_groupby.to_groupby()?;
+
+            let res = perform_groupby_aggregation(
+                groupby,
+                op,
+                &operation.tag,
+                &tag.span,
+                args.has_flag("explicit"),
+            )?;
+
+            Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+        }
+        UntaggedValue::DataFrame(df) => {
+            let df = df.as_ref();
+
+            let res = perform_dataframe_aggregation(df, op, &operation.tag)?;
+
+            Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+        }
+        _ => Err(ShellError::labeled_error(
+            "No groupby, dataframe or series in stream",
+            "no groupby, dataframe or series found in input stream",
+            &value.tag.span,
+        )),
+    }
+}
+
+fn perform_groupby_aggregation(
+    groupby: GroupBy,
+    operation: Operation,
+    operation_tag: &Tag,
+    agg_span: &Span,
+    explicit: bool,
+) -> Result<polars::prelude::DataFrame, ShellError> {
+    let mut res = match operation {
+        Operation::Mean => groupby.mean(),
+        Operation::Sum => groupby.sum(),
+        Operation::Min => groupby.min(),
+        Operation::Max => groupby.max(),
+        Operation::First => groupby.first(),
+        Operation::Last => groupby.last(),
+        Operation::Nunique => groupby.n_unique(),
+        Operation::Quantile(quantile) => groupby.quantile(quantile),
+        Operation::Median => groupby.median(),
+        Operation::Var => groupby.var(),
+        Operation::Std => groupby.std(),
+        Operation::Count => groupby.count(),
+    }
+    .map_err(|e| {
+        let span = match &e {
+            PolarsError::NotFound(_) => agg_span,
+            _ => &operation_tag.span,
+        };
+
+        parse_polars_error::<&str>(&e, span, None)
+    })?;
+
+    if !explicit {
+        let col_names = res
+            .get_column_names()
+            .iter()
+            .map(|name| name.to_string())
+            .collect::<Vec<String>>();
+
+        for col in col_names {
+            let from = match operation {
+                Operation::Mean => "_mean",
+                Operation::Sum => "_sum",
+                Operation::Min => "_min",
+                Operation::Max => "_max",
+                Operation::First => "_first",
+                Operation::Last => "_last",
+                Operation::Nunique => "_n_unique",
+                Operation::Quantile(_) => "_quantile",
+                Operation::Median => "_median",
+                Operation::Var => "_agg_var",
+                Operation::Std => "_agg_std",
+                Operation::Count => "_count",
+            };
+
+            let new_col = match col.find(from) {
+                Some(index) => &col[..index],
+                None => &col[..],
+            };
+
+            res.rename(col.as_str(), new_col)
+                .expect("Column is always there. Looping with known names");
+        }
+    }
+
+    Ok(res)
+}
+
+fn perform_dataframe_aggregation(
+    dataframe: &polars::prelude::DataFrame,
+    operation: Operation,
+    operation_tag: &Tag,
+) -> Result<polars::prelude::DataFrame, ShellError> {
+    match operation {
+        Operation::Mean => Ok(dataframe.mean()),
+        Operation::Sum => Ok(dataframe.sum()),
+        Operation::Min => Ok(dataframe.min()),
+        Operation::Max => Ok(dataframe.max()),
+        Operation::Quantile(quantile) => dataframe
+            .quantile(quantile)
+            .map_err(|e| parse_polars_error::<&str>(&e, &operation_tag.span, None)),
+        Operation::Median => Ok(dataframe.median()),
+        Operation::Var => Ok(dataframe.var()),
+        Operation::Std => Ok(dataframe.std()),
+        _ => Err(ShellError::labeled_error_with_secondary(
+            "Not valid operation",
+            "operation not valid for dataframe",
+            &operation_tag.span,
+            "Perhaps you want: mean, sum, min, max, quantile, median, var, or std",
+            &operation_tag.span,
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/append.rs

@@ -0,0 +1,138 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Axis, Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+use nu_source::Tagged;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe append"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Appends a new dataframe"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe append")
+            .required_named(
+                "other",
+                SyntaxShape::Any,
+                "dataframe to be appended",
+                Some('o'),
+            )
+            .required_named(
+                "axis",
+                SyntaxShape::String,
+                "row or col axis orientation",
+                Some('a'),
+            )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Appends a dataframe as new columns",
+                example: r#"let a = ([[a b]; [1 2] [3 4]] | dataframe to-df);
+    $a | dataframe append -o $a -a row"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                        ),
+                        Column::new(
+                            "a_x".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                        ),
+                        Column::new(
+                            "b_x".to_string(),
+                            vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+            Example {
+                description: "Appends a dataframe merging at the end of columns",
+                example: r#"let a = ([[a b]; [1 2] [3 4]] | dataframe to-df);
+    $a | dataframe append -o $a -a col"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(3).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(3).into(),
+                            ],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![
+                                UntaggedValue::int(2).into(),
+                                UntaggedValue::int(4).into(),
+                                UntaggedValue::int(2).into(),
+                                UntaggedValue::int(4).into(),
+                            ],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+        ]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let other: Value = args.req_named("other")?;
+    let axis: Tagged<String> = args.req_named("axis")?;
+
+    let axis = Axis::try_from_str(axis.item.as_str(), &axis.tag.span)?;
+
+    let df_other = match other.value {
+        UntaggedValue::DataFrame(df) => Ok(df),
+        _ => Err(ShellError::labeled_error(
+            "Incorrect type",
+            "can only append a dataframe to a dataframe",
+            other.tag.span,
+        )),
+    }?;
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let df_new = df.append_df(&df_other, axis, &tag.span)?;
+    Ok(OutputStream::one(df_new.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/column.rs

@@ -0,0 +1,74 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue,
+};
+
+use nu_source::Tagged;
+
+use super::utils::parse_polars_error;
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe column"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Returns the selected column as Series"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe column").required("column", SyntaxShape::String, "column name")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Returns the selected column as series",
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe column a",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "a".to_string(),
+                    vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+    let column: Tagged<String> = args.req(0)?;
+
+    let (df, df_tag) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let res = df
+        .as_ref()
+        .column(column.item.as_ref())
+        .map_err(|e| parse_polars_error::<&str>(&e, &column.tag.span, None))?;
+
+    let df = NuDataFrame::try_from_series(vec![res.clone()], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(df_tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

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

@@ -0,0 +1,26 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{Signature, UntaggedValue};
+
+pub struct Command;
+
+impl WholeStreamCommand for Command {
+    fn name(&self) -> &str {
+        "dataframe"
+    }
+
+    fn usage(&self) -> &str {
+        "Commands to work with polars dataframes"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        Ok(OutputStream::one(
+            UntaggedValue::string(get_full_help(&Command, args.scope())).into_value(Tag::unknown()),
+        ))
+    }
+}

crates/nu-command/src/commands/dataframe/drop.rs

@@ -0,0 +1,89 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+use super::utils::{convert_columns, parse_polars_error};
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe drop"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Creates a new dataframe by dropping the selected columns"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe drop").rest(SyntaxShape::Any, "column names to be dropped")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "drop column a",
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe drop a",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![Column::new(
+                    "b".to_string(),
+                    vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                )],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let columns: Vec<Value> = args.rest(0)?;
+    let (col_string, col_span) = convert_columns(&columns, &tag)?;
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let new_df = match col_string.get(0) {
+        Some(col) => df
+            .as_ref()
+            .drop(col)
+            .map_err(|e| parse_polars_error::<&str>(&e, &col_span, None)),
+        None => Err(ShellError::labeled_error(
+            "Empty names list",
+            "No column names where found",
+            &col_span,
+        )),
+    }?;
+
+    // If there are more columns in the drop selection list, these
+    // are added from the resulting dataframe
+    let res = col_string.iter().skip(1).try_fold(new_df, |new_df, col| {
+        new_df
+            .drop(col)
+            .map_err(|e| parse_polars_error::<&str>(&e, &col_span, None))
+    })?;
+
+    Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/drop_duplicates.rs

@@ -0,0 +1,95 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+use super::utils::{convert_columns, parse_polars_error};
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe drop-duplicates"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Drops duplicate values in dataframe"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe drop-duplicates")
+            .optional(
+                "subset",
+                SyntaxShape::Table,
+                "subset of columns to drop duplicates",
+            )
+            .switch("maintain", "maintain order", Some('m'))
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "drop duplicates",
+            example: "[[a b]; [1 2] [3 4] [1 2]] | dataframe to-df | dataframe drop-duplicates",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "a".to_string(),
+                        vec![UntaggedValue::int(1).into(), UntaggedValue::int(3).into()],
+                    ),
+                    Column::new(
+                        "b".to_string(),
+                        vec![UntaggedValue::int(2).into(), UntaggedValue::int(4).into()],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    // Extracting the selection columns of the columns to perform the aggregation
+    let columns: Option<Vec<Value>> = args.opt(0)?;
+    let (subset, col_span) = match columns {
+        Some(cols) => {
+            let (agg_string, col_span) = convert_columns(&cols, &tag)?;
+            (Some(agg_string), col_span)
+        }
+        None => (None, Span::unknown()),
+    };
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let subset_slice = subset.as_ref().map(|cols| &cols[..]);
+
+    let res = df
+        .as_ref()
+        .drop_duplicates(args.has_flag("maintain"), subset_slice)
+        .map_err(|e| parse_polars_error::<&str>(&e, &col_span, None))?;
+
+    Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/drop_nulls.rs

@@ -0,0 +1,132 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+use super::utils::{convert_columns, parse_polars_error};
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe drop-nulls"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame, Series] Drops null values in dataframe"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe drop-nulls").optional(
+            "subset",
+            SyntaxShape::Table,
+            "subset of columns to drop duplicates",
+        )
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "drop null values in dataframe",
+                example: r#"let df = ([[a b]; [1 2] [3 0] [1 2]] | dataframe to-df);
+    let res = ($df.b / $df.b);
+    let df = ($df | dataframe with-column $res --name res);
+    $df | dataframe drop-nulls"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(1).into()],
+                        ),
+                        Column::new(
+                            "b".to_string(),
+                            vec![UntaggedValue::int(2).into(), UntaggedValue::int(2).into()],
+                        ),
+                        Column::new(
+                            "res".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(1).into()],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+            Example {
+                description: "drop null values in dataframe",
+                example: r#"let s = ([1 2 0 0 3 4] | dataframe to-df);
+    ($s / $s) | dataframe drop-nulls"#,
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![Column::new(
+                        "div_0_0".to_string(),
+                        vec![
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(1).into(),
+                            UntaggedValue::int(1).into(),
+                        ],
+                    )],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+        ]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let value = args.input.next().ok_or_else(|| {
+        ShellError::labeled_error("Empty stream", "No value found in stream", &tag.span)
+    })?;
+
+    match value.value {
+        UntaggedValue::DataFrame(df) => {
+            // Extracting the selection columns of the columns to perform the aggregation
+            let columns: Option<Vec<Value>> = args.opt(0)?;
+            let (subset, col_span) = match columns {
+                Some(cols) => {
+                    let (agg_string, col_span) = convert_columns(&cols, &tag)?;
+                    (Some(agg_string), col_span)
+                }
+                None => (None, Span::unknown()),
+            };
+
+            let subset_slice = subset.as_ref().map(|cols| &cols[..]);
+
+            let res = df
+                .as_ref()
+                .drop_nulls(subset_slice)
+                .map_err(|e| parse_polars_error::<&str>(&e, &col_span, None))?;
+
+            Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+        }
+        _ => Err(ShellError::labeled_error(
+            "Incorrect type",
+            "drop nulls cannot be done with this value",
+            &value.tag.span,
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/dtypes.rs

@@ -0,0 +1,106 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue, Value,
+};
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe dtypes"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Show dataframe data types"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe dtypes")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "drop column a",
+            example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe dtypes",
+            result: Some(vec![NuDataFrame::try_from_columns(
+                vec![
+                    Column::new(
+                        "column".to_string(),
+                        vec![
+                            UntaggedValue::string("a").into(),
+                            UntaggedValue::string("b").into(),
+                        ],
+                    ),
+                    Column::new(
+                        "dtype".to_string(),
+                        vec![
+                            UntaggedValue::string("i64").into(),
+                            UntaggedValue::string("i64").into(),
+                        ],
+                    ),
+                ],
+                &Span::default(),
+            )
+            .expect("simple df for test should not fail")
+            .into_value(Tag::default())]),
+        }]
+    }
+}
+
+#[allow(clippy::needless_collect)]
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let (df, _) = NuDataFrame::try_from_stream(&mut args.input, &tag.span)?;
+
+    let mut dtypes: Vec<Value> = Vec::new();
+    let names: Vec<Value> = df
+        .as_ref()
+        .get_column_names()
+        .iter()
+        .map(|v| {
+            let dtype = df
+                .as_ref()
+                .column(v)
+                .expect("using name from list of names from dataframe")
+                .dtype();
+
+            let dtype_str = format!("{}", dtype);
+            dtypes.push(Value {
+                value: dtype_str.into(),
+                tag: Tag::default(),
+            });
+
+            Value {
+                value: v.to_string().into(),
+                tag: Tag::default(),
+            }
+        })
+        .collect();
+
+    let names_col = Column::new("column".to_string(), names);
+    let dtypes_col = Column::new("dtype".to_string(), dtypes);
+
+    let df = NuDataFrame::try_from_columns(vec![names_col, dtypes_col], &tag.span)?;
+    Ok(OutputStream::one(df.into_value(tag)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}

crates/nu-command/src/commands/dataframe/dummies.rs

@@ -0,0 +1,142 @@
+use crate::prelude::*;
+use nu_engine::WholeStreamCommand;
+use nu_errors::ShellError;
+use nu_protocol::{
+    dataframe::{Column, NuDataFrame},
+    Signature, UntaggedValue,
+};
+
+use super::utils::parse_polars_error;
+
+pub struct DataFrame;
+
+impl WholeStreamCommand for DataFrame {
+    fn name(&self) -> &str {
+        "dataframe to-dummies"
+    }
+
+    fn usage(&self) -> &str {
+        "[DataFrame] Creates a new dataframe with dummy variables"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("dataframe to-dummies")
+    }
+
+    fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> {
+        command(args)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create new dataframe with dummy variables from a dataframe",
+                example: "[[a b]; [1 2] [3 4]] | dataframe to-df | dataframe to-dummies",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "a_1".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(0).into()],
+                        ),
+                        Column::new(
+                            "a_3".to_string(),
+                            vec![UntaggedValue::int(0).into(), UntaggedValue::int(1).into()],
+                        ),
+                        Column::new(
+                            "b_2".to_string(),
+                            vec![UntaggedValue::int(1).into(), UntaggedValue::int(0).into()],
+                        ),
+                        Column::new(
+                            "b_4".to_string(),
+                            vec![UntaggedValue::int(0).into(), UntaggedValue::int(1).into()],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+            Example {
+                description: "Create new dataframe with dummy variables from a series",
+                example: "[1 2 2 3 3] | dataframe to-df | dataframe to-dummies",
+                result: Some(vec![NuDataFrame::try_from_columns(
+                    vec![
+                        Column::new(
+                            "0_1".to_string(),
+                            vec![
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                            ],
+                        ),
+                        Column::new(
+                            "0_2".to_string(),
+                            vec![
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                            ],
+                        ),
+                        Column::new(
+                            "0_3".to_string(),
+                            vec![
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(0).into(),
+                                UntaggedValue::int(1).into(),
+                                UntaggedValue::int(1).into(),
+                            ],
+                        ),
+                    ],
+                    &Span::default(),
+                )
+                .expect("simple df for test should not fail")
+                .into_value(Tag::default())]),
+            },
+        ]
+    }
+}
+
+fn command(mut args: CommandArgs) -> Result<OutputStream, ShellError> {
+    let tag = args.call_info.name_tag.clone();
+
+    let value = args.input.next().ok_or_else(|| {
+        ShellError::labeled_error("Empty stream", "No value found in stream", &tag.span)
+    })?;
+
+    match value.value {
+        UntaggedValue::DataFrame(df) => {
+            let res = df.as_ref().to_dummies().map_err(|e| {
+                parse_polars_error(
+                    &e,
+                    &tag.span,
+                    Some("The only allowed column types for dummies are String or Int"),
+                )
+            })?;
+
+            Ok(OutputStream::one(NuDataFrame::dataframe_to_value(res, tag)))
+        }
+        _ => Err(ShellError::labeled_error(
+            "Incorrect type",
+            "dummies cannot be done with this value",
+            &value.tag.span,
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DataFrame;
+    use super::ShellError;
+
+    #[test]
+    fn examples_work_as_expected() -> Result<(), ShellError> {
+        use crate::examples::test_dataframe as test_examples;
+
+        test_examples(DataFrame {})
+    }
+}