Update Cargo.toml

Fixes #1626 and [this ichwh issue](https://gitlab.com/avandesa/ichwh-rs/-/issues/3)

.azure/azure-pipelines.yml

@@ -59,4 +59,3 @@ steps:
   - bash: cargo fmt --all -- --check
     condition: eq(variables['style'], 'fmt')
     displayName: Lint
-    

.cargo/config

@@ -1,3 +1,3 @@
 [build]
 
-#rustflags = ["--cfg", "coloring_in_tokens"]
+#rustflags = ["--cfg", "data_processing_primitives"]

.circleci/config.yml

@@ -38,7 +38,7 @@ workflows:
           extra_build_args: --cache-from=quay.io/nushell/nu-base:devel
           filters:
             branches:
-              ignore: 
+              ignore:
                 - master
           before_build:
             - pull_cache

.github/workflows/docker-publish.yml

@@ -24,7 +24,7 @@ jobs:
       run: |
         cross build --target ${{ matrix.arch }} --release
         # leave only the executable file
-        rm -rd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
+        rm -frd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
         find . -empty -delete
     - uses: actions/upload-artifact@master
       with:
@@ -52,15 +52,15 @@ jobs:
         - glibc
         - musl
         include:
-        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true    }
-        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true    }
-        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true    }
-        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  use-patch: true }
-        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl,                 }
-        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl,                 }
-        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  use-patch: true }
-        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,                  }
-        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl,                 }
+        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true,  use-patch: false}
+        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
+        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
+        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
+        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
+        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
+        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
+        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: false}
+        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
     steps:
     - uses: actions/checkout@v1
     - uses: actions/download-artifact@master

CONTRIBUTING.md

@@ -0,0 +1,11 @@
+Welcome to nushell!
+
+*Note: for a more complete guide see [The nu contributor book](https://github.com/nushell/contributor-book)*
+
+For speedy contributions open it in Gitpod, nu will be pre-installed with the latest build in a VSCode like editor all from your browser.
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)
+
+To get live support from the community see our [Discord](https://discordapp.com/invite/NtAbbGn), [Twitter](https://twitter.com/nu_shell) or file an issue or feature request here on [GitHub](https://github.com/nushell/nushell/issues/new/choose)!
+<!--WIP-->
+

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "nu"
-version = "0.11.0"
-authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
-description = "A shell for the GitHub era"
+version = "0.13.0"
+authors = ["The Nu Project Contributors"]
+description = "A new type of shell"
 license = "MIT"
 edition = "2018"
 readme = "README.md"
@@ -18,31 +18,28 @@ members = ["crates/*/"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-cli = { version = "0.11.0", path = "./crates/nu-cli" }
-nu-source = { version = "0.11.0", path = "./crates/nu-source" }
-nu-plugin = { version = "0.11.0", path = "./crates/nu-plugin" }
-nu-protocol = { version = "0.11.0", path = "./crates/nu-protocol" }
-nu-errors = { version = "0.11.0", path = "./crates/nu-errors" }
-nu-parser = { version = "0.11.0", path = "./crates/nu-parser" }
-nu-value-ext = { version = "0.11.0", path = "./crates/nu-value-ext" }
-nu_plugin_average = { version = "0.11.0", path = "./crates/nu_plugin_average", optional=true }
-nu_plugin_binaryview = { version = "0.11.0", path = "./crates/nu_plugin_binaryview", optional=true }
-nu_plugin_fetch = { version = "0.11.0", path = "./crates/nu_plugin_fetch", optional=true }
-nu_plugin_inc = { version = "0.11.0", path = "./crates/nu_plugin_inc", optional=true }
-nu_plugin_match = { version = "0.11.0", path = "./crates/nu_plugin_match", optional=true }
-nu_plugin_post = { version = "0.11.0", path = "./crates/nu_plugin_post", optional=true }
-nu_plugin_ps = { version = "0.11.0", path = "./crates/nu_plugin_ps", optional=true }
-nu_plugin_str = { version = "0.11.0", path = "./crates/nu_plugin_str", optional=true }
-nu_plugin_sum = { version = "0.11.0", path = "./crates/nu_plugin_sum", optional=true }
-nu_plugin_sys = { version = "0.11.0", path = "./crates/nu_plugin_sys", optional=true }
-nu_plugin_textview = { version = "0.11.0", path = "./crates/nu_plugin_textview", optional=true }
-nu_plugin_tree = { version = "0.11.0", path = "./crates/nu_plugin_tree", optional=true }
-nu-macros = { version = "0.11.0", path = "./crates/nu-macros" }
+nu-cli = { version = "0.13.0", path = "./crates/nu-cli" }
+nu-source = { version = "0.13.0", path = "./crates/nu-source" }
+nu-plugin = { version = "0.13.0", path = "./crates/nu-plugin" }
+nu-protocol = { version = "0.13.0", path = "./crates/nu-protocol" }
+nu-errors = { version = "0.13.0", path = "./crates/nu-errors" }
+nu-parser = { version = "0.13.0", path = "./crates/nu-parser" }
+nu-value-ext = { version = "0.13.0", path = "./crates/nu-value-ext" }
+nu_plugin_average = { version = "0.13.0", path = "./crates/nu_plugin_average", optional=true }
+nu_plugin_binaryview = { version = "0.13.0", path = "./crates/nu_plugin_binaryview", optional=true }
+nu_plugin_fetch = { version = "0.13.0", path = "./crates/nu_plugin_fetch", optional=true }
+nu_plugin_inc = { version = "0.13.0", path = "./crates/nu_plugin_inc", optional=true }
+nu_plugin_match = { version = "0.13.0", path = "./crates/nu_plugin_match", optional=true }
+nu_plugin_post = { version = "0.13.0", path = "./crates/nu_plugin_post", optional=true }
+nu_plugin_ps = { version = "0.13.0", path = "./crates/nu_plugin_ps", optional=true }
+nu_plugin_str = { version = "0.13.0", path = "./crates/nu_plugin_str", optional=true }
+nu_plugin_sys = { version = "0.13.0", path = "./crates/nu_plugin_sys", optional=true }
+nu_plugin_textview = { version = "0.13.0", path = "./crates/nu_plugin_textview", optional=true }
+nu_plugin_tree = { version = "0.13.0", path = "./crates/nu_plugin_tree", optional=true }
 
-crossterm = { version = "0.16.0", optional = true }
-onig_sys = { version = "=69.1.0", optional = true }
+crossterm = { version = "0.17.2", optional = true }
 semver = { version = "0.9.0", optional = true }
-syntect = { version = "3.2.0", optional = true }
+syntect = { version = "4.1", default-features = false, features = ["default-fancy"], optional = true}
 url = { version = "2.1.1", optional = true }
 
 clap = "2.33.0"
@@ -53,23 +50,22 @@ log = "0.4.8"
 pretty_env_logger = "0.4.0"
 
 [dev-dependencies]
-pretty_assertions = "0.6.1"
-nu-test-support = { version = "0.11.0", path = "./crates/nu-test-support" }
+nu-test-support = { version = "0.13.0", path = "./crates/nu-test-support" }
 
 [build-dependencies]
 toml = "0.5.6"
-serde = { version = "1.0.104", features = ["derive"] }
-nu-build = { version = "0.11.0", path = "./crates/nu-build" }
+serde = { version = "1.0.106", features = ["derive"] }
+nu-build = { version = "0.13.0", path = "./crates/nu-build" }
 
 [features]
 # Test executables
 test-bins = []
 
 default = ["sys", "ps", "textview", "inc", "str"]
-stable = ["default", "starship-prompt", "binaryview", "match", "tree", "average", "sum", "post", "fetch", "clipboard-cli"]
+stable = ["default", "starship-prompt", "binaryview", "match", "tree", "average", "post", "fetch", "clipboard-cli", "trash-support"]
 
 # Default
-textview = ["crossterm", "syntect", "onig_sys", "url", "nu_plugin_textview"]
+textview = ["crossterm", "syntect", "url", "nu_plugin_textview"]
 sys = ["nu_plugin_sys"]
 ps = ["nu_plugin_ps"]
 inc = ["semver", "nu_plugin_inc"]
@@ -81,12 +77,12 @@ binaryview = ["nu_plugin_binaryview"]
 fetch = ["nu_plugin_fetch"]
 match = ["nu_plugin_match"]
 post = ["nu_plugin_post"]
-sum = ["nu_plugin_sum"]
 trace = ["nu-parser/trace"]
 tree = ["nu_plugin_tree"]
 
 clipboard-cli = ["nu-cli/clipboard-cli"]
 starship-prompt = ["nu-cli/starship-prompt"]
+trash-support = ["nu-cli/trash-support"]
 
 [[bin]]
 name = "fail"
@@ -167,11 +163,6 @@ name = "nu_plugin_stable_post"
 path = "src/plugins/nu_plugin_stable_post.rs"
 required-features = ["post"]
 
-[[bin]]
-name = "nu_plugin_stable_sum"
-path = "src/plugins/nu_plugin_stable_sum.rs"
-required-features = ["sum"]
-
 [[bin]]
 name = "nu_plugin_stable_tree"
 path = "src/plugins/nu_plugin_stable_tree.rs"

README.md

@@ -13,15 +13,22 @@ A new type of shell.
 
 # Status
 
-This project has reached a minimum-viable product level of quality. While contributors dogfood it as their daily driver, it may be unstable for some commands. Future releases will work to fill out missing features and improve stability. Its design is also subject to change as it matures.
+This project has reached a minimum-viable product level of quality.
+While contributors dogfood it as their daily driver, it may be unstable for some commands.
+Future releases will work to fill out missing features and improve stability.
+Its design is also subject to change as it matures.
 
-Nu comes with a set of built-in commands (listed below). If a command is unknown, the command will shell-out and execute it (using cmd on Windows or bash on Linux and macOS), correctly passing through stdin, stdout, and stderr, so things like your daily git workflows and even `vim` will work just fine.
+Nu comes with a set of built-in commands (listed below).
+If a command is unknown, the command will shell-out and execute it (using cmd on Windows or bash on Linux and macOS), correctly passing through stdin, stdout, and stderr, so things like your daily git workflows and even `vim` will work just fine.
 
 # Learning more
 
-There are a few good resources to learn about Nu. There is a [book](https://www.nushell.sh/book/) about Nu that is currently in progress. The book focuses on using Nu and its core concepts.
+There are a few good resources to learn about Nu.
+There is a [book](https://www.nushell.sh/book/) about Nu that is currently in progress.
+The book focuses on using Nu and its core concepts.
 
-If you're a developer who would like to contribute to Nu, we're also working on a [book for developers](https://www.nushell.sh/contributor-book/) to help you get started. There are also [good first issues](https://github.com/nushell/nushell/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to help you dive in.
+If you're a developer who would like to contribute to Nu, we're also working on a [book for developers](https://www.nushell.sh/contributor-book/) to help you get started.
+There are also [good first issues](https://github.com/nushell/nushell/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to help you dive in.
 
 We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.
 
@@ -63,6 +70,16 @@ cargo build --workspace --features=stable
 
 ## Docker
 
+### Quickstart
+
+Want to try Nu right away? Execute the following to get started.
+
+```bash
+docker run -it quay.io/nushell/nu:latest
+```
+
+### Guide
+
 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:
 
@@ -107,11 +124,18 @@ The second container is a bit smaller if the size is important to you.
 
 # Philosophy
 
-Nu draws inspiration from projects like PowerShell, functional programming languages, and modern CLI tools. Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure. For example, when you list the contents of a directory, what you get back is a table of rows, where each row represents an item in that directory. These values can be piped through a series of steps, in a series of commands called a 'pipeline'.
+Nu draws inspiration from projects like PowerShell, functional programming languages, and modern CLI tools.
+Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure.
+For example, when you list the contents of a directory, what you get back is a table of rows, where each row represents an item in that directory.
+These values can be piped through a series of steps, in a series of commands called a 'pipeline'.
 
 ## Pipelines
 
-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. 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:
+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.
+Additionally, commands can output structured data (you can think of this as a third kind of stream).
+Commands that work in the pipeline fit into one of three categories:
 
 * Commands that produce a stream (eg, `ls`)
 * Commands that filter a stream (eg, `where type == "Directory"`)
@@ -135,13 +159,15 @@ Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing lef
 ────┴───────────┴───────────┴──────────┴────────┴──────────────┴────────────────
 ```
 
-Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed. We could have also written the above:
+Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed.
+We could have also written the above:
 
 ```
 /home/jonathan/Source/nushell(master)> ls | where type == Directory
 ```
 
-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.
+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.
 
 ```text
 /home/jonathan/Source/nushell(master)> ps | where cpu > 0
@@ -157,7 +183,8 @@ Being able to use the same commands and compose them differently is an important
 
 ## Opening files
 
-Nu can load file and URL contents as raw text or as structured data (if it recognizes the format). For example, you can load a .toml file as structured data and explore it:
+Nu can load file and URL contents as raw text or as structured data (if it recognizes the format).
+For example, you can load a .toml file as structured data and explore it:
 
 ```
 /home/jonathan/Source/nushell(master)> open Cargo.toml
@@ -210,19 +237,26 @@ 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 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.
 
-To do so, use the `enter` command, which will allow you 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.
+To do so, use the `enter` command, which will allow you 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.
 
 Finally, to get a list of all the current shells, you can use the `shells` command.
 
 ## Plugins
 
-Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use. This allows you to extend nu for your needs.
+Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use.
+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. 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.
+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.
+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.
 
 # Goals
 
@@ -240,9 +274,9 @@ Nu adheres closely to a set of goals that make up its design philosophy. As feat
 
 # Commands
 
-You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/documentation.html#quick-command-references). 
+You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/documentation.html#quick-command-references).
 
 # License
 
-The project is made available under the MIT license. See "LICENSE" for more information.
+The project is made available under the MIT license. See the `LICENSE` file for more information.
 

crates/nu-build/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nu-build"
-version = "0.11.0"
-authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
+version = "0.13.0"
+authors = ["The Nu Project Contributors"]
 edition = "2018"
 description = "Core build system for nushell"
 license = "MIT"
@@ -10,7 +10,7 @@ license = "MIT"
 doctest = false
 
 [dependencies]
-serde = { version = "1.0.103", features = ["derive"] }
+serde = { version = "1.0.106", features = ["derive"] }
 lazy_static = "1.4.0"
-serde_json = "1.0.44"
-toml = "0.5.5"
+serde_json = "1.0.51"
+toml = "0.5.6"

crates/nu-cli/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nu-cli"
-version = "0.11.0"
-authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>", "Andrés N. Robalino <andres@androbtech.com>"]
+version = "0.13.0"
+authors = ["The Nu Project Contributors"]
 description = "CLI for nushell"
 edition = "2018"
 license = "MIT"
@@ -10,21 +10,20 @@ license = "MIT"
 doctest = false
 
 [dependencies]
-nu-source = { version = "0.11.0", path = "../nu-source" }
-nu-plugin = { version = "0.11.0", path = "../nu-plugin" }
-nu-protocol = { version = "0.11.0", path = "../nu-protocol" }
-nu-errors = { version = "0.11.0", path = "../nu-errors" }
-nu-parser = { version = "0.11.0", path = "../nu-parser" }
-nu-value-ext = { version = "0.11.0", path = "../nu-value-ext" }
-nu-macros = { version = "0.11.0", path = "../nu-macros" }
-nu-test-support = { version = "0.11.0", path = "../nu-test-support" }
+nu-source = { version = "0.13.0", path = "../nu-source" }
+nu-plugin = { version = "0.13.0", path = "../nu-plugin" }
+nu-protocol = { version = "0.13.0", path = "../nu-protocol" }
+nu-errors = { version = "0.13.0", path = "../nu-errors" }
+nu-parser = { version = "0.13.0", path = "../nu-parser" }
+nu-value-ext = { version = "0.13.0", path = "../nu-value-ext" }
+nu-test-support = { version = "0.13.0", path = "../nu-test-support" }
 
 ansi_term = "0.12.1"
 app_dirs = "1.2.1"
 async-stream = "0.2"
-base64 = "0.11"
+base64 = "0.12.0"
 bigdecimal = { version = "0.1.0", features = ["serde"] }
-bson = { version = "0.14.0", features = ["decimal128"] }
+bson = { version = "0.14.1", features = ["decimal128"] }
 byte-unit = "3.0.3"
 bytes = "0.5.4"
 calamine = "0.16"
@@ -36,24 +35,23 @@ ctrlc = "3.1.4"
 derive-new = "0.5.8"
 dirs = "2.0.2"
 dunce = "1.0.0"
-filesize = "0.1.0"
+filesize = "0.2.0"
 futures = { version = "0.3", features = ["compat", "io-compat"] }
 futures-util = "0.3.4"
 futures_codec = "0.4"
 getset = "0.1.0"
-git2 = { version = "0.11.0", default_features = false }
+git2 = { version = "0.13.1", default_features = false }
 glob = "0.3.0"
 hex = "0.4"
-ichwh = "0.3"
+htmlescape = "0.3.1"
+ical = "0.6.*"
+ichwh = "0.3.4"
 indexmap = { version = "1.3.2", features = ["serde-1"] }
 itertools = "0.9.0"
 language-reporting = "0.4.0"
 log = "0.4.8"
 meval = "0.2"
 natural = "0.5.0"
-nom = "5.0.1"
-nom-tracable = "0.4.1"
-nom_locate = "1.0.0"
 num-bigint = { version = "0.2.6", features = ["serde"] }
 num-traits = "0.2.11"
 parking_lot = "0.10.0"
@@ -65,13 +63,13 @@ ptree = {version = "0.2" }
 query_interface = "0.3.5"
 rand = "0.7"
 regex = "1"
-roxmltree = "0.9.1"
-rustyline = "6.0.0"
-serde = { version = "1.0.104", features = ["derive"] }
+roxmltree = "0.10.1"
+rustyline = "6.1.1"
+serde = { version = "1.0.106", features = ["derive"] }
 serde-hjson = "0.9.1"
 serde_bytes = "0.11.3"
 serde_ini = "0.2.0"
-serde_json = "1.0.48"
+serde_json = "1.0.51"
 serde_urlencoded = "0.6.1"
 serde_yaml = "0.8"
 shellexpand = "2.0.0"
@@ -81,29 +79,30 @@ term = "0.5.2"
 termcolor = "1.1.0"
 textwrap = {version = "0.11.0", features = ["term_size"]}
 toml = "0.5.6"
-trash = "1.0.0"
 typetag = "0.1.4"
 umask = "0.1"
 unicode-xid = "0.2.0"
-which = "3.1.1"
 
+trash = { version = "1.0.0", optional = true }
 clipboard = { version = "0.5", optional = true }
-starship = { version = "0.37.0", optional = true }
+starship = { version = "0.39.0", optional = true }
 
 [target.'cfg(unix)'.dependencies]
-users = "0.9"
+users = "0.10.0"
 
 [dependencies.rusqlite]
-version = "0.21.0"
+version = "0.22.0"
 features = ["bundled", "blob"]
 
-[dev-dependencies]
-pretty_assertions = "0.6.1"
-
 [build-dependencies]
-nu-build = { version = "0.11.0", path = "../nu-build" }
+nu-build = { version = "0.13.0", path = "../nu-build" }
+
+[dev-dependencies]
+quickcheck = "0.9"
+quickcheck_macros = "0.9"
 
 [features]
 stable = []
 starship-prompt = ["starship"]
 clipboard-cli = ["clipboard"]
+trash-support = ["trash"]

crates/nu-cli/src/cli.rs

@@ -1,5 +1,5 @@
+use crate::commands::classified::block::run_block;
 use crate::commands::classified::external::{MaybeTextCodec, StringOrBinary};
-use crate::commands::classified::pipeline::run_pipeline;
 use crate::commands::plugin::JsonRpc;
 use crate::commands::plugin::{PluginCommand, PluginSink};
 use crate::commands::whole_stream_command;
@@ -10,10 +10,10 @@ use crate::prelude::*;
 use futures_codec::FramedRead;
 
 use nu_errors::ShellError;
-use nu_parser::{ClassifiedPipeline, PipelineShape, SpannedToken, TokensIterator};
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use nu_protocol::hir::{ClassifiedCommand, Expression, InternalCommand, Literal, NamedArguments};
+use nu_protocol::{Primitive, ReturnSuccess, Scope, Signature, UntaggedValue, Value};
 
-use log::{debug, log_enabled, trace};
+use log::{debug, trace};
 use rustyline::error::ReadlineError;
 use rustyline::{
     self, config::Configurer, config::EditMode, At, Cmd, ColorMode, CompletionType, Config, Editor,
@@ -258,6 +258,7 @@ pub fn create_default_context(
             whole_stream_command(What),
             whole_stream_command(Which),
             whole_stream_command(Debug),
+            per_item_command(Alias),
             // Statistics
             whole_stream_command(Size),
             whole_stream_command(Count),
@@ -304,18 +305,23 @@ pub fn create_default_context(
             whole_stream_command(Range),
             whole_stream_command(Rename),
             whole_stream_command(Uniq),
+            per_item_command(Each),
             // Table manipulation
             whole_stream_command(Shuffle),
             whole_stream_command(Wrap),
             whole_stream_command(Pivot),
+            whole_stream_command(Headers),
             // Data processing
             whole_stream_command(Histogram),
+            whole_stream_command(Sum),
             // File format output
             whole_stream_command(ToBSON),
             whole_stream_command(ToCSV),
+            whole_stream_command(ToHTML),
             whole_stream_command(ToJSON),
             whole_stream_command(ToSQLite),
             whole_stream_command(ToDB),
+            whole_stream_command(ToMarkdown),
             whole_stream_command(ToTOML),
             whole_stream_command(ToTSV),
             whole_stream_command(ToURL),
@@ -336,6 +342,10 @@ pub fn create_default_context(
             whole_stream_command(FromXML),
             whole_stream_command(FromYAML),
             whole_stream_command(FromYML),
+            whole_stream_command(FromIcs),
+            whole_stream_command(FromVcf),
+            // "Private" commands (not intended to be accessed directly)
+            whole_stream_command(RunExternalCommand),
         ]);
 
         cfg_if::cfg_if! {
@@ -360,12 +370,66 @@ pub fn create_default_context(
     Ok(context)
 }
 
+pub async fn run_vec_of_pipelines(
+    pipelines: Vec<String>,
+    redirect_stdin: bool,
+) -> Result<(), Box<dyn Error>> {
+    let mut syncer = crate::EnvironmentSyncer::new();
+    let mut context = crate::create_default_context(&mut syncer)?;
+
+    let _ = crate::load_plugins(&mut context);
+
+    let cc = context.ctrl_c.clone();
+
+    ctrlc::set_handler(move || {
+        cc.store(true, Ordering::SeqCst);
+    })
+    .expect("Error setting Ctrl-C handler");
+
+    if context.ctrl_c.load(Ordering::SeqCst) {
+        context.ctrl_c.store(false, Ordering::SeqCst);
+    }
+
+    // before we start up, let's run our startup commands
+    if let Ok(config) = crate::data::config::config(Tag::unknown()) {
+        if let Some(commands) = config.get("startup") {
+            match commands {
+                Value {
+                    value: UntaggedValue::Table(pipelines),
+                    ..
+                } => {
+                    for pipeline in pipelines {
+                        if let Ok(pipeline_string) = pipeline.as_string() {
+                            let _ = run_pipeline_standalone(
+                                pipeline_string,
+                                false,
+                                &mut context,
+                                false,
+                            )
+                            .await;
+                        }
+                    }
+                }
+                _ => {
+                    println!("warning: expected a table of pipeline strings as startup commands");
+                }
+            }
+        }
+    }
+
+    for pipeline in pipelines {
+        run_pipeline_standalone(pipeline, redirect_stdin, &mut context, true).await?;
+    }
+    Ok(())
+}
+
 pub async fn run_pipeline_standalone(
     pipeline: String,
     redirect_stdin: bool,
     context: &mut Context,
+    exit_on_error: bool,
 ) -> Result<(), Box<dyn Error>> {
-    let line = process_line(Ok(pipeline), context, redirect_stdin).await;
+    let line = process_line(Ok(pipeline), context, redirect_stdin, false).await;
 
     match line {
         LineResult::Success(line) => {
@@ -392,7 +456,9 @@ pub async fn run_pipeline_standalone(
             });
 
             context.maybe_print_errors(Text::from(line));
-            std::process::exit(1);
+            if exit_on_error {
+                std::process::exit(1);
+            }
         }
 
         _ => {}
@@ -435,6 +501,34 @@ pub async fn cli() -> Result<(), Box<dyn Error>> {
     })
     .expect("Error setting Ctrl-C handler");
     let mut ctrlcbreak = false;
+
+    // before we start up, let's run our startup commands
+    if let Ok(config) = crate::data::config::config(Tag::unknown()) {
+        if let Some(commands) = config.get("startup") {
+            match commands {
+                Value {
+                    value: UntaggedValue::Table(pipelines),
+                    ..
+                } => {
+                    for pipeline in pipelines {
+                        if let Ok(pipeline_string) = pipeline.as_string() {
+                            let _ = run_pipeline_standalone(
+                                pipeline_string,
+                                false,
+                                &mut context,
+                                false,
+                            )
+                            .await;
+                        }
+                    }
+                }
+                _ => {
+                    println!("warning: expected a table of pipeline strings as startup commands");
+                }
+            }
+        }
+    }
+
     loop {
         if context.ctrl_c.load(Ordering::SeqCst) {
             context.ctrl_c.store(false, Ordering::SeqCst);
@@ -514,7 +608,7 @@ pub async fn cli() -> Result<(), Box<dyn Error>> {
             initial_command = None;
         }
 
-        let line = process_line(readline, &mut context, false).await;
+        let line = process_line(readline, &mut context, false, true).await;
 
         // 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
@@ -597,6 +691,7 @@ async fn process_line(
     readline: Result<String, ReadlineError>,
     ctx: &mut Context,
     redirect_stdin: bool,
+    cli_mode: bool,
 ) -> LineResult {
     match &readline {
         Ok(line) if line.trim() == "" => LineResult::Success(line.clone()),
@@ -604,9 +699,9 @@ async fn process_line(
         Ok(line) => {
             let line = chomp_newline(line);
 
-            let result = match nu_parser::parse(&line) {
+            let result = match nu_parser::lite_parse(&line, 0) {
                 Err(err) => {
-                    return LineResult::Error(line.to_string(), err);
+                    return LineResult::Error(line.to_string(), err.into());
                 }
 
                 Ok(val) => val,
@@ -615,12 +710,100 @@ async fn process_line(
             debug!("=== Parsed ===");
             debug!("{:#?}", result);
 
-            let pipeline = classify_pipeline(&result, ctx, &Text::from(line));
+            let classified_block = nu_parser::classify_block(&result, ctx.registry());
 
-            if let Some(failure) = pipeline.failed {
+            debug!("{:#?}", classified_block);
+            //println!("{:#?}", pipeline);
+
+            if let Some(failure) = classified_block.failed {
                 return LineResult::Error(line.to_string(), failure.into());
             }
 
+            // There's a special case to check before we process the pipeline:
+            // If we're giving a path by itself
+            // ...and it's not a command in the path
+            // ...and it doesn't have any arguments
+            // ...and we're in the CLI
+            // ...then change to this directory
+            if cli_mode
+                && classified_block.block.block.len() == 1
+                && classified_block.block.block[0].list.len() == 1
+            {
+                if let ClassifiedCommand::Internal(InternalCommand {
+                    ref name, ref args, ..
+                }) = classified_block.block.block[0].list[0]
+                {
+                    let internal_name = name;
+                    let name = args
+                        .positional
+                        .as_ref()
+                        .and_then(|potionals| {
+                            potionals.get(0).map(|e| {
+                                if let Expression::Literal(Literal::String(ref s)) = e.expr {
+                                    &s
+                                } else {
+                                    ""
+                                }
+                            })
+                        })
+                        .unwrap_or("");
+
+                    if internal_name == "run_external"
+                        && args
+                            .positional
+                            .as_ref()
+                            .map(|ref v| v.len() == 1)
+                            .unwrap_or(true)
+                        && args
+                            .named
+                            .as_ref()
+                            .map(NamedArguments::is_empty)
+                            .unwrap_or(true)
+                        && dunce::canonicalize(&name).is_ok()
+                        && PathBuf::from(&name).is_dir()
+                        && ichwh::which(&name).await.unwrap_or(None).is_none()
+                    {
+                        // Here we work differently if we're in Windows because of the expected Windows behavior
+                        #[cfg(windows)]
+                        {
+                            if name.ends_with(':') {
+                                // This looks like a drive shortcut. We need to a) switch drives and b) go back to the previous directory we were viewing on that drive
+                                // But first, we need to save where we are now
+                                let current_path = ctx.shell_manager.path();
+
+                                let split_path: Vec<_> = current_path.split(':').collect();
+                                if split_path.len() > 1 {
+                                    ctx.windows_drives_previous_cwd
+                                        .lock()
+                                        .insert(split_path[0].to_string(), current_path);
+                                }
+
+                                let name = name.to_uppercase();
+                                let new_drive: Vec<_> = name.split(':').collect();
+
+                                if let Some(val) =
+                                    ctx.windows_drives_previous_cwd.lock().get(new_drive[0])
+                                {
+                                    ctx.shell_manager.set_path(val.to_string());
+                                    return LineResult::Success(line.to_string());
+                                } else {
+                                    ctx.shell_manager.set_path(name.to_string());
+                                    return LineResult::Success(line.to_string());
+                                }
+                            } else {
+                                ctx.shell_manager.set_path(name.to_string());
+                                return LineResult::Success(line.to_string());
+                            }
+                        }
+                        #[cfg(not(windows))]
+                        {
+                            ctx.shell_manager.set_path(name.to_string());
+                            return LineResult::Success(line.to_string());
+                        }
+                    }
+                }
+            }
+
             let input_stream = if redirect_stdin {
                 let file = futures::io::AllowStdIo::new(std::io::stdin());
                 let stream = FramedRead::new(file, MaybeTextCodec).map(|line| {
@@ -641,13 +824,13 @@ async fn process_line(
                         panic!("Internal error: could not read lines of text from stdin")
                     }
                 });
-                Some(stream.to_input_stream())
+                stream.to_input_stream()
             } else {
-                None
+                InputStream::empty()
             };
 
-            match run_pipeline(pipeline, ctx, input_stream, line).await {
-                Ok(Some(input)) => {
+            match run_block(&classified_block.block, ctx, input_stream, &Scope::empty()).await {
+                Ok(input) => {
                     // Running a pipeline gives us back a stream that we can then
                     // work through. At the top level, we just want to pull on the
                     // values to compute them.
@@ -658,9 +841,8 @@ async fn process_line(
                         shell_manager: ctx.shell_manager.clone(),
                         host: ctx.host.clone(),
                         ctrl_c: ctx.ctrl_c.clone(),
-                        commands: ctx.registry.clone(),
+                        registry: ctx.registry.clone(),
                         name: Tag::unknown(),
-                        source: Text::from(String::new()),
                     };
 
                     if let Ok(mut output_stream) = crate::commands::autoview::autoview(context) {
@@ -675,16 +857,14 @@ async fn process_line(
                                         break;
                                     }
                                 }
-                                _ => {
-                                    break;
-                                }
+                                Ok(None) => break,
+                                Err(e) => return LineResult::Error(line.to_string(), e),
                             }
                         }
                     }
 
                     LineResult::Success(line.to_string())
                 }
-                Ok(None) => LineResult::Success(line.to_string()),
                 Err(err) => LineResult::Error(line.to_string(), err),
             }
         }
@@ -697,39 +877,32 @@ async fn process_line(
     }
 }
 
-pub fn classify_pipeline(
-    pipeline: &SpannedToken,
-    context: &Context,
-    source: &Text,
-) -> ClassifiedPipeline {
-    let pipeline_list = vec![pipeline.clone()];
-    let expand_context = context.expand_context(source);
-    let mut iterator = TokensIterator::new(&pipeline_list, expand_context, pipeline.span());
-
-    let result = iterator.expand_infallible(PipelineShape);
-
-    if log_enabled!(target: "nu::expand_syntax", log::Level::Debug) {
-        outln!("");
-        let _ = ptree::print_tree(&iterator.expand_tracer().print(source.clone()));
-        outln!("");
-    }
-
-    result
-}
-
 pub fn print_err(err: ShellError, host: &dyn Host, source: &Text) {
-    let diag = err.into_diagnostic();
-
-    let writer = host.err_termcolor();
-    let mut source = source.to_string();
-    source.push_str(" ");
-    let files = nu_parser::Files::new(source);
-    let _ = std::panic::catch_unwind(move || {
-        let _ = language_reporting::emit(
-            &mut writer.lock(),
-            &files,
-            &diag,
-            &language_reporting::DefaultConfig,
-        );
-    });
+    if let Some(diag) = err.into_diagnostic() {
+        let writer = host.err_termcolor();
+        let mut source = source.to_string();
+        source.push_str(" ");
+        let files = nu_parser::Files::new(source);
+        let _ = std::panic::catch_unwind(move || {
+            let _ = language_reporting::emit(
+                &mut writer.lock(),
+                &files,
+                &diag,
+                &language_reporting::DefaultConfig,
+            );
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[quickcheck]
+    fn quickcheck_parse(data: String) -> bool {
+        if let Ok(lite_block) = nu_parser::lite_parse(&data, 0) {
+            let context = crate::context::Context::basic().unwrap();
+            let _ = nu_parser::classify_block(&lite_block, context.registry());
+        }
+        true
+    }
 }

crates/nu-cli/src/commands.rs

@@ -4,6 +4,7 @@ pub(crate) mod macros;
 mod from_delimited_data;
 mod to_delimited_data;
 
+pub(crate) mod alias;
 pub(crate) mod append;
 pub(crate) mod args;
 pub(crate) mod autoview;
@@ -20,6 +21,7 @@ pub(crate) mod date;
 pub(crate) mod debug;
 pub(crate) mod default;
 pub(crate) mod du;
+pub(crate) mod each;
 pub(crate) mod echo;
 pub(crate) mod edit;
 pub(crate) mod enter;
@@ -30,6 +32,7 @@ pub(crate) mod first;
 pub(crate) mod format;
 pub(crate) mod from_bson;
 pub(crate) mod from_csv;
+pub(crate) mod from_ics;
 pub(crate) mod from_ini;
 pub(crate) mod from_json;
 pub(crate) mod from_ods;
@@ -38,11 +41,13 @@ 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 headers;
 pub(crate) mod help;
 pub(crate) mod histogram;
 pub(crate) mod history;
@@ -71,6 +76,8 @@ pub(crate) mod reject;
 pub(crate) mod rename;
 pub(crate) mod reverse;
 pub(crate) mod rm;
+pub(crate) mod run_alias;
+pub(crate) mod run_external;
 pub(crate) mod save;
 pub(crate) mod shells;
 pub(crate) mod shuffle;
@@ -81,13 +88,16 @@ pub(crate) mod sort_by;
 pub(crate) mod split_by;
 pub(crate) mod split_column;
 pub(crate) mod split_row;
+pub(crate) mod sum;
 #[allow(unused)]
 pub(crate) mod t_sort_by;
 pub(crate) mod table;
 pub(crate) mod tags;
 pub(crate) mod to_bson;
 pub(crate) mod to_csv;
+pub(crate) mod to_html;
 pub(crate) mod to_json;
+pub(crate) mod to_md;
 pub(crate) mod to_sqlite;
 pub(crate) mod to_toml;
 pub(crate) mod to_tsv;
@@ -108,6 +118,7 @@ pub(crate) use command::{
     WholeStreamCommand,
 };
 
+pub(crate) use alias::Alias;
 pub(crate) use append::Append;
 pub(crate) use calc::Calc;
 pub(crate) use compact::Compact;
@@ -118,6 +129,7 @@ pub(crate) use date::Date;
 pub(crate) use debug::Debug;
 pub(crate) use default::Default;
 pub(crate) use du::Du;
+pub(crate) use each::Each;
 pub(crate) use echo::Echo;
 pub(crate) use edit::Edit;
 pub(crate) mod kill;
@@ -133,6 +145,7 @@ pub(crate) use first::First;
 pub(crate) use format::Format;
 pub(crate) use from_bson::FromBSON;
 pub(crate) use from_csv::FromCSV;
+pub(crate) use from_ics::FromIcs;
 pub(crate) use from_ini::FromINI;
 pub(crate) use from_json::FromJSON;
 pub(crate) use from_ods::FromODS;
@@ -142,12 +155,14 @@ pub(crate) use from_ssv::FromSSV;
 pub(crate) use from_toml::FromTOML;
 pub(crate) use from_tsv::FromTSV;
 pub(crate) use from_url::FromURL;
+pub(crate) use from_vcf::FromVcf;
 pub(crate) use from_xlsx::FromXLSX;
 pub(crate) use from_xml::FromXML;
 pub(crate) use from_yaml::FromYAML;
 pub(crate) use from_yaml::FromYML;
 pub(crate) use get::Get;
 pub(crate) use group_by::GroupBy;
+pub(crate) use headers::Headers;
 pub(crate) use help::Help;
 pub(crate) use histogram::Histogram;
 pub(crate) use history::History;
@@ -175,6 +190,7 @@ pub(crate) use reject::Reject;
 pub(crate) use rename::Rename;
 pub(crate) use reverse::Reverse;
 pub(crate) use rm::Remove;
+pub(crate) use run_external::RunExternalCommand;
 pub(crate) use save::Save;
 pub(crate) use shells::Shells;
 pub(crate) use shuffle::Shuffle;
@@ -185,13 +201,16 @@ pub(crate) use sort_by::SortBy;
 pub(crate) use split_by::SplitBy;
 pub(crate) use split_column::SplitColumn;
 pub(crate) use split_row::SplitRow;
+pub(crate) use sum::Sum;
 #[allow(unused_imports)]
 pub(crate) use t_sort_by::TSortBy;
 pub(crate) use table::Table;
 pub(crate) use tags::Tags;
 pub(crate) use to_bson::ToBSON;
 pub(crate) use to_csv::ToCSV;
+pub(crate) use to_html::ToHTML;
 pub(crate) use to_json::ToJSON;
+pub(crate) use to_md::ToMarkdown;
 pub(crate) use to_sqlite::ToDB;
 pub(crate) use to_sqlite::ToSQLite;
 pub(crate) use to_toml::ToTOML;

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

@@ -0,0 +1,65 @@
+use crate::commands::PerItemCommand;
+use crate::context::CommandRegistry;
+use crate::prelude::*;
+use nu_errors::ShellError;
+use nu_protocol::{
+    CallInfo, CommandAction, Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value,
+};
+
+pub struct Alias;
+
+impl PerItemCommand for Alias {
+    fn name(&self) -> &str {
+        "alias"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("alias")
+            .required("name", SyntaxShape::String, "the name of the alias")
+            .required("args", SyntaxShape::Table, "the arguments to the alias")
+            .required("block", SyntaxShape::Block, "the block to run on each row")
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block on each row of the table."
+    }
+
+    fn run(
+        &self,
+        call_info: &CallInfo,
+        _registry: &CommandRegistry,
+        _raw_args: &RawCommandArgs,
+        _input: Value,
+    ) -> Result<OutputStream, ShellError> {
+        let call_info = call_info.clone();
+        let stream = async_stream! {
+            match (call_info.args.expect_nth(0)?, call_info.args.expect_nth(1)?, call_info.args.expect_nth(2)?) {
+                (Value {value: UntaggedValue::Primitive(Primitive::String(name)), .. },
+                Value { value: UntaggedValue::Table(list), .. },
+                Value {
+                    value: UntaggedValue::Block(block),
+                    tag
+                }) => {
+                    let mut args: Vec<String> = vec![];
+                    for item in list.iter() {
+                        if let Ok(string) = item.as_string() {
+                            args.push(format!("${}", string));
+                        } else {
+                            yield Err(ShellError::labeled_error("Expected a string", "expected a string", item.tag()));
+                        }
+                    }
+                    yield ReturnSuccess::action(CommandAction::AddAlias(name.to_string(), args, block.clone()))
+                }
+                _ => {
+                    yield Err(ShellError::labeled_error(
+                        "Expected `name [args] {block}",
+                        "needs a name, args, and a block",
+                        call_info.name_tag,
+                    ))
+                }
+            };
+        };
+
+        Ok(stream.to_output_stream())
+    }
+}

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

@@ -45,5 +45,5 @@ fn append(
     after.push_back(row);
     let after = futures::stream::iter(after);
 
-    Ok(OutputStream::from_input(input.values.chain(after)))
+    Ok(OutputStream::from_input(input.chain(after)))
 }

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

@@ -2,8 +2,8 @@ use crate::commands::UnevaluatedCallInfo;
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_parser::{hir, hir::Expression, hir::Literal, hir::SpannedExpression};
-use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use nu_protocol::{hir, hir::Expression, hir::Literal, hir::SpannedExpression};
+use nu_protocol::{Primitive, ReturnSuccess, Scope, Signature, UntaggedValue, Value};
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
 
@@ -29,10 +29,9 @@ impl WholeStreamCommand for Autoview {
     ) -> Result<OutputStream, ShellError> {
         autoview(RunnableContext {
             input: args.input,
-            commands: registry.clone(),
+            registry: registry.clone(),
             shell_manager: args.shell_manager,
             host: args.host,
-            source: args.call_info.source,
             ctrl_c: args.ctrl_c,
             name: args.call_info.name_tag,
         })
@@ -42,9 +41,8 @@ impl WholeStreamCommand for Autoview {
 pub struct RunnableContextWithoutInput {
     pub shell_manager: ShellManager,
     pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
-    pub source: Text,
     pub ctrl_c: Arc<AtomicBool>,
-    pub commands: CommandRegistry,
+    pub registry: CommandRegistry,
     pub name: Tag,
 }
 
@@ -53,9 +51,8 @@ impl RunnableContextWithoutInput {
         let new_context = RunnableContextWithoutInput {
             shell_manager: context.shell_manager,
             host: context.host,
-            source: context.source,
             ctrl_c: context.ctrl_c,
-            commands: context.commands,
+            registry: context.registry,
             name: context.name,
         };
         (context.input, new_context)
@@ -95,7 +92,7 @@ pub fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
 
                         if let Some(table) = table {
                             let command_args = create_default_command_args(&context).with_input(stream);
-                            let result = table.run(command_args, &context.commands);
+                            let result = table.run(command_args, &context.registry);
                             result.collect::<Vec<_>>().await;
                         }
                     }
@@ -109,7 +106,7 @@ pub fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
                                     let mut stream = VecDeque::new();
                                     stream.push_back(UntaggedValue::string(s).into_value(Tag { anchor, span }));
                                     let command_args = create_default_command_args(&context).with_input(stream);
-                                    let result = text.run(command_args, &context.commands);
+                                    let result = text.run(command_args, &context.registry);
                                     result.collect::<Vec<_>>().await;
                                 } else {
                                     out!("{}", s);
@@ -129,7 +126,7 @@ pub fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
                                     let mut stream = VecDeque::new();
                                     stream.push_back(UntaggedValue::string(s).into_value(Tag { anchor, span }));
                                     let command_args = create_default_command_args(&context).with_input(stream);
-                                    let result = text.run(command_args, &context.commands);
+                                    let result = text.run(command_args, &context.registry);
                                     result.collect::<Vec<_>>().await;
                                 } else {
                                     out!("{}\n", s);
@@ -159,13 +156,19 @@ pub fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
                             } => {
                                 out!("{}", n);
                             }
+                            Value {
+                                value: UntaggedValue::Primitive(Primitive::Boolean(b)),
+                                ..
+                            } => {
+                                out!("{}", b);
+                            }
 
                             Value { value: UntaggedValue::Primitive(Primitive::Binary(ref b)), .. } => {
                                 if let Some(binary) = binary {
                                     let mut stream = VecDeque::new();
                                     stream.push_back(x);
                                     let command_args = create_default_command_args(&context).with_input(stream);
-                                    let result = binary.run(command_args, &context.commands);
+                                    let result = binary.run(command_args, &context.registry);
                                     result.collect::<Vec<_>>().await;
                                 } else {
                                     use pretty_hex::*;
@@ -176,12 +179,82 @@ pub fn autoview(context: RunnableContext) -> Result<OutputStream, ShellError> {
                             Value { value: UntaggedValue::Error(e), .. } => {
                                 yield Err(e);
                             }
+
+                            Value { value: UntaggedValue::Row(row), ..} => {
+                                use prettytable::format::{FormatBuilder, LinePosition, LineSeparator};
+                                use prettytable::{color, Attr, Cell, Row, Table};
+                                use crate::data::value::{format_leaf, style_leaf};
+                                use textwrap::fill;
+
+                                let termwidth = std::cmp::max(textwrap::termwidth(), 20);
+
+                                enum TableMode {
+                                    Light,
+                                    Normal,
+                                }
+
+                                let mut table = Table::new();
+                                let table_mode = crate::data::config::config(Tag::unknown());
+
+                                let table_mode = if let Some(s) = table_mode?.get("table_mode") {
+                                    match s.as_string() {
+                                        Ok(typ) if typ == "light" => TableMode::Light,
+                                        _ => TableMode::Normal,
+                                    }
+                                } else {
+                                    TableMode::Normal
+                                };
+
+                                match table_mode {
+                                    TableMode::Light => {
+                                        table.set_format(
+                                            FormatBuilder::new()
+                                                .separator(LinePosition::Title, LineSeparator::new('─', '─', ' ', ' '))
+                                                .padding(1, 1)
+                                                .build(),
+                                        );
+                                    }
+                                    _ => {
+                                        table.set_format(
+                                            FormatBuilder::new()
+                                                .column_separator('│')
+                                                .separator(LinePosition::Top, LineSeparator::new('─', '┬', ' ', ' '))
+                                                .separator(LinePosition::Title, LineSeparator::new('─', '┼', ' ', ' '))
+                                                .separator(LinePosition::Bottom, LineSeparator::new('─', '┴', ' ', ' '))
+                                                .padding(1, 1)
+                                                .build(),
+                                        );
+                                    }
+                                }
+
+                                let mut max_key_len = 0;
+                                for (key, _) in row.entries.iter() {
+                                    max_key_len = std::cmp::max(max_key_len, key.chars().count());
+                                }
+
+                                if max_key_len > (termwidth/2 - 1) {
+                                    max_key_len = termwidth/2 - 1;
+                                }
+
+                                let max_val_len = termwidth - max_key_len - 5;
+
+                                for (key, value) in row.entries.iter() {
+                                    table.add_row(Row::new(vec![Cell::new(&fill(&key, max_key_len)).with_style(Attr::ForegroundColor(color::GREEN)).with_style(Attr::Bold),
+                                        Cell::new(&fill(&format_leaf(value).plain_string(100_000), max_val_len))]));
+                                }
+
+                                table.printstd();
+
+                                // table.print_term(&mut *context.host.lock().out_terminal().ok_or_else(|| ShellError::untagged_runtime_error("Could not open terminal for output"))?)
+                                //     .map_err(|_| ShellError::untagged_runtime_error("Internal error: could not print to terminal (for unix systems check to make sure TERM is set)"))?;
+                            }
+
                             Value { value: ref item, .. } => {
                                 if let Some(table) = table {
                                     let mut stream = VecDeque::new();
                                     stream.push_back(x);
                                     let command_args = create_default_command_args(&context).with_input(stream);
-                                    let result = table.run(command_args, &context.commands);
+                                    let result = table.run(command_args, &context.registry);
                                     result.collect::<Vec<_>>().await;
                                 } else {
                                     out!("{:?}", item);
@@ -212,15 +285,16 @@ fn create_default_command_args(context: &RunnableContextWithoutInput) -> RawComm
         call_info: UnevaluatedCallInfo {
             args: hir::Call {
                 head: Box::new(SpannedExpression::new(
-                    Expression::Literal(Literal::String(span)),
+                    Expression::Literal(Literal::String(String::new())),
                     span,
                 )),
                 positional: None,
                 named: None,
                 span,
+                is_last: true,
             },
-            source: context.source.clone(),
             name_tag: context.name.clone(),
+            scope: Scope::empty(),
         },
     }
 }

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

@@ -1,7 +1,6 @@
 use crate::commands::WholeStreamCommand;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_macros::signature;
 use nu_protocol::{Signature, SyntaxShape};
 
 pub struct Cd;
@@ -12,17 +11,11 @@ impl WholeStreamCommand for Cd {
     }
 
     fn signature(&self) -> Signature {
-        signature! {
-            def cd {
-                "the directory to change to"
-                directory(optional Path) - "the directory to change to"
-            }
-        }
-        // Signature::build("cd").optional(
-        //     "directory",
-        //     SyntaxShape::Path,
-        //     "the directory to change to",
-        // )
+        Signature::build("cd").optional(
+            "directory",
+            SyntaxShape::Path,
+            "the directory to change to",
+        )
     }
 
     fn usage(&self) -> &str {

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

@@ -0,0 +1,96 @@
+use crate::commands::classified::expr::run_expression_block;
+//use crate::commands::classified::external::run_external_command;
+use crate::commands::classified::internal::run_internal_command;
+use crate::context::Context;
+use crate::prelude::*;
+use crate::stream::InputStream;
+use futures::stream::TryStreamExt;
+use nu_errors::ShellError;
+use nu_protocol::hir::{Block, ClassifiedCommand, Commands};
+use nu_protocol::{ReturnSuccess, Scope, UntaggedValue, Value};
+use std::sync::atomic::Ordering;
+
+pub(crate) async fn run_block(
+    block: &Block,
+    ctx: &mut Context,
+    mut input: InputStream,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    let mut output: Result<InputStream, ShellError> = Ok(InputStream::empty());
+    for pipeline in &block.block {
+        match output {
+            Ok(inp) if inp.is_empty() => {}
+            Ok(inp) => {
+                let mut output_stream = inp.to_output_stream();
+
+                loop {
+                    match output_stream.try_next().await {
+                        Ok(Some(ReturnSuccess::Value(Value {
+                            value: UntaggedValue::Error(e),
+                            ..
+                        }))) => return Err(e),
+                        Ok(Some(_item)) => {
+                            if let Some(err) = ctx.get_errors().get(0) {
+                                ctx.clear_errors();
+                                return Err(err.clone());
+                            }
+                            if ctx.ctrl_c.load(Ordering::SeqCst) {
+                                break;
+                            }
+                        }
+                        Ok(None) => {
+                            if let Some(err) = ctx.get_errors().get(0) {
+                                ctx.clear_errors();
+                                return Err(err.clone());
+                            }
+                            break;
+                        }
+                        Err(e) => return Err(e),
+                    }
+                }
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
+        output = run_pipeline(pipeline, ctx, input, scope).await;
+
+        input = InputStream::empty();
+    }
+
+    output
+}
+
+async fn run_pipeline(
+    commands: &Commands,
+    ctx: &mut Context,
+    mut input: InputStream,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    let mut iter = commands.list.clone().into_iter().peekable();
+
+    loop {
+        let item: Option<ClassifiedCommand> = iter.next();
+        let next: Option<&ClassifiedCommand> = iter.peek();
+
+        input = match (item, next) {
+            (Some(ClassifiedCommand::Dynamic(_)), _) | (_, Some(ClassifiedCommand::Dynamic(_))) => {
+                return Err(ShellError::unimplemented("Dynamic commands"))
+            }
+
+            (Some(ClassifiedCommand::Expr(expr)), _) => {
+                run_expression_block(*expr, ctx, input, scope)?
+            }
+            (Some(ClassifiedCommand::Error(err)), _) => return Err(err.into()),
+            (_, Some(ClassifiedCommand::Error(err))) => return Err(err.clone().into()),
+
+            (Some(ClassifiedCommand::Internal(left)), _) => {
+                run_internal_command(left, ctx, input, scope)?
+            }
+
+            (None, _) => break,
+        };
+    }
+
+    Ok(input)
+}

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

@@ -1,7 +1,7 @@
 use derive_new::new;
-use nu_parser::hir;
+use nu_protocol::hir;
 
-#[derive(new, Debug, Eq, PartialEq)]
+#[derive(new, Debug)]
 pub(crate) struct Command {
     pub(crate) args: hir::Call,
 }

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

@@ -0,0 +1,29 @@
+use crate::evaluate::evaluate_baseline_expr;
+use crate::prelude::*;
+
+use log::{log_enabled, trace};
+
+use nu_errors::ShellError;
+use nu_protocol::hir::SpannedExpression;
+use nu_protocol::Scope;
+
+pub(crate) fn run_expression_block(
+    expr: SpannedExpression,
+    context: &mut Context,
+    input: InputStream,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
+    if log_enabled!(log::Level::Trace) {
+        trace!(target: "nu::run::expr", "->");
+        trace!(target: "nu::run::expr", "{:?}", expr);
+    }
+
+    let scope = scope.clone();
+    let registry = context.registry().clone();
+    let stream = input.map(move |row| {
+        let scope = scope.clone().set_it(row);
+        evaluate_baseline_expr(&expr, &registry, &scope)
+    });
+
+    Ok(stream.to_input_stream())
+}

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

@@ -1,20 +1,22 @@
+use crate::evaluate::evaluate_baseline_expr;
 use crate::futures::ThreadedReceiver;
 use crate::prelude::*;
+
+use std::io::Write;
+use std::ops::Deref;
+use std::process::{Command, Stdio};
+use std::sync::mpsc;
+
 use bytes::{BufMut, Bytes, BytesMut};
 use futures::executor::block_on_stream;
 use futures::stream::StreamExt;
 use futures_codec::FramedRead;
 use log::trace;
+
 use nu_errors::ShellError;
-use nu_parser::commands::classified::external::ExternalArg;
-use nu_parser::ExternalCommand;
-use nu_protocol::{ColumnPath, Primitive, ShellTypeName, UntaggedValue, Value};
-use nu_source::{Tag, Tagged};
-use nu_value_ext::as_column_path;
-use std::io::Write;
-use std::ops::Deref;
-use std::process::{Command, Stdio};
-use std::sync::mpsc;
+use nu_protocol::hir::ExternalCommand;
+use nu_protocol::{Primitive, Scope, ShellTypeName, UntaggedValue, Value};
+use nu_source::Tag;
 
 pub enum StringOrBinary {
     String(String),
@@ -80,7 +82,7 @@ impl futures_codec::Decoder for MaybeTextCodec {
     }
 }
 
-pub fn nu_value_to_string(command: &ExternalCommand, from: &Value) -> Result<String, ShellError> {
+pub fn nu_value_to_string(name_tag: &Tag, from: &Value) -> Result<String, ShellError> {
     match &from.value {
         UntaggedValue::Primitive(Primitive::Int(i)) => Ok(i.to_string()),
         UntaggedValue::Primitive(Primitive::String(s))
@@ -89,20 +91,21 @@ pub fn nu_value_to_string(command: &ExternalCommand, from: &Value) -> Result<Str
         unsupported => Err(ShellError::labeled_error(
             format!("needs string data (given: {})", unsupported.type_name()),
             "expected a string",
-            &command.name_tag,
+            name_tag,
         )),
     }
 }
 
-pub(crate) fn run_external_command(
+pub(crate) async fn run_external_command(
     command: ExternalCommand,
     context: &mut Context,
-    input: Option<InputStream>,
+    input: InputStream,
+    scope: &Scope,
     is_last: bool,
-) -> Result<Option<InputStream>, ShellError> {
+) -> Result<InputStream, ShellError> {
     trace!(target: "nu::run::external", "-> {}", command.name);
 
-    if !did_find_command(&command.name) {
+    if !did_find_command(&command.name).await {
         return Err(ShellError::labeled_error(
             "Command not found",
             "command not found",
@@ -110,265 +113,71 @@ pub(crate) fn run_external_command(
         ));
     }
 
-    if command.has_it_argument() || command.has_nu_argument() {
-        run_with_iterator_arg(command, context, input, is_last)
+    if command.has_it_argument() {
+        run_with_iterator_arg(command, context, input, scope, is_last)
     } else {
-        run_with_stdin(command, context, input, is_last)
+        run_with_stdin(command, context, input, scope, is_last)
     }
 }
 
-fn prepare_column_path_for_fetching_it_variable(
-    argument: &ExternalArg,
-) -> Result<Tagged<ColumnPath>, ShellError> {
-    // We have "$it.[contents of interest]"
-    // and start slicing from "$it.[member+]"
-    //                             ^ here.
-    let key = nu_source::Text::from(argument.deref()).slice(4..argument.len());
-
-    to_column_path(&key, &argument.tag)
-}
-
-fn prepare_column_path_for_fetching_nu_variable(
-    argument: &ExternalArg,
-) -> Result<Tagged<ColumnPath>, ShellError> {
-    // We have "$nu.[contents of interest]"
-    // and start slicing from "$nu.[member+]"
-    //                             ^ here.
-    let key = nu_source::Text::from(argument.deref()).slice(4..argument.len());
-
-    to_column_path(&key, &argument.tag)
-}
-
-fn to_column_path(
-    path_members: &str,
-    tag: impl Into<Tag>,
-) -> Result<Tagged<ColumnPath>, ShellError> {
-    let tag = tag.into();
-
-    as_column_path(
-        &UntaggedValue::Table(
-            path_members
-                .split('.')
-                .map(|x| {
-                    let member = match x.parse::<u64>() {
-                        Ok(v) => UntaggedValue::int(v),
-                        Err(_) => UntaggedValue::string(x),
-                    };
-
-                    member.into_value(&tag)
-                })
-                .collect(),
-        )
-        .into_value(&tag),
-    )
-}
-
 fn run_with_iterator_arg(
     command: ExternalCommand,
     context: &mut Context,
-    input: Option<InputStream>,
+    input: InputStream,
+    scope: &Scope,
     is_last: bool,
-) -> Result<Option<InputStream>, ShellError> {
+) -> Result<InputStream, ShellError> {
     let path = context.shell_manager.path();
 
-    let mut inputs: InputStream = if let Some(input) = input {
-        trace_stream!(target: "nu::trace_stream::external::it", "input" = input)
-    } else {
-        InputStream::empty()
-    };
+    let mut inputs: InputStream =
+        trace_stream!(target: "nu::trace_stream::external::it", "input" = input);
+
+    let name_tag = command.name_tag.clone();
+    let scope = scope.clone();
+    let context = context.clone();
 
     let stream = async_stream! {
         while let Some(value) = inputs.next().await {
-            let name = command.name.clone();
-            let name_tag = command.name_tag.clone();
-            let home_dir = dirs::home_dir();
-            let path = &path;
-            let args = command.args.clone();
+            // Evaluate the expressions into values, and from values into strings for each iteration
+            let mut command_args = vec![];
+            let scope = scope.clone().set_it(value);
+            for arg in command.args.iter() {
+                let value = evaluate_baseline_expr(arg, &context.registry, &scope)?;
+                command_args.push(nu_value_to_string(&name_tag, &value)?);
+            }
 
-            let it_replacement = {
-                if command.has_it_argument() {
-                    let empty_arg = ExternalArg {
-                        arg: "".to_string(),
-                        tag: name_tag.clone()
-                    };
+            let process_args = command_args
+            .iter()
+            .map(|arg| {
+                let arg = expand_tilde(arg.deref(), dirs::home_dir);
 
-                    let key = args.iter()
-                        .find(|arg| arg.looks_like_it())
-                        .unwrap_or_else(|| &empty_arg);
-
-                    if args.iter().all(|arg| !arg.is_it()) {
-                        let key = match prepare_column_path_for_fetching_it_variable(&key) {
-                            Ok(keypath) => keypath,
-                            Err(reason) => {
-                                yield Ok(Value {
-                                    value: UntaggedValue::Error(reason),
-                                    tag: name_tag
-                                });
-                                return;
-                            }
-                        };
-
-                        match crate::commands::get::get_column_path(&key, &value) {
-                            Ok(field) => {
-                                match nu_value_to_string(&command, &field) {
-                                    Ok(val) => Some(val),
-                                    Err(reason) => {
-                                        yield Ok(Value {
-                                            value: UntaggedValue::Error(reason),
-                                            tag: name_tag
-                                        });
-                                        return;
-                                    },
-                                }
-                            },
-                            Err(reason) => {
-                                yield Ok(Value {
-                                    value: UntaggedValue::Error(reason),
-                                    tag: name_tag
-                                });
-                                return;
-                            }
-                        }
-                    } else {
-                        match nu_value_to_string(&command, &value) {
-                            Ok(val) => Some(val),
-                            Err(reason) => {
-                                yield Ok(Value {
-                                    value: UntaggedValue::Error(reason),
-                                    tag: name_tag
-                                });
-                                return;
-                            },
-                        }
-                    }
-                } else {
-                    None
-                }
-            };
-
-            let nu_replacement = {
-                if command.has_nu_argument() {
-                    let empty_arg = ExternalArg {
-                        arg: "".to_string(),
-                        tag: name_tag.clone()
-                    };
-
-                    let key = args.iter()
-                        .find(|arg| arg.looks_like_nu())
-                        .unwrap_or_else(|| &empty_arg);
-
-                    let nu_var = match crate::evaluate::variables::nu(&name_tag) {
-                        Ok(variables) => variables,
-                        Err(reason) => {
-                            yield Ok(Value {
-                                value: UntaggedValue::Error(reason),
-                                tag: name_tag
-                            });
-                            return;
-                        }
-                    };
-
-                    if args.iter().all(|arg| !arg.is_nu()) {
-                        let key = match prepare_column_path_for_fetching_nu_variable(&key) {
-                            Ok(keypath) => keypath,
-                            Err(reason) => {
-                                yield Ok(Value {
-                                    value: UntaggedValue::Error(reason),
-                                    tag: name_tag
-                                });
-                                return;
-                            }
-                        };
-
-                        match crate::commands::get::get_column_path(&key, &nu_var) {
-                            Ok(field) => {
-                                match nu_value_to_string(&command, &field) {
-                                    Ok(val) => Some(val),
-                                    Err(reason) => {
-                                        yield Ok(Value {
-                                            value: UntaggedValue::Error(reason),
-                                            tag: name_tag
-                                        });
-                                        return;
-                                    },
-                                }
-                            },
-                            Err(reason) => {
-                                yield Ok(Value {
-                                    value: UntaggedValue::Error(reason),
-                                    tag: name_tag
-                                });
-                                return;
-                            }
-                        }
-                    } else {
-                        match nu_value_to_string(&command, &nu_var) {
-                            Ok(val) => Some(val),
-                            Err(reason) => {
-                                yield Ok(Value {
-                                    value: UntaggedValue::Error(reason),
-                                    tag: name_tag
-                                });
-                                return;
-                            },
-                        }
-                    }
-                } else {
-                    None
-                }
-            };
-
-            let process_args = args.iter().filter_map(|arg| {
-                if arg.chars().all(|c| c.is_whitespace()) {
-                    None
-                } else {
-                    let arg = if arg.looks_like_it() {
-                        if let Some(mut value) = it_replacement.to_owned() {
-                            let mut value = expand_tilde(&value, || home_dir.as_ref()).as_ref().to_string();
-                            #[cfg(not(windows))]
-                            {
-                                value = {
-                                    if argument_contains_whitespace(&value) && !argument_is_quoted(&value) {
-                                        add_quotes(&value)
-                                    } else {
-                                        value
-                                    }
-                                };
-                            }
-                            Some(value)
+                #[cfg(not(windows))]
+                {
+                    if argument_contains_whitespace(&arg) && argument_is_quoted(&arg) {
+                        if let Some(unquoted) = remove_quotes(&arg) {
+                            format!(r#""{}""#, unquoted)
                         } else {
-                            None
-                        }
-                    } else if arg.looks_like_nu() {
-                        if let Some(mut value) = nu_replacement.to_owned() {
-                            #[cfg(not(windows))]
-                            {
-                                value = {
-                                    if argument_contains_whitespace(&value) && !argument_is_quoted(&value) {
-                                        add_quotes(&value)
-                                    } else {
-                                        value
-                                    }
-                                };
-                            }
-                            Some(value)
-                        } else {
-                            None
+                            arg.as_ref().to_string()
                         }
                     } else {
-                        Some(arg.to_string())
-                    };
-
-                    arg
+                        arg.as_ref().to_string()
+                    }
                 }
-            }).collect::<Vec<String>>();
+                #[cfg(windows)]
+                {
+                    if let Some(unquoted) = remove_quotes(&arg) {
+                        unquoted.to_string()
+                    } else {
+                        arg.as_ref().to_string()
+                    }
+                }
+            })
+            .collect::<Vec<String>>();
 
-            match spawn(&command, &path, &process_args[..], None, is_last) {
-                Ok(res) => {
-                    if let Some(mut res) = res {
-                        while let Some(item) = res.next().await {
-                            yield Ok(item)
-                        }
+            match spawn(&command, &path, &process_args[..], InputStream::empty(), is_last) {
+                Ok(mut res) => {
+                    while let Some(item) = res.next().await {
+                        yield Ok(item)
                     }
                 }
                 Err(reason) => {
@@ -382,34 +191,35 @@ fn run_with_iterator_arg(
         }
     };
 
-    Ok(Some(stream.to_input_stream()))
+    Ok(stream.to_input_stream())
 }
 
 fn run_with_stdin(
     command: ExternalCommand,
     context: &mut Context,
-    input: Option<InputStream>,
+    input: InputStream,
+    scope: &Scope,
     is_last: bool,
-) -> Result<Option<InputStream>, ShellError> {
+) -> Result<InputStream, ShellError> {
     let path = context.shell_manager.path();
 
-    let input = input
-        .map(|input| trace_stream!(target: "nu::trace_stream::external::stdin", "input" = input));
+    let input = trace_stream!(target: "nu::trace_stream::external::stdin", "input" = input);
 
-    let process_args = command
-        .args
+    let mut command_args = vec![];
+    for arg in command.args.iter() {
+        let value = evaluate_baseline_expr(arg, &context.registry, scope)?;
+        command_args.push(value.as_string()?);
+    }
+
+    let process_args = command_args
         .iter()
         .map(|arg| {
             let arg = expand_tilde(arg.deref(), dirs::home_dir);
 
             #[cfg(not(windows))]
             {
-                if argument_contains_whitespace(&arg) && argument_is_quoted(&arg) {
-                    if let Some(unquoted) = remove_quotes(&arg) {
-                        format!(r#""{}""#, unquoted)
-                    } else {
-                        arg.as_ref().to_string()
-                    }
+                if argument_contains_whitespace(&arg) && !argument_is_quoted(&arg) {
+                    add_quotes(&arg)
                 } else {
                     arg.as_ref().to_string()
                 }
@@ -432,9 +242,9 @@ fn spawn(
     command: &ExternalCommand,
     path: &str,
     args: &[String],
-    input: Option<InputStream>,
+    input: InputStream,
     is_last: bool,
-) -> Result<Option<InputStream>, ShellError> {
+) -> Result<InputStream, ShellError> {
     let command = command.clone();
 
     let mut process = {
@@ -444,6 +254,8 @@ fn spawn(
             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
@@ -469,7 +281,7 @@ fn spawn(
     }
 
     // open since we have some contents for stdin
-    if input.is_some() {
+    if !input.is_empty() {
         process.stdin(Stdio::piped());
         trace!(target: "nu::run::external", "set up stdin pipe");
     }
@@ -488,7 +300,7 @@ fn spawn(
         let stdout_name_tag = command.name_tag;
 
         std::thread::spawn(move || {
-            if let Some(input) = input {
+            if !input.is_empty() {
                 let mut stdin_write = stdin
                     .take()
                     .expect("Internal error: could not get stdin pipe for external command");
@@ -610,7 +422,15 @@ fn spawn(
 
             // We can give an error when we see a non-zero exit code, but this is different
             // than what other shells will do.
-            if child.wait().is_err() {
+            let external_failed = match child.wait() {
+                Err(_) => true,
+                Ok(exit_status) => match exit_status.code() {
+                    Some(e) if e != 0 => true,
+                    _ => false,
+                },
+            };
+
+            if external_failed {
                 let cfg = crate::data::config::config(Tag::unknown());
                 if let Ok(cfg) = cfg {
                     if cfg.contains_key("nonzero_exit_errors") {
@@ -620,40 +440,45 @@ fn spawn(
                                 "command failed",
                                 &stdout_name_tag,
                             )),
-                            tag: 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(Some(stream.to_input_stream()))
+        Ok(stream.to_input_stream())
     } else {
         Err(ShellError::labeled_error(
-            "Command not found",
-            "command not found",
+            "Failed to spawn process",
+            "failed to spawn",
             &command.name_tag,
         ))
     }
 }
 
-fn did_find_command(name: &str) -> bool {
+async fn did_find_command(name: &str) -> bool {
     #[cfg(not(windows))]
     {
-        which::which(name).is_ok()
+        ichwh::which(name).await.unwrap_or(None).is_some()
     }
 
     #[cfg(windows)]
     {
-        if which::which(name).is_ok() {
+        if ichwh::which(name).await.unwrap_or(None).is_some() {
             true
         } else {
             let cmd_builtins = [
                 "call", "cls", "color", "date", "dir", "echo", "find", "hostname", "pause",
                 "start", "time", "title", "ver", "copy", "mkdir", "rename", "rd", "rmdir", "type",
+                "mklink",
             ];
 
             cmd_builtins.contains(&name)
@@ -714,10 +539,11 @@ fn shell_os_paths() -> Vec<std::path::PathBuf> {
 mod tests {
     use super::{
         add_quotes, argument_contains_whitespace, argument_is_quoted, expand_tilde, remove_quotes,
-        run_external_command, Context,
+        run_external_command, Context, InputStream,
     };
     use futures::executor::block_on;
     use nu_errors::ShellError;
+    use nu_protocol::Scope;
     use nu_test_support::commands::ExternalBuilder;
 
     // async fn read(mut stream: OutputStream) -> Option<Value> {
@@ -736,9 +562,14 @@ mod tests {
     async fn non_existent_run() -> Result<(), ShellError> {
         let cmd = ExternalBuilder::for_name("i_dont_exist.exe").build();
 
+        let input = InputStream::empty();
         let mut ctx = Context::basic().expect("There was a problem creating a basic context.");
 
-        assert!(run_external_command(cmd, &mut ctx, None, false).is_err());
+        assert!(
+            run_external_command(cmd, &mut ctx, input, &Scope::empty(), false)
+                .await
+                .is_err()
+        );
 
         Ok(())
     }

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

@@ -1,42 +1,37 @@
+use crate::commands::command::per_item_command;
+use crate::commands::run_alias::AliasCommand;
 use crate::commands::UnevaluatedCallInfo;
 use crate::prelude::*;
 use log::{log_enabled, trace};
 use nu_errors::ShellError;
-use nu_parser::InternalCommand;
-use nu_protocol::{CommandAction, Primitive, ReturnSuccess, UntaggedValue, Value};
+use nu_protocol::hir::InternalCommand;
+use nu_protocol::{CommandAction, Primitive, ReturnSuccess, Scope, UntaggedValue, Value};
 
 pub(crate) fn run_internal_command(
     command: InternalCommand,
     context: &mut Context,
-    input: Option<InputStream>,
-    source: Text,
-) -> Result<Option<InputStream>, ShellError> {
+    input: InputStream,
+    scope: &Scope,
+) -> Result<InputStream, ShellError> {
     if log_enabled!(log::Level::Trace) {
         trace!(target: "nu::run::internal", "->");
         trace!(target: "nu::run::internal", "{}", command.name);
-        trace!(target: "nu::run::internal", "{}", command.args.debug(&source));
     }
 
-    let objects: InputStream = if let Some(input) = input {
-        trace_stream!(target: "nu::trace_stream::internal", "input" = input)
-    } else {
-        InputStream::empty()
-    };
-
+    let objects: InputStream = trace_stream!(target: "nu::trace_stream::internal", "input" = input);
     let internal_command = context.expect_command(&command.name);
 
     let result = {
         context.run_command(
             internal_command?,
-            command.name_tag.clone(),
+            Tag::unknown_anchor(command.name_span),
             command.args.clone(),
-            &source,
+            scope,
             objects,
         )
     };
 
-    let result = trace_out_stream!(target: "nu::trace_stream::internal", "output" = result);
-    let mut result = result.values;
+    let mut result = trace_out_stream!(target: "nu::trace_stream::internal", "output" = result);
     let mut context = context.clone();
 
     let stream = async_stream! {
@@ -64,14 +59,15 @@ pub(crate) fn run_internal_command(
                                 ctrl_c: context.ctrl_c.clone(),
                                 shell_manager: context.shell_manager.clone(),
                                 call_info: UnevaluatedCallInfo {
-                                    args: nu_parser::hir::Call {
+                                    args: nu_protocol::hir::Call {
                                         head: command.args.head,
                                         positional: None,
                                         named: None,
-                                        span: Span::unknown()
+                                        span: Span::unknown(),
+                                        is_last: false,
                                     },
-                                    source: source.clone(),
-                                    name_tag: command.name_tag,
+                                    name_tag: Tag::unknown_anchor(command.name_span),
+                                    scope: Scope::empty(),
                                 }
                             };
                             let mut result = converter.run(new_args.with_input(vec![tagged_contents]), &context.registry);
@@ -124,6 +120,15 @@ pub(crate) fn run_internal_command(
                             FilesystemShell::with_location(location, context.registry().clone()),
                         ));
                     }
+                    CommandAction::AddAlias(name, args, block) => {
+                        context.add_commands(vec![
+                            per_item_command(AliasCommand::new(
+                                name,
+                                args,
+                                block,
+                            ))
+                        ]);
+                    }
                     CommandAction::PreviousShell => {
                         context.shell_manager.prev();
                     }
@@ -142,7 +147,8 @@ pub(crate) fn run_internal_command(
                     value: UntaggedValue::Error(err),
                     ..
                 })) => {
-                    context.error(err);
+                    context.error(err.clone());
+                    yield Err(err);
                     break;
                 }
 
@@ -175,5 +181,5 @@ pub(crate) fn run_internal_command(
         }
     };
 
-    Ok(Some(stream.to_input_stream()))
+    Ok(stream.to_input_stream())
 }

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

@@ -1,7 +1,8 @@
+pub(crate) mod block;
 mod dynamic;
+pub(crate) mod expr;
 pub(crate) mod external;
 pub(crate) mod internal;
-pub(crate) mod pipeline;
 
 #[allow(unused_imports)]
 pub(crate) use dynamic::Command as DynamicCommand;

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

@@ -1,50 +0,0 @@
-use crate::commands::classified::external::run_external_command;
-use crate::commands::classified::internal::run_internal_command;
-use crate::context::Context;
-use crate::stream::InputStream;
-use nu_errors::ShellError;
-use nu_parser::{ClassifiedCommand, ClassifiedPipeline};
-use nu_source::Text;
-
-pub(crate) async fn run_pipeline(
-    pipeline: ClassifiedPipeline,
-    ctx: &mut Context,
-    mut input: Option<InputStream>,
-    line: &str,
-) -> Result<Option<InputStream>, ShellError> {
-    let mut iter = pipeline.commands.list.into_iter().peekable();
-
-    loop {
-        let item: Option<ClassifiedCommand> = iter.next();
-        let next: Option<&ClassifiedCommand> = iter.peek();
-
-        input = match (item, next) {
-            (Some(ClassifiedCommand::Dynamic(_)), _) | (_, Some(ClassifiedCommand::Dynamic(_))) => {
-                return Err(ShellError::unimplemented("Dynamic commands"))
-            }
-
-            (Some(ClassifiedCommand::Expr(_)), _) | (_, Some(ClassifiedCommand::Expr(_))) => {
-                return Err(ShellError::unimplemented("Expression-only commands"))
-            }
-
-            (Some(ClassifiedCommand::Error(err)), _) => return Err(err.into()),
-            (_, Some(ClassifiedCommand::Error(err))) => return Err(err.clone().into()),
-
-            (Some(ClassifiedCommand::Internal(left)), _) => {
-                run_internal_command(left, ctx, input, Text::from(line))?
-            }
-
-            (Some(ClassifiedCommand::External(left)), None) => {
-                run_external_command(left, ctx, input, true)?
-            }
-
-            (Some(ClassifiedCommand::External(left)), _) => {
-                run_external_command(left, ctx, input, false)?
-            }
-
-            (None, _) => break,
-        };
-    }
-
-    Ok(input)
-}

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

@@ -41,7 +41,7 @@ pub mod clipboard {
         RunnableContext { input, name, .. }: RunnableContext,
     ) -> Result<OutputStream, ShellError> {
         let stream = async_stream! {
-            let values: Vec<Value> = input.values.collect().await;
+            let values: Vec<Value> = input.collect().await;
 
             let mut clip_stream = inner_clip(values, name).await;
             while let Some(value) = clip_stream.next().await {

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

@@ -6,7 +6,7 @@ use crate::prelude::*;
 use derive_new::new;
 use getset::Getters;
 use nu_errors::ShellError;
-use nu_parser::hir;
+use nu_protocol::hir;
 use nu_protocol::{CallInfo, EvaluatedArgs, ReturnValue, Scope, Signature, Value};
 use serde::{Deserialize, Serialize};
 use std::ops::Deref;
@@ -15,17 +15,28 @@ use std::sync::atomic::AtomicBool;
 #[derive(Deserialize, Serialize, Debug, Clone)]
 pub struct UnevaluatedCallInfo {
     pub args: hir::Call,
-    pub source: Text,
     pub name_tag: Tag,
+    pub scope: Scope,
 }
 
 impl UnevaluatedCallInfo {
-    pub fn evaluate(
+    pub fn evaluate(self, registry: &CommandRegistry) -> Result<CallInfo, ShellError> {
+        let args = evaluate_args(&self.args, registry, &self.scope)?;
+
+        Ok(CallInfo {
+            args,
+            name_tag: self.name_tag,
+        })
+    }
+
+    pub fn evaluate_with_new_it(
         self,
         registry: &CommandRegistry,
-        scope: &Scope,
+        it: &Value,
     ) -> Result<CallInfo, ShellError> {
-        let args = evaluate_args(&self.args, registry, scope, &self.source)?;
+        let mut scope = self.scope.clone();
+        scope = scope.set_it(it.clone());
+        let args = evaluate_args(&self.args, registry, &scope)?;
 
         Ok(CallInfo {
             args,
@@ -114,7 +125,7 @@ impl CommandArgs {
         let ctrl_c = self.ctrl_c.clone();
         let shell_manager = self.shell_manager.clone();
         let input = self.input;
-        let call_info = self.call_info.evaluate(registry, &Scope::empty())?;
+        let call_info = self.call_info.evaluate(registry)?;
 
         Ok(EvaluatedWholeStreamCommandArgs::new(
             host,
@@ -134,7 +145,12 @@ impl CommandArgs {
         let ctrl_c = self.ctrl_c.clone();
         let shell_manager = self.shell_manager.clone();
         let input = self.input;
-        let call_info = self.call_info.evaluate(registry, scope)?;
+        let call_info = UnevaluatedCallInfo {
+            name_tag: self.call_info.name_tag,
+            args: self.call_info.args,
+            scope: scope.clone(),
+        };
+        let call_info = call_info.evaluate(registry)?;
 
         Ok(EvaluatedWholeStreamCommandArgs::new(
             host,
@@ -145,10 +161,6 @@ impl CommandArgs {
         ))
     }
 
-    pub fn source(&self) -> Text {
-        self.call_info.source.clone()
-    }
-
     pub fn process<'de, T: Deserialize<'de>, O: ToOutputStream>(
         self,
         registry: &CommandRegistry,
@@ -156,7 +168,6 @@ impl CommandArgs {
     ) -> Result<RunnableArgs<T, O>, ShellError> {
         let shell_manager = self.shell_manager.clone();
         let host = self.host.clone();
-        let source = self.source();
         let ctrl_c = self.ctrl_c.clone();
         let args = self.evaluate_once(registry)?;
         let call_info = args.call_info.clone();
@@ -168,8 +179,7 @@ impl CommandArgs {
             args: T::deserialize(&mut deserializer)?,
             context: RunnableContext {
                 input,
-                commands: registry.clone(),
-                source,
+                registry: registry.clone(),
                 shell_manager,
                 name: name_tag,
                 host,
@@ -193,7 +203,6 @@ impl CommandArgs {
 
         let shell_manager = self.shell_manager.clone();
         let host = self.host.clone();
-        let source = self.source();
         let ctrl_c = self.ctrl_c.clone();
         let args = self.evaluate_once(registry)?;
         let call_info = args.call_info.clone();
@@ -206,8 +215,7 @@ impl CommandArgs {
             args: T::deserialize(&mut deserializer)?,
             context: RunnableContext {
                 input,
-                commands: registry.clone(),
-                source,
+                registry: registry.clone(),
                 shell_manager,
                 name: name_tag,
                 host,
@@ -229,15 +237,14 @@ pub struct RunnableContext {
     pub input: InputStream,
     pub shell_manager: ShellManager,
     pub host: Arc<parking_lot::Mutex<Box<dyn Host>>>,
-    pub source: Text,
     pub ctrl_c: Arc<AtomicBool>,
-    pub commands: CommandRegistry,
+    pub registry: CommandRegistry,
     pub name: Tag,
 }
 
 impl RunnableContext {
     pub fn get_command(&self, name: &str) -> Option<Arc<Command>> {
-        self.commands.get_command(name)
+        self.registry.get_command(name)
     }
 }
 
@@ -374,6 +381,14 @@ impl EvaluatedCommandArgs {
         self.call_info.args.nth(pos)
     }
 
+    /// Get the nth positional argument, error if not possible
+    pub fn expect_nth(&self, pos: usize) -> Result<&Value, ShellError> {
+        match self.call_info.args.nth(pos) {
+            None => Err(ShellError::unimplemented("Better error: expect_nth")),
+            Some(item) => Ok(item),
+        }
+    }
+
     pub fn get(&self, name: &str) -> Option<&Value> {
         self.call_info.args.get(name)
     }
@@ -515,12 +530,17 @@ impl Command {
 
         let out = args
             .input
-            .values
             .map(move |x| {
-                let call_info = raw_args
-                    .clone()
-                    .call_info
-                    .evaluate(&registry, &Scope::it_value(x.clone()));
+                let call_info = UnevaluatedCallInfo {
+                    args: raw_args.call_info.args.clone(),
+                    name_tag: raw_args.call_info.name_tag.clone(),
+                    scope: raw_args.call_info.scope.clone().set_it(x.clone()),
+                }
+                .evaluate(&registry);
+                // let call_info = raw_args
+                //     .clone()
+                //     .call_info
+                //     .evaluate(&registry, &Scope::it_value(x.clone()));
 
                 match call_info {
                     Ok(call_info) => match command.run(&call_info, &registry, &raw_args, x) {
@@ -576,9 +596,9 @@ impl WholeStreamCommand for FnFilterCommand {
         let registry: CommandRegistry = registry.clone();
         let func = self.func;
 
-        let result = input.values.map(move |it| {
+        let result = input.map(move |it| {
             let registry = registry.clone();
-            let call_info = match call_info.clone().evaluate(&registry, &Scope::it_value(it)) {
+            let call_info = match call_info.clone().evaluate_with_new_it(&registry, &it) {
                 Err(err) => return OutputStream::from(vec![Err(err)]).values,
                 Ok(args) => args,
             };

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

@@ -39,7 +39,7 @@ pub fn compact(
     CompactArgs { rest: columns }: CompactArgs,
     RunnableContext { input, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
-    let objects = input.values.filter(move |item| {
+    let objects = input.filter(move |item| {
         let keep = if columns.is_empty() {
             item.is_some()
         } else {

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

@@ -41,7 +41,7 @@ impl WholeStreamCommand for Config {
             )
             .named(
                 "set_into",
-                SyntaxShape::Member,
+                SyntaxShape::String,
                 "sets a variable from values in the pipeline",
                 Some('i'),
             )
@@ -124,7 +124,7 @@ pub fn config(
             yield ReturnSuccess::value(UntaggedValue::Row(result.into()).into_value(&value.tag));
         }
         else if let Some(v) = set_into {
-            let rows: Vec<Value> = input.values.collect().await;
+            let rows: Vec<Value> = input.collect().await;
             let key = v.to_string();
 
             if rows.len() == 0 {

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

@@ -37,7 +37,7 @@ pub fn count(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let rows: Vec<Value> = input.values.collect().await;
+        let rows: Vec<Value> = input.collect().await;
 
         yield ReturnSuccess::value(UntaggedValue::int(rows.len()).into_value(name))
     };

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

@@ -37,7 +37,6 @@ fn debug_value(
     RunnableContext { input, .. }: RunnableContext,
 ) -> Result<impl ToOutputStream, ShellError> {
     Ok(input
-        .values
         .map(move |v| {
             if raw {
                 ReturnSuccess::value(

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

@@ -47,7 +47,6 @@ fn default(
     RunnableContext { input, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = input
-        .values
         .map(move |item| {
             let mut result = VecDeque::new();
 

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

@@ -9,7 +9,6 @@ use nu_errors::ShellError;
 use nu_protocol::{CallInfo, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 use std::path::PathBuf;
-use std::sync::atomic::Ordering;
 
 const NAME: &str = "du";
 const GLOB_PARAMS: MatchOptions = MatchOptions {
@@ -42,7 +41,7 @@ impl PerItemCommand for Du {
             .optional("path", SyntaxShape::Pattern, "starting directory")
             .switch(
                 "all",
-                "Output File sizes as well as directory sizes",
+                "Output file sizes as well as directory sizes",
                 Some('a'),
             )
             .switch(
@@ -90,51 +89,33 @@ impl PerItemCommand for Du {
 fn du(args: DuArgs, ctx: &RunnablePerItemContext) -> Result<OutputStream, ShellError> {
     let tag = ctx.name.clone();
 
-    let exclude = args
-        .exclude
-        .clone()
-        .map_or(Ok(None), move |x| match Pattern::new(&x.item) {
-            Ok(p) => Ok(Some(p)),
-            Err(e) => Err(ShellError::labeled_error(
-                e.msg,
-                "Glob error",
-                x.tag.clone(),
-            )),
-        })?;
-    let path = args.path.clone();
-    let filter_files = path.is_none();
-    let paths = match path {
-        Some(p) => match glob::glob_with(
-            p.item.to_str().expect("Why isn't this encoded properly?"),
-            GLOB_PARAMS,
-        ) {
-            Ok(g) => Ok(g),
-            Err(e) => Err(ShellError::labeled_error(
-                e.msg,
-                "Glob error",
-                p.tag.clone(),
-            )),
-        },
-        None => match glob::glob_with("*", GLOB_PARAMS) {
-            Ok(g) => Ok(g),
-            Err(e) => Err(ShellError::labeled_error(e.msg, "Glob error", tag.clone())),
-        },
-    }?
+    let exclude = args.exclude.map_or(Ok(None), move |x| {
+        Pattern::new(&x.item)
+            .map(Option::Some)
+            .map_err(|e| ShellError::labeled_error(e.msg, "glob error", x.tag.clone()))
+    })?;
+
+    let include_files = args.all;
+    let paths = match args.path {
+        Some(p) => {
+            let p = p.item.to_str().expect("Why isn't this encoded properly?");
+            glob::glob_with(p, GLOB_PARAMS)
+        }
+        None => glob::glob_with("*", GLOB_PARAMS),
+    }
+    .map_err(|e| ShellError::labeled_error(e.msg, "glob error", tag.clone()))?
     .filter(move |p| {
-        if filter_files {
+        if include_files {
+            true
+        } else {
             match p {
                 Ok(f) if f.is_dir() => true,
                 Err(e) if e.path().is_dir() => true,
                 _ => false,
             }
-        } else {
-            true
         }
     })
-    .map(move |p| match p {
-        Err(e) => Err(glob_err_into(e)),
-        Ok(s) => Ok(s),
-    });
+    .map(|v| v.map_err(glob_err_into));
 
     let ctrl_c = ctx.ctrl_c.clone();
     let all = args.all;
@@ -142,35 +123,29 @@ fn du(args: DuArgs, ctx: &RunnablePerItemContext) -> Result<OutputStream, ShellE
     let max_depth = args.max_depth.map(|f| f.item);
     let min_size = args.min_size.map(|f| f.item);
 
-    let stream = async_stream! {
-        let params = DirBuilder {
-            tag: tag.clone(),
-            min: min_size,
-            deref,
-            ex: exclude,
-            all,
-        };
-        for path in paths {
-            if ctrl_c.load(Ordering::SeqCst) {
-                break;
-            }
-            match path {
-                Ok(p) => {
-                    if p.is_dir() {
-                        yield Ok(ReturnSuccess::Value(
-                            DirInfo::new(p, &params, max_depth).into(),
-                        ));
-                    } else {
-                        match FileInfo::new(p, deref, tag.clone()) {
-                            Ok(f) => yield Ok(ReturnSuccess::Value(f.into())),
-                            Err(e) => yield Err(e)
-                        }
-                    }
-                }
-                Err(e) => yield Err(e),
-            }
-        }
+    let params = DirBuilder {
+        tag: tag.clone(),
+        min: min_size,
+        deref,
+        exclude,
+        all,
     };
+
+    let stream = futures::stream::iter(paths)
+        .interruptible(ctrl_c)
+        .map(move |path| match path {
+            Ok(p) => {
+                if p.is_dir() {
+                    Ok(ReturnSuccess::Value(
+                        DirInfo::new(p, &params, max_depth).into(),
+                    ))
+                } else {
+                    FileInfo::new(p, deref, tag.clone()).map(|v| ReturnSuccess::Value(v.into()))
+                }
+            }
+            Err(e) => Err(e),
+        });
+
     Ok(stream.to_output_stream())
 }
 
@@ -178,7 +153,7 @@ struct DirBuilder {
     tag: Tag,
     min: Option<u64>,
     deref: bool,
-    ex: Option<Pattern>,
+    exclude: Option<Pattern>,
     all: bool,
 }
 
@@ -243,15 +218,11 @@ impl DirInfo {
                 for f in d {
                     match f {
                         Ok(i) => match i.file_type() {
-                            Ok(t) if t.is_dir() => {
-                                s = s.add_dir(i.path(), depth, &params);
-                            }
-                            Ok(_t) => {
-                                s = s.add_file(i.path(), &params);
-                            }
-                            Err(e) => s = s.add_error(ShellError::from(e)),
+                            Ok(t) if t.is_dir() => s = s.add_dir(i.path(), depth, &params),
+                            Ok(_t) => s = s.add_file(i.path(), &params),
+                            Err(e) => s = s.add_error(e.into()),
                         },
-                        Err(e) => s = s.add_error(ShellError::from(e)),
+                        Err(e) => s = s.add_error(e.into()),
                     }
                 }
             }
@@ -283,8 +254,11 @@ impl DirInfo {
 
     fn add_file(mut self, f: impl Into<PathBuf>, params: &DirBuilder) -> Self {
         let f = f.into();
-        let ex = params.ex.as_ref().map_or(false, |x| x.matches_path(&f));
-        if !ex {
+        let include = params
+            .exclude
+            .as_ref()
+            .map_or(true, |x| !x.matches_path(&f));
+        if include {
             match FileInfo::new(f, params.deref, self.tag.clone()) {
                 Ok(file) => {
                     let inc = params.min.map_or(true, |s| file.size >= s);
@@ -313,55 +287,51 @@ fn glob_err_into(e: GlobError) -> ShellError {
     ShellError::from(e)
 }
 
+fn value_from_vec<V>(vec: Vec<V>, tag: &Tag) -> Value
+where
+    V: Into<Value>,
+{
+    if vec.is_empty() {
+        UntaggedValue::nothing()
+    } else {
+        let values = vec.into_iter().map(Into::into).collect::<Vec<Value>>();
+        UntaggedValue::Table(values)
+    }
+    .retag(tag)
+}
+
 impl From<DirInfo> for Value {
     fn from(d: DirInfo) -> Self {
         let mut r: IndexMap<String, Value> = IndexMap::new();
+
         r.insert(
             "path".to_string(),
-            UntaggedValue::path(d.path).retag(d.tag.clone()),
+            UntaggedValue::path(d.path).retag(&d.tag),
         );
+
         r.insert(
             "apparent".to_string(),
-            UntaggedValue::bytes(d.size).retag(d.tag.clone()),
+            UntaggedValue::bytes(d.size).retag(&d.tag),
         );
+
         r.insert(
             "physical".to_string(),
-            UntaggedValue::bytes(d.blocks).retag(d.tag.clone()),
+            UntaggedValue::bytes(d.blocks).retag(&d.tag),
         );
-        if !d.files.is_empty() {
-            let v = Value {
-                value: UntaggedValue::Table(
-                    d.files
-                        .into_iter()
-                        .map(move |f| f.into())
-                        .collect::<Vec<Value>>(),
-                ),
-                tag: d.tag.clone(),
-            };
-            r.insert("files".to_string(), v);
-        }
-        if !d.dirs.is_empty() {
-            let v = Value {
-                value: UntaggedValue::Table(
-                    d.dirs
-                        .into_iter()
-                        .map(move |d| d.into())
-                        .collect::<Vec<Value>>(),
-                ),
-                tag: d.tag.clone(),
-            };
-            r.insert("directories".to_string(), v);
-        }
+
+        r.insert("directories".to_string(), value_from_vec(d.dirs, &d.tag));
+
+        r.insert("files".to_string(), value_from_vec(d.files, &d.tag));
+
         if !d.errors.is_empty() {
-            let v = Value {
-                value: UntaggedValue::Table(
-                    d.errors
-                        .into_iter()
-                        .map(move |e| UntaggedValue::Error(e).into_untagged_value())
-                        .collect::<Vec<Value>>(),
-                ),
-                tag: d.tag.clone(),
-            };
+            let v = UntaggedValue::Table(
+                d.errors
+                    .into_iter()
+                    .map(move |e| UntaggedValue::Error(e).into_untagged_value())
+                    .collect::<Vec<Value>>(),
+            )
+            .retag(&d.tag);
+
             r.insert("errors".to_string(), v);
         }
 
@@ -375,22 +345,32 @@ impl From<DirInfo> for Value {
 impl From<FileInfo> for Value {
     fn from(f: FileInfo) -> Self {
         let mut r: IndexMap<String, Value> = IndexMap::new();
+
         r.insert(
             "path".to_string(),
-            UntaggedValue::path(f.path).retag(f.tag.clone()),
+            UntaggedValue::path(f.path).retag(&f.tag),
         );
+
         r.insert(
             "apparent".to_string(),
-            UntaggedValue::bytes(f.size).retag(f.tag.clone()),
+            UntaggedValue::bytes(f.size).retag(&f.tag),
         );
-        let b = match f.blocks {
-            Some(k) => UntaggedValue::bytes(k).retag(f.tag.clone()),
-            None => UntaggedValue::nothing().retag(f.tag.clone()),
-        };
+
+        let b = f
+            .blocks
+            .map(UntaggedValue::bytes)
+            .unwrap_or_else(UntaggedValue::nothing)
+            .retag(&f.tag);
+
         r.insert("physical".to_string(), b);
-        Value {
-            value: UntaggedValue::row(r),
-            tag: f.tag,
-        }
+
+        r.insert(
+            "directories".to_string(),
+            UntaggedValue::nothing().retag(&f.tag),
+        );
+
+        r.insert("files".to_string(), UntaggedValue::nothing().retag(&f.tag));
+
+        UntaggedValue::row(r).retag(&f.tag)
     }
 }

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

@@ -0,0 +1,86 @@
+use crate::commands::classified::block::run_block;
+use crate::commands::PerItemCommand;
+use crate::context::CommandRegistry;
+use crate::prelude::*;
+
+use futures::stream::once;
+
+use nu_errors::ShellError;
+use nu_protocol::{CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue, Value};
+
+pub struct Each;
+
+impl PerItemCommand for Each {
+    fn name(&self) -> &str {
+        "each"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("each").required(
+            "block",
+            SyntaxShape::Block,
+            "the block to run on each row",
+        )
+    }
+
+    fn usage(&self) -> &str {
+        "Run a block on each row of the table."
+    }
+
+    fn run(
+        &self,
+        call_info: &CallInfo,
+        registry: &CommandRegistry,
+        raw_args: &RawCommandArgs,
+        input: Value,
+    ) -> Result<OutputStream, ShellError> {
+        let call_info = call_info.clone();
+        let registry = registry.clone();
+        let raw_args = raw_args.clone();
+        let stream = async_stream! {
+            match call_info.args.expect_nth(0)? {
+                Value {
+                    value: UntaggedValue::Block(block),
+                    tag
+                } => {
+                    let mut context = Context::from_raw(&raw_args, &registry);
+                    let input_clone = input.clone();
+                    let input_stream = once(async { Ok(input) }).to_input_stream();
+
+                    let result = run_block(
+                        block,
+                        &mut context,
+                        input_stream,
+                        &Scope::new(input_clone),
+                    ).await;
+
+                    match result {
+                        Ok(mut stream) => {
+                            let errors = context.get_errors();
+                            if let Some(error) = errors.first() {
+                                yield Err(error.clone());
+                                return;
+                            }
+
+                            while let Some(result) = stream.next().await {
+                                yield Ok(ReturnSuccess::Value(result));
+                            }
+                        }
+                        Err(e) => {
+                            yield Err(e);
+                        }
+                    }
+                }
+                Value { tag, .. } => {
+                    yield Err(ShellError::labeled_error(
+                        "Expected a block",
+                        "each needs a block",
+                        tag,
+                    ))
+                }
+            };
+        };
+
+        Ok(stream.to_output_stream())
+    }
+}

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

@@ -97,14 +97,15 @@ impl PerItemCommand for Enter {
                                             ctrl_c: raw_args.ctrl_c,
                                             shell_manager: raw_args.shell_manager,
                                             call_info: UnevaluatedCallInfo {
-                                                args: nu_parser::hir::Call {
+                                                args: nu_protocol::hir::Call {
                                                     head: raw_args.call_info.args.head,
                                                     positional: None,
                                                     named: None,
-                                                    span: Span::unknown()
+                                                    span: Span::unknown(),
+                                                    is_last: false,
                                                 },
-                                                source: raw_args.call_info.source,
                                                 name_tag: raw_args.call_info.name_tag,
+                                                scope: raw_args.call_info.scope.clone()
                                             },
                                         };
                                         let mut result = converter.run(

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

@@ -45,7 +45,7 @@ pub fn evaluate_by(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
         if values.is_empty() {
             yield Err(ShellError::labeled_error(

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

@@ -48,7 +48,5 @@ fn first(
         1
     };
 
-    Ok(OutputStream::from_input(
-        context.input.values.take(rows_desired),
-    ))
+    Ok(OutputStream::from_input(context.input.take(rows_desired)))
 }

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

@@ -9,11 +9,6 @@ use nu_source::Tagged;
 use nu_value_ext::{as_column_path, get_data_by_column_path};
 use std::borrow::Borrow;
 
-use nom::{
-    bytes::complete::{tag, take_while},
-    IResult,
-};
-
 pub struct Format;
 
 impl PerItemCommand for Format {
@@ -45,14 +40,8 @@ impl PerItemCommand for Format {
         let pattern_tag = pattern.tag.clone();
         let pattern = pattern.as_string()?;
 
-        let format_pattern = format(&pattern).map_err(|_| {
-            ShellError::labeled_error(
-                "Could not create format pattern",
-                "could not create format pattern",
-                &pattern_tag,
-            )
-        })?;
-        let commands = format_pattern.1;
+        let format_pattern = format(&pattern);
+        let commands = format_pattern;
 
         let output = match value {
             value
@@ -66,7 +55,7 @@ impl PerItemCommand for Format {
                 for command in &commands {
                     match command {
                         FormatCommand::Text(s) => {
-                            output.push_str(s);
+                            output.push_str(&s);
                         }
                         FormatCommand::Column(c) => {
                             let key = to_column_path(&c, &pattern_tag)?;
@@ -104,32 +93,43 @@ enum FormatCommand {
     Column(String),
 }
 
-fn format(input: &str) -> IResult<&str, Vec<FormatCommand>> {
+fn format(input: &str) -> Vec<FormatCommand> {
     let mut output = vec![];
 
-    let mut loop_input = input;
+    let mut loop_input = input.chars();
     loop {
-        let (input, before) = take_while(|c| c != '{')(loop_input)?;
+        let mut before = String::new();
+
+        while let Some(c) = loop_input.next() {
+            if c == '{' {
+                break;
+            }
+            before.push(c);
+        }
+
         if !before.is_empty() {
             output.push(FormatCommand::Text(before.to_string()));
         }
-        if input != "" {
-            // Look for column as we're now at one
-            let (input, _) = tag("{")(input)?;
-            let (input, column) = take_while(|c| c != '}')(input)?;
-            let (input, _) = tag("}")(input)?;
+        // Look for column as we're now at one
+        let mut column = String::new();
 
-            output.push(FormatCommand::Column(column.to_string()));
-            loop_input = input;
-        } else {
-            loop_input = input;
+        while let Some(c) = loop_input.next() {
+            if c == '}' {
+                break;
+            }
+            column.push(c);
         }
-        if loop_input == "" {
+
+        if !column.is_empty() {
+            output.push(FormatCommand::Column(column.to_string()));
+        }
+
+        if before.is_empty() && column.is_empty() {
             break;
         }
     }
 
-    Ok((loop_input, output))
+    output
 }
 
 fn to_column_path(

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

@@ -1,7 +1,7 @@
 use crate::prelude::*;
-use csv::ReaderBuilder;
+use csv::{ErrorKind, ReaderBuilder};
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, TaggedDictBuilder, UntaggedValue, Value};
+use nu_protocol::{ReturnSuccess, TaggedDictBuilder, UntaggedValue, Value};
 
 fn from_delimited_string_to_value(
     s: String,
@@ -27,10 +27,13 @@ fn from_delimited_string_to_value(
     for row in reader.records() {
         let mut tagged_row = TaggedDictBuilder::new(&tag);
         for (value, header) in row?.iter().zip(headers.iter()) {
-            tagged_row.insert_value(
-                header,
-                UntaggedValue::Primitive(Primitive::String(String::from(value))).into_value(&tag),
-            )
+            if let Ok(i) = value.parse::<i64>() {
+                tagged_row.insert_value(header, UntaggedValue::int(i).into_value(&tag))
+            } else if let Ok(f) = value.parse::<f64>() {
+                tagged_row.insert_value(header, UntaggedValue::decimal(f).into_value(&tag))
+            } else {
+                tagged_row.insert_value(header, UntaggedValue::string(value).into_value(&tag))
+            }
         }
         rows.push(tagged_row.into_value());
     }
@@ -58,8 +61,11 @@ pub fn from_delimited_data(
                 }
                 x => yield ReturnSuccess::value(x),
             },
-            Err(_) => {
-                let line_one = format!("Could not parse as {}", format_name);
+            Err(err) => {
+                let line_one = match pretty_csv_error(err) {
+                    Some(pretty) => format!("Could not parse as {} ({})", format_name,pretty),
+                    None => format!("Could not parse as {}", format_name),
+                };
                 let line_two = format!("input cannot be parsed as {}", format_name);
                 yield Err(ShellError::labeled_error_with_secondary(
                     line_one,
@@ -74,3 +80,26 @@ pub fn from_delimited_data(
 
     Ok(stream.to_output_stream())
 }
+
+fn pretty_csv_error(err: csv::Error) -> Option<String> {
+    match err.kind() {
+        ErrorKind::UnequalLengths {
+            pos,
+            expected_len,
+            len,
+        } => {
+            if let Some(pos) = pos {
+                Some(format!(
+                    "Line {}: expected {} fields, found {}",
+                    pos.line(),
+                    expected_len,
+                    len
+                ))
+            } else {
+                Some(format!("Expected {} fields, found {}", expected_len, len))
+            }
+        }
+        ErrorKind::Seek => Some("Internal error while parsing csv".to_string()),
+        _ => None,
+    }
+}

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

@@ -0,0 +1,240 @@
+extern crate ical;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use ical::parser::ical::component::*;
+use ical::property::Property;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+use std::io::BufReader;
+
+pub struct FromIcs;
+
+impl WholeStreamCommand for FromIcs {
+    fn name(&self) -> &str {
+        "from-ics"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from-ics")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .ics and create table."
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        from_ics(args, registry)
+    }
+}
+
+fn from_ics(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once(registry)?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let stream = async_stream! {
+        let input_string = input.collect_string(tag.clone()).await?.item;
+        let input_bytes = input_string.as_bytes();
+        let buf_reader = BufReader::new(input_bytes);
+        let parser = ical::IcalParser::new(buf_reader);
+
+        for calendar in parser {
+            match calendar {
+                Ok(c) => yield ReturnSuccess::value(calendar_to_value(c, tag.clone())),
+                Err(_) => yield Err(ShellError::labeled_error(
+                    "Could not parse as .ics",
+                    "input cannot be parsed as .ics",
+                    tag.clone()
+                )),
+            }
+        }
+    };
+
+    Ok(stream.to_output_stream())
+}
+
+fn calendar_to_value(calendar: IcalCalendar, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag.clone());
+
+    row.insert_untagged(
+        "properties",
+        properties_to_value(calendar.properties, tag.clone()),
+    );
+    row.insert_untagged("events", events_to_value(calendar.events, tag.clone()));
+    row.insert_untagged("alarms", alarms_to_value(calendar.alarms, tag.clone()));
+    row.insert_untagged("to-Dos", todos_to_value(calendar.todos, tag.clone()));
+    row.insert_untagged(
+        "journals",
+        journals_to_value(calendar.journals, tag.clone()),
+    );
+    row.insert_untagged(
+        "free-busys",
+        free_busys_to_value(calendar.free_busys, tag.clone()),
+    );
+    row.insert_untagged("timezones", timezones_to_value(calendar.timezones, tag));
+
+    row.into_value()
+}
+
+fn events_to_value(events: Vec<IcalEvent>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &events
+            .into_iter()
+            .map(|event| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(event.properties, tag.clone()),
+                );
+                row.insert_untagged("alarms", alarms_to_value(event.alarms, tag.clone()));
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn alarms_to_value(alarms: Vec<IcalAlarm>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &alarms
+            .into_iter()
+            .map(|alarm| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(alarm.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn todos_to_value(todos: Vec<IcalTodo>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &todos
+            .into_iter()
+            .map(|todo| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(todo.properties, tag.clone()),
+                );
+                row.insert_untagged("alarms", alarms_to_value(todo.alarms, tag.clone()));
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn journals_to_value(journals: Vec<IcalJournal>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &journals
+            .into_iter()
+            .map(|journal| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(journal.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn free_busys_to_value(free_busys: Vec<IcalFreeBusy>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &free_busys
+            .into_iter()
+            .map(|free_busy| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(free_busy.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn timezones_to_value(timezones: Vec<IcalTimeZone>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &timezones
+            .into_iter()
+            .map(|timezone| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(timezone.properties, tag.clone()),
+                );
+                row.insert_untagged(
+                    "transitions",
+                    timezone_transitions_to_value(timezone.transitions, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn timezone_transitions_to_value(
+    transitions: Vec<IcalTimeZoneTransition>,
+    tag: Tag,
+) -> UntaggedValue {
+    UntaggedValue::table(
+        &transitions
+            .into_iter()
+            .map(|transition| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+                row.insert_untagged(
+                    "properties",
+                    properties_to_value(transition.properties, tag.clone()),
+                );
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn properties_to_value(properties: Vec<Property>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &properties
+            .into_iter()
+            .map(|prop| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+
+                let name = UntaggedValue::string(prop.name);
+                let value = match prop.value {
+                    Some(val) => UntaggedValue::string(val),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+                let params = match prop.params {
+                    Some(param_list) => params_to_value(param_list, tag.clone()).into(),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+
+                row.insert_untagged("name", name);
+                row.insert_untagged("value", value);
+                row.insert_untagged("params", params);
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag);
+
+    for (param_name, param_values) in params {
+        let values: Vec<Value> = param_values.into_iter().map(|val| val.into()).collect();
+        let values = UntaggedValue::table(&values);
+        row.insert_untagged(param_name, values);
+    }
+
+    row.into_value()
+}

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

@@ -0,0 +1,102 @@
+extern crate ical;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use ical::parser::vcard::component::*;
+use ical::property::Property;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, TaggedDictBuilder, UntaggedValue, Value};
+use std::io::BufReader;
+
+pub struct FromVcf;
+
+impl WholeStreamCommand for FromVcf {
+    fn name(&self) -> &str {
+        "from-vcf"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("from-vcf")
+    }
+
+    fn usage(&self) -> &str {
+        "Parse text as .vcf and create table."
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        from_vcf(args, registry)
+    }
+}
+
+fn from_vcf(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once(registry)?;
+    let tag = args.name_tag();
+    let input = args.input;
+
+    let stream = async_stream! {
+        let input_string = input.collect_string(tag.clone()).await?.item;
+        let input_bytes = input_string.as_bytes();
+        let buf_reader = BufReader::new(input_bytes);
+        let parser = ical::VcardParser::new(buf_reader);
+
+        for contact in parser {
+            match contact {
+                Ok(c) => yield ReturnSuccess::value(contact_to_value(c, tag.clone())),
+                Err(_) => yield Err(ShellError::labeled_error(
+                    "Could not parse as .vcf",
+                    "input cannot be parsed as .vcf",
+                    tag.clone()
+                )),
+            }
+        }
+    };
+
+    Ok(stream.to_output_stream())
+}
+
+fn contact_to_value(contact: VcardContact, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag.clone());
+    row.insert_untagged("properties", properties_to_value(contact.properties, tag));
+    row.into_value()
+}
+
+fn properties_to_value(properties: Vec<Property>, tag: Tag) -> UntaggedValue {
+    UntaggedValue::table(
+        &properties
+            .into_iter()
+            .map(|prop| {
+                let mut row = TaggedDictBuilder::new(tag.clone());
+
+                let name = UntaggedValue::string(prop.name);
+                let value = match prop.value {
+                    Some(val) => UntaggedValue::string(val),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+                let params = match prop.params {
+                    Some(param_list) => params_to_value(param_list, tag.clone()).into(),
+                    None => UntaggedValue::Primitive(Primitive::Nothing),
+                };
+
+                row.insert_untagged("name", name);
+                row.insert_untagged("value", value);
+                row.insert_untagged("params", params);
+                row.into_value()
+            })
+            .collect::<Vec<Value>>(),
+    )
+}
+
+fn params_to_value(params: Vec<(String, Vec<String>)>, tag: Tag) -> Value {
+    let mut row = TaggedDictBuilder::new(tag);
+
+    for (param_name, param_values) in params {
+        let values: Vec<Value> = param_values.into_iter().map(|val| val.into()).collect();
+        let values = UntaggedValue::table(&values);
+        row.insert_untagged(param_name, values);
+    }
+
+    row.into_value()
+}

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

@@ -4,8 +4,8 @@ use indexmap::set::IndexSet;
 use log::trace;
 use nu_errors::ShellError;
 use nu_protocol::{
-    did_you_mean, ColumnPath, PathMember, ReturnSuccess, ReturnValue, Signature, SyntaxShape,
-    UnspannedPathMember, UntaggedValue, Value,
+    did_you_mean, ColumnPath, PathMember, Primitive, ReturnSuccess, ReturnValue, Signature,
+    SyntaxShape, UnspannedPathMember, UntaggedValue, Value,
 };
 use nu_source::span_for_spanned_list;
 use nu_value_ext::get_data_by_column_path;
@@ -197,7 +197,6 @@ pub fn get(
         let member = fields.remove(0);
         trace!("get {:?} {:?}", member, fields);
         let stream = input
-            .values
             .map(move |item| {
                 let mut result = VecDeque::new();
 
@@ -221,6 +220,10 @@ pub fn get(
                                     result.push_back(ReturnSuccess::value(item.clone()));
                                 }
                             }
+                            Value {
+                                value: UntaggedValue::Primitive(Primitive::Nothing),
+                                ..
+                            } => {}
                             other => result.push_back(ReturnSuccess::value(other.clone())),
                         },
                         Err(reason) => result.push_back(ReturnSuccess::value(

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

@@ -43,7 +43,7 @@ pub fn group_by(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
         if values.is_empty() {
             yield Err(ShellError::labeled_error(

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

@@ -0,0 +1,80 @@
+use crate::commands::WholeStreamCommand;
+use crate::context::CommandRegistry;
+use crate::prelude::*;
+use futures::stream::StreamExt;
+use indexmap::IndexMap;
+use nu_errors::ShellError;
+use nu_protocol::Dictionary;
+use nu_protocol::{ReturnSuccess, Signature, UntaggedValue, Value};
+
+pub struct Headers;
+#[derive(Deserialize)]
+pub struct HeadersArgs {}
+
+impl WholeStreamCommand for Headers {
+    fn name(&self) -> &str {
+        "headers"
+    }
+    fn signature(&self) -> Signature {
+        Signature::build("headers")
+    }
+    fn usage(&self) -> &str {
+        "Use the first row of the table as column names"
+    }
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        args.process(registry, headers)?.run()
+    }
+}
+
+pub fn headers(
+    HeadersArgs {}: HeadersArgs,
+    RunnableContext { input, .. }: RunnableContext,
+) -> Result<OutputStream, ShellError> {
+    let stream = async_stream! {
+        let rows: Vec<Value> = input.collect().await;
+
+        if rows.len() < 1 {
+            yield Err(ShellError::untagged_runtime_error("Couldn't find headers, was the input a properly formatted, non-empty table?"));
+        }
+
+        //the headers are the first row in the table
+        let headers: Vec<String> = match &rows[0].value {
+            UntaggedValue::Row(d) => {
+                Ok(d.entries.iter().map(|(k, v)| {
+                    match v.as_string() {
+                        Ok(s) => s,
+                        Err(_) => { //If a cell that should contain a header name is empty, we name the column Column[index]
+                            match d.entries.get_full(k) {
+                                Some((index, _, _)) => format!("Column{}", index),
+                                None => "unknownColumn".to_string()
+                            }
+                        }
+                    }
+                }).collect())
+            }
+            _ => Err(ShellError::unexpected_eof("Could not get headers, is the table empty?", rows[0].tag.span))
+        }?;
+
+        //Each row is a dictionary with the headers as keys
+        for r in rows.iter().skip(1) {
+            match &r.value {
+                UntaggedValue::Row(d) => {
+                    let mut i = 0;
+                    let mut entries = IndexMap::new();
+                    for (_, v) in d.entries.iter() {
+                        entries.insert(headers[i].clone(), v.clone());
+                        i += 1;
+                    }
+                    yield Ok(ReturnSuccess::Value(UntaggedValue::Row(Dictionary{entries}).into_value(r.tag.clone())))
+                }
+                _ => yield Err(ShellError::unexpected_eof("Couldn't iterate through rows, was the input a properly formatted table?", r.tag.span))
+            }
+        }
+    };
+
+    Ok(stream.to_output_stream())
+}

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

@@ -76,6 +76,12 @@ impl PerItemCommand for Help {
                     return Ok(
                         get_help(&command.name(), &command.usage(), command.signature()).into(),
                     );
+                } else {
+                    return Err(ShellError::labeled_error(
+                        "Can't find command (use 'help commands' for full list)",
+                        "can't find command",
+                        tag,
+                    ));
                 }
                 let help = futures::stream::iter(help);
                 Ok(help.to_output_stream())
@@ -87,8 +93,8 @@ Here are some tips to help you get started.
   * help commands - list all available commands
   * help <command name> - display help about a particular command
 
-Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character. Each stage 
-in the pipeline works together to load, parse, and display information to you.
+Nushell works on the idea of a "pipeline". Pipelines are commands connected with the '|' character.
+Each stage in the pipeline works together to load, parse, and display information to you.
 
 [Examples]
 

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

@@ -30,7 +30,7 @@ impl WholeStreamCommand for Histogram {
                 "the name of the column to graph by",
             )
             .rest(
-                SyntaxShape::Member,
+                SyntaxShape::String,
                 "column name to give the histogram's frequency column",
             )
     }
@@ -53,7 +53,7 @@ pub fn histogram(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
         let Tagged { item: group_by, .. } = column_name.clone();
 

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

@@ -47,7 +47,7 @@ fn lines(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream,
     let mut leftover_string = String::new();
     let stream = async_stream! {
         loop {
-            match input.values.next().await {
+            match input.next().await {
                 Some(Value { value: UntaggedValue::Primitive(Primitive::String(st)), ..}) => {
                     let mut st = leftover_string.clone() + &st;
                     leftover.clear();

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

@@ -10,6 +10,7 @@ pub struct Ls;
 #[derive(Deserialize)]
 pub struct LsArgs {
     pub path: Option<Tagged<PathBuf>>,
+    pub all: bool,
     pub full: bool,
     #[serde(rename = "short-names")]
     pub short_names: bool,
@@ -29,6 +30,7 @@ impl PerItemCommand for Ls {
                 SyntaxShape::Pattern,
                 "a path to get the directory contents from",
             )
+            .switch("all", "also show hidden files", Some('a'))
             .switch(
                 "full",
                 "list all available columns for each entry",

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

@@ -46,7 +46,7 @@ pub fn map_max_by(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
 
         if values.is_empty() {

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

@@ -22,7 +22,7 @@ impl WholeStreamCommand for Nth {
         Signature::build("nth")
             .required(
                 "row number",
-                SyntaxShape::Any,
+                SyntaxShape::Int,
                 "the number of the row to return",
             )
             .rest(SyntaxShape::Any, "Optionally return more rows")
@@ -49,7 +49,6 @@ fn nth(
     RunnableContext { input, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = input
-        .values
         .enumerate()
         .map(move |(idx, item)| {
             let row_number = vec![row_number.clone()];

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

@@ -6,10 +6,6 @@ use nu_protocol::{
     CallInfo, ReturnSuccess, Signature, SyntaxShape, TaggedDictBuilder, UntaggedValue, Value,
 };
 
-use nom::{
-    bytes::complete::{tag, take_while},
-    IResult,
-};
 use regex::Regex;
 
 #[derive(Debug)]
@@ -18,32 +14,44 @@ enum ParseCommand {
     Column(String),
 }
 
-fn parse(input: &str) -> IResult<&str, Vec<ParseCommand>> {
+fn parse(input: &str) -> Vec<ParseCommand> {
     let mut output = vec![];
 
-    let mut loop_input = input;
+    //let mut loop_input = input;
+    let mut loop_input = input.chars();
     loop {
-        let (input, before) = take_while(|c| c != '{')(loop_input)?;
+        let mut before = String::new();
+
+        while let Some(c) = loop_input.next() {
+            if c == '{' {
+                break;
+            }
+            before.push(c);
+        }
+
         if !before.is_empty() {
             output.push(ParseCommand::Text(before.to_string()));
         }
-        if input != "" {
-            // Look for column as we're now at one
-            let (input, _) = tag("{")(input)?;
-            let (input, column) = take_while(|c| c != '}')(input)?;
-            let (input, _) = tag("}")(input)?;
+        // Look for column as we're now at one
+        let mut column = String::new();
 
-            output.push(ParseCommand::Column(column.to_string()));
-            loop_input = input;
-        } else {
-            loop_input = input;
+        while let Some(c) = loop_input.next() {
+            if c == '}' {
+                break;
+            }
+            column.push(c);
         }
-        if loop_input == "" {
+
+        if !column.is_empty() {
+            output.push(ParseCommand::Column(column.to_string()));
+        }
+
+        if before.is_empty() && column.is_empty() {
             break;
         }
     }
 
-    Ok((loop_input, output))
+    output
 }
 
 fn column_names(commands: &[ParseCommand]) -> Vec<String> {
@@ -103,16 +111,10 @@ impl PerItemCommand for Parse {
         //let value_tag = value.tag();
         let pattern = call_info.args.expect_nth(0)?.as_string()?;
 
-        let parse_pattern = parse(&pattern).map_err(|_| {
-            ShellError::labeled_error(
-                "Could not create parse pattern",
-                "could not create parse pattern",
-                &value.tag,
-            )
-        })?;
-        let parse_regex = build_regex(&parse_pattern.1);
+        let parse_pattern = parse(&pattern);
+        let parse_regex = build_regex(&parse_pattern);
 
-        let column_names = column_names(&parse_pattern.1);
+        let column_names = column_names(&parse_pattern);
         let regex = Regex::new(&parse_regex).map_err(|_| {
             ShellError::labeled_error("Could not parse regex", "could not parse regex", &value.tag)
         })?;

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

@@ -1,7 +1,6 @@
 use crate::commands::WholeStreamCommand;
 use crate::context::CommandRegistry;
 use crate::prelude::*;
-use futures_util::pin_mut;
 use nu_errors::ShellError;
 use nu_protocol::{
     ColumnPath, PathMember, Primitive, ReturnSuccess, ReturnValue, Signature, SyntaxShape,
@@ -44,7 +43,9 @@ impl WholeStreamCommand for Pick {
 
 fn pick(
     PickArgs { rest: mut fields }: PickArgs,
-    RunnableContext { input, name, .. }: RunnableContext,
+    RunnableContext {
+        mut input, name, ..
+    }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     if fields.is_empty() {
         return Err(ShellError::labeled_error(
@@ -64,13 +65,10 @@ fn pick(
         .collect::<Vec<ColumnPath>>();
 
     let stream = async_stream! {
-        let values = input.values;
-        pin_mut!(values);
-
         let mut empty = true;
         let mut bring_back: indexmap::IndexMap<String, Vec<Value>> = indexmap::IndexMap::new();
 
-        while let Some(value) = values.next().await {
+        while let Some(value) = input.next().await {
             for path in &column_paths {
                 let path_members_span = span_for_spanned_list(path.members().iter().map(|p| p.span));
 
@@ -80,7 +78,7 @@ fn pick(
                         "No data to fetch.",
                         format!("Couldn't pick column \"{}\"", column),
                         path_member_tried.span,
-                        format!("How about exploring it with \"get\"? Check the input is appropiate originating from here"),
+                        format!("How about exploring it with \"get\"? Check the input is appropriate originating from here"),
                         obj_source.tag.span)
                     }
 

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

@@ -3,7 +3,7 @@ use crate::prelude::*;
 use derive_new::new;
 use log::trace;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, ReturnValue, Scope, Signature, UntaggedValue, Value};
+use nu_protocol::{Primitive, ReturnSuccess, ReturnValue, Signature, UntaggedValue, Value};
 use serde::{self, Deserialize, Serialize};
 use std::io::prelude::*;
 use std::io::BufReader;
@@ -71,10 +71,13 @@ pub fn filter_plugin(
 ) -> Result<OutputStream, ShellError> {
     trace!("filter_plugin :: {}", path);
 
-    let args = args.evaluate_once_with_scope(
-        registry,
-        &Scope::it_value(UntaggedValue::string("$it").into_untagged_value()),
-    )?;
+    let scope = &args
+        .call_info
+        .scope
+        .clone()
+        .set_it(UntaggedValue::string("$it").into_untagged_value());
+
+    let args = args.evaluate_once_with_scope(registry, &scope)?;
 
     let mut child = std::process::Command::new(path)
         .stdin(std::process::Stdio::piped())
@@ -95,7 +98,7 @@ pub fn filter_plugin(
     trace!("filtering :: {:?}", call_info);
 
     let stream = bos
-        .chain(args.input.values)
+        .chain(args.input)
         .chain(eos)
         .map(move |v| match v {
             Value {
@@ -340,7 +343,7 @@ pub fn sink_plugin(
     let call_info = args.call_info.clone();
 
     let stream = async_stream! {
-        let input: Vec<Value> = args.input.values.collect().await;
+        let input: Vec<Value> = args.input.collect().await;
 
         let request = JsonRpc::new("sink", (call_info.clone(), input));
         let request_raw = serde_json::to_string(&request);

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

@@ -43,5 +43,5 @@ fn prepend(
 ) -> Result<OutputStream, ShellError> {
     let prepend = futures::stream::iter(vec![row]);
 
-    Ok(OutputStream::from_input(prepend.chain(input.values)))
+    Ok(prepend.chain(input).to_output_stream())
 }

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

@@ -50,7 +50,5 @@ fn range(
     let from = *from as usize;
     let to = *to as usize;
 
-    Ok(OutputStream::from_input(
-        input.values.skip(from).take(to - from + 1),
-    ))
+    Ok(input.skip(from).take(to - from + 1).to_output_stream())
 }

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

@@ -45,7 +45,7 @@ pub fn reduce_by(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
         if values.is_empty() {
             yield Err(ShellError::labeled_error(

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

@@ -18,7 +18,7 @@ impl WholeStreamCommand for Reject {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("reject").rest(SyntaxShape::Member, "the names of columns to remove")
+        Signature::build("reject").rest(SyntaxShape::String, "the names of columns to remove")
     }
 
     fn usage(&self) -> &str {
@@ -48,9 +48,7 @@ fn reject(
 
     let fields: Vec<_> = fields.iter().map(|f| f.item.clone()).collect();
 
-    let stream = input
-        .values
-        .map(move |item| reject_fields(&item, &fields, &item.tag));
+    let stream = input.map(move |item| reject_fields(&item, &fields, &item.tag));
 
     Ok(stream.from_input_stream())
 }

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

@@ -26,7 +26,7 @@ impl WholeStreamCommand for Rename {
                 "the name of the column to rename for",
             )
             .rest(
-                SyntaxShape::Member,
+                SyntaxShape::String,
                 "Additional column name(s) to rename for",
             )
     }
@@ -54,7 +54,6 @@ pub fn rename(
     let new_column_names = new_column_names.into_iter().flatten().collect::<Vec<_>>();
 
     let stream = input
-        .values
         .map(move |item| {
             let mut result = VecDeque::new();
 

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

@@ -32,7 +32,7 @@ fn reverse(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
     let args = args.evaluate_once(registry)?;
     let (input, _args) = args.parts();
 
-    let input = input.values.collect::<Vec<_>>();
+    let input = input.collect::<Vec<_>>();
 
     let output = input.map(move |mut vec| {
         vec.reverse();

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

@@ -10,8 +10,9 @@ pub struct Remove;
 
 #[derive(Deserialize)]
 pub struct RemoveArgs {
-    pub target: Tagged<PathBuf>,
+    pub rest: Vec<Tagged<PathBuf>>,
     pub recursive: Tagged<bool>,
+    #[allow(unused)]
     pub trash: Tagged<bool>,
 }
 
@@ -22,17 +23,17 @@ impl PerItemCommand for Remove {
 
     fn signature(&self) -> Signature {
         Signature::build("rm")
-            .required("path", SyntaxShape::Pattern, "the file path to remove")
             .switch(
                 "trash",
                 "use the platform's recycle bin instead of permanently deleting",
                 Some('t'),
             )
             .switch("recursive", "delete subdirectories recursively", Some('r'))
+            .rest(SyntaxShape::Pattern, "the file path(s) to remove")
     }
 
     fn usage(&self) -> &str {
-        "Remove a file"
+        "Remove file(s)"
     }
 
     fn run(

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

@@ -0,0 +1,108 @@
+use crate::commands::classified::block::run_block;
+use crate::prelude::*;
+
+use derive_new::new;
+use nu_errors::ShellError;
+use nu_protocol::{hir::Block, CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, Value};
+
+#[derive(new)]
+pub struct AliasCommand {
+    name: String,
+    args: Vec<String>,
+    block: Block,
+}
+
+impl PerItemCommand for AliasCommand {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn signature(&self) -> Signature {
+        let mut alias = Signature::build(&self.name);
+
+        for arg in &self.args {
+            alias = alias.optional(arg, SyntaxShape::Any, "");
+        }
+
+        alias
+    }
+
+    fn usage(&self) -> &str {
+        ""
+    }
+
+    fn run(
+        &self,
+        call_info: &CallInfo,
+        registry: &CommandRegistry,
+        raw_args: &RawCommandArgs,
+        input: Value,
+    ) -> Result<OutputStream, ShellError> {
+        let tag = call_info.name_tag.clone();
+        let call_info = call_info.clone();
+        let registry = registry.clone();
+        let raw_args = raw_args.clone();
+        let block = self.block.clone();
+
+        let mut scope = Scope::it_value(input.clone());
+        if let Some(positional) = &call_info.args.positional {
+            for (pos, arg) in positional.iter().enumerate() {
+                scope = scope.set_var(self.args[pos].to_string(), arg.clone());
+            }
+        }
+
+        let stream = async_stream! {
+            let mut context = Context::from_raw(&raw_args, &registry);
+
+            let input_clone = Ok(input.clone());
+            let input_stream = futures::stream::once(async { input_clone }).boxed().to_input_stream();
+
+            let result = run_block(
+                &block,
+                &mut context,
+                input_stream,
+                &scope
+            ).await;
+
+            match result {
+                Ok(stream) if stream.is_empty() => {
+                    yield Err(ShellError::labeled_error(
+                        "Expected a block",
+                        "alias needs a block",
+                        tag,
+                    ));
+                }
+                Ok(mut stream) => {
+                    // We collect first to ensure errors are put into the context
+                    while let Some(result) = stream.next().await {
+                        yield Ok(ReturnSuccess::Value(result));
+                    }
+
+                    let errors = context.get_errors();
+                    if let Some(x) = errors.first() {
+                        //yield Err(error.clone());
+                        yield Err(ShellError::labeled_error_with_secondary(
+                            "Alias failed to run",
+                            "alias failed to run",
+                            tag.clone(),
+                            x.to_string(),
+                            tag
+                        ));
+                    }
+                }
+                Err(e) => {
+                    //yield Err(e);
+                    yield Err(ShellError::labeled_error_with_secondary(
+                        "Alias failed to run",
+                        "alias failed to run",
+                        tag.clone(),
+                        e.to_string(),
+                        tag
+                    ));
+                }
+            }
+        };
+
+        Ok(stream.to_output_stream())
+    }
+}

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

@@ -0,0 +1,122 @@
+use crate::commands::classified::external;
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+
+use derive_new::new;
+use parking_lot::Mutex;
+
+use nu_errors::ShellError;
+use nu_protocol::hir::{Expression, ExternalArgs, ExternalCommand, Literal, SpannedExpression};
+use nu_protocol::{ReturnSuccess, Signature, SyntaxShape};
+
+#[derive(Deserialize)]
+pub struct RunExternalArgs {}
+
+#[derive(new)]
+pub struct RunExternalCommand;
+
+fn spanned_expression_to_string(expr: SpannedExpression) -> String {
+    if let SpannedExpression {
+        expr: Expression::Literal(Literal::String(s)),
+        ..
+    } = expr
+    {
+        s
+    } else {
+        "notacommand!!!".to_string()
+    }
+}
+
+impl WholeStreamCommand for RunExternalCommand {
+    fn name(&self) -> &str {
+        "run_external"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name()).rest(SyntaxShape::Any, "external command arguments")
+    }
+
+    fn usage(&self) -> &str {
+        ""
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        let positionals = args.call_info.args.positional.ok_or_else(|| {
+            ShellError::untagged_runtime_error("positional arguments unexpectedly empty")
+        })?;
+
+        let mut positionals = positionals.into_iter();
+
+        let name = positionals
+            .next()
+            .map(spanned_expression_to_string)
+            .ok_or_else(|| {
+                ShellError::untagged_runtime_error(
+                    "run_external unexpectedly missing external name positional arg",
+                )
+            })?;
+
+        let command = ExternalCommand {
+            name,
+            name_tag: args.call_info.name_tag.clone(),
+            args: ExternalArgs {
+                list: positionals.collect(),
+                span: args.call_info.args.span,
+            },
+        };
+
+        let mut external_context;
+        #[cfg(windows)]
+        {
+            external_context = Context {
+                registry: registry.clone(),
+                host: args.host.clone(),
+                shell_manager: args.shell_manager.clone(),
+                ctrl_c: args.ctrl_c.clone(),
+                current_errors: Arc::new(Mutex::new(vec![])),
+                windows_drives_previous_cwd: Arc::new(Mutex::new(std::collections::HashMap::new())),
+            };
+        }
+        #[cfg(not(windows))]
+        {
+            external_context = Context {
+                registry: registry.clone(),
+                host: args.host.clone(),
+                shell_manager: args.shell_manager.clone(),
+                ctrl_c: args.ctrl_c.clone(),
+                current_errors: Arc::new(Mutex::new(vec![])),
+            };
+        }
+        let scope = args.call_info.scope.clone();
+
+        let is_last = args.call_info.args.is_last;
+        let input = args.input;
+        let stream = async_stream! {
+            let result = external::run_external_command(
+                command,
+                &mut external_context,
+                input,
+                &scope,
+                is_last,
+            ).await;
+
+            match result {
+                Ok(mut stream) => {
+                    while let Some(value) = stream.next().await {
+                        yield Ok(ReturnSuccess::Value(value));
+                    }
+                },
+                Err(e) => {
+                    yield Err(e);
+                },
+                _ => {}
+            }
+        };
+
+        Ok(stream.to_output_stream())
+    }
+}

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

@@ -1,7 +1,7 @@
 use crate::commands::{UnevaluatedCallInfo, WholeStreamCommand};
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{Primitive, ReturnSuccess, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{Primitive, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue, Value};
 use nu_source::Tagged;
 use std::path::{Path, PathBuf};
 
@@ -168,7 +168,7 @@ fn save(
         shell_manager,
         host,
         ctrl_c,
-        commands: registry,
+        registry,
         ..
     }: RunnableContext,
     raw_args: RawCommandArgs,
@@ -177,7 +177,7 @@ fn save(
     let name_tag = name.clone();
 
     let stream = async_stream! {
-        let input: Vec<Value> = input.values.collect().await;
+        let input: Vec<Value> = input.collect().await;
         if path.is_none() {
             // If there is no filename, check the metadata for the anchor filename
             if input.len() > 0 {
@@ -228,14 +228,15 @@ fn save(
                             ctrl_c,
                             shell_manager,
                             call_info: UnevaluatedCallInfo {
-                                args: nu_parser::hir::Call {
+                                args: nu_protocol::hir::Call {
                                     head: raw_args.call_info.args.head,
                                     positional: None,
                                     named: None,
-                                    span: Span::unknown()
+                                    span: Span::unknown(),
+                                    is_last: false,
                                 },
-                                source: raw_args.call_info.source,
                                 name_tag: raw_args.call_info.name_tag,
+                                scope: Scope::empty(), // FIXME?
                             }
                         };
                         let mut result = converter.run(new_args.with_input(input), &registry);

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

@@ -36,9 +36,9 @@ fn shells(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream
         let mut dict = TaggedDictBuilder::new(&tag);
 
         if index == (*args.shell_manager.current_shell).load(Ordering::SeqCst) {
-            dict.insert_untagged(" ", "X".to_string());
+            dict.insert_untagged("active", "X".to_string());
         } else {
-            dict.insert_untagged(" ", " ".to_string());
+            dict.insert_untagged("active", " ".to_string());
         }
         dict.insert_untagged("name", shell.name());
         dict.insert_untagged("path", shell.path());

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

@@ -48,7 +48,7 @@ fn shuffle(
     RunnableContext { input, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let mut values: Vec<Value> = input.values.collect().await;
+        let mut values: Vec<Value> = input.collect().await;
 
         let out = if let Some(n) = limit {
             let (shuffled, _) = values.partial_shuffle(&mut thread_rng(), *n as usize);

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

@@ -33,7 +33,6 @@ fn size(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream,
     let name_span = tag.span;
 
     Ok(input
-        .values
         .map(move |v| {
             if let Ok(s) = v.as_string() {
                 ReturnSuccess::value(count(&s, &v.tag))

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

@@ -41,7 +41,5 @@ fn skip(SkipArgs { rows }: SkipArgs, context: RunnableContext) -> Result<OutputS
         1
     };
 
-    Ok(OutputStream::from_input(
-        context.input.values.skip(rows_desired),
-    ))
+    Ok(OutputStream::from_input(context.input.skip(rows_desired)))
 }

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

@@ -1,16 +1,12 @@
 use crate::commands::WholeStreamCommand;
+use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use log::trace;
 use nu_errors::ShellError;
-use nu_protocol::{Evaluate, Scope, Signature, SyntaxShape};
+use nu_protocol::{hir::ClassifiedCommand, Scope, Signature, SyntaxShape, UntaggedValue, Value};
 
 pub struct SkipWhile;
 
-#[derive(Deserialize)]
-pub struct SkipWhileArgs {
-    condition: Evaluate,
-}
-
 impl WholeStreamCommand for SkipWhile {
     fn name(&self) -> &str {
         "skip-while"
@@ -20,7 +16,7 @@ impl WholeStreamCommand for SkipWhile {
         Signature::build("skip-while")
             .required(
                 "condition",
-                SyntaxShape::Block,
+                SyntaxShape::Math,
                 "the condition that must be met to continue skipping",
             )
             .filter()
@@ -35,26 +31,66 @@ impl WholeStreamCommand for SkipWhile {
         args: CommandArgs,
         registry: &CommandRegistry,
     ) -> Result<OutputStream, ShellError> {
-        args.process(registry, skip_while)?.run()
-    }
-}
+        let registry = registry.clone();
+        let call_info = args.evaluate_once(&registry)?;
 
-pub fn skip_while(
-    SkipWhileArgs { condition }: SkipWhileArgs,
-    RunnableContext { input, .. }: RunnableContext,
-) -> Result<OutputStream, ShellError> {
-    let objects = input.values.skip_while(move |item| {
-        trace!("ITEM = {:?}", item);
-        let result = condition.invoke(&Scope::new(item.clone()));
-        trace!("RESULT = {:?}", result);
+        let block = call_info.args.expect_nth(0)?.clone();
 
-        let return_value = match result {
-            Ok(ref v) if v.is_true() => true,
-            _ => false,
+        let condition = match block {
+            Value {
+                value: UntaggedValue::Block(block),
+                tag,
+            } => {
+                if block.block.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a condition",
+                        "expected a condition",
+                        tag,
+                    ));
+                }
+                match block.block[0].list.get(0) {
+                    Some(item) => match item {
+                        ClassifiedCommand::Expr(expr) => expr.clone(),
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Expected a condition",
+                                "expected a condition",
+                                tag,
+                            ))
+                        }
+                    },
+                    None => {
+                        return Err(ShellError::labeled_error(
+                            "Expected a condition",
+                            "expected a condition",
+                            tag,
+                        ));
+                    }
+                }
+            }
+            Value { tag, .. } => {
+                return Err(ShellError::labeled_error(
+                    "Expected a condition",
+                    "expected a condition",
+                    tag,
+                ));
+            }
         };
 
-        futures::future::ready(return_value)
-    });
+        let objects = call_info.input.skip_while(move |item| {
+            let condition = condition.clone();
+            trace!("ITEM = {:?}", item);
+            let result = evaluate_baseline_expr(&*condition, &registry, &Scope::new(item.clone()));
+            trace!("RESULT = {:?}", result);
 
-    Ok(objects.from_input_stream())
+            let return_value = match result {
+                Ok(ref v) if v.is_true() => true,
+                _ => false,
+            };
+
+            futures::future::ready(return_value)
+        });
+
+        Ok(objects.from_input_stream())
+    }
 }

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

@@ -44,7 +44,7 @@ pub fn split_by(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
         if values.len() > 1 || values.is_empty() {
             yield Err(ShellError::labeled_error(

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

@@ -30,7 +30,7 @@ impl WholeStreamCommand for SplitColumn {
                 "the character that denotes what separates columns",
             )
             .switch("collapse-empty", "remove empty columns", Some('c'))
-            .rest(SyntaxShape::Member, "column names to give the new columns")
+            .rest(SyntaxShape::String, "column names to give the new columns")
     }
 
     fn usage(&self) -> &str {
@@ -57,7 +57,6 @@ fn split_column(
     let name_span = name.span;
 
     Ok(input
-        .values
         .map(move |v| {
             if let Ok(s) = v.as_string() {
                 let splitter = separator.replace("\\n", "\n");

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

@@ -43,7 +43,6 @@ fn split_row(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = input
-        .values
         .map(move |v| {
             if let Ok(s) = v.as_string() {
                 let splitter = separator.item.replace("\\n", "\n");

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

@@ -0,0 +1,54 @@
+use crate::commands::WholeStreamCommand;
+use crate::prelude::*;
+use crate::utils::data_processing::{reducer_for, Reduce};
+use nu_errors::ShellError;
+use nu_protocol::{ReturnSuccess, ReturnValue, Signature, Value};
+use num_traits::identities::Zero;
+
+pub struct Sum;
+
+impl WholeStreamCommand for Sum {
+    fn name(&self) -> &str {
+        "sum"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("sum")
+    }
+
+    fn usage(&self) -> &str {
+        "Sums the values."
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        sum(RunnableContext {
+            input: args.input,
+            registry: registry.clone(),
+            shell_manager: args.shell_manager,
+            host: args.host,
+            ctrl_c: args.ctrl_c,
+            name: args.call_info.name_tag,
+        })
+    }
+}
+
+fn sum(RunnableContext { mut input, .. }: RunnableContext) -> Result<OutputStream, ShellError> {
+    let stream = async_stream! {
+        let mut values = input.drain_vec().await;
+
+        let action = reducer_for(Reduce::Sum);
+
+        match action(Value::zero(), values) {
+            Ok(total) => yield ReturnSuccess::value(total),
+            Err(err) => yield Err(err),
+        }
+    };
+
+    let stream: BoxStream<'static, ReturnValue> = stream.boxed();
+
+    Ok(stream.to_output_stream())
+}

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

@@ -69,7 +69,7 @@ fn t_sort_by(
     RunnableContext { input, name, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     Ok(OutputStream::new(async_stream! {
-        let values: Vec<Value> = input.values.collect().await;
+        let values: Vec<Value> = input.collect().await;
 
         let column_grouped_by_name = if let Some(grouped_by) = group_by {
             Some(grouped_by.item().clone())

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

@@ -30,7 +30,6 @@ impl WholeStreamCommand for Tags {
 fn tags(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
     Ok(args
         .input
-        .values
         .map(move |v| {
             let mut tags = TaggedDictBuilder::new(v.tag());
             {

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

@@ -266,7 +266,7 @@ fn to_bson(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
     let name_span = name_tag.span;
 
     let stream = async_stream! {
-        let input: Vec<Value> = args.input.values.collect().await;
+        let input: Vec<Value> = args.input.collect().await;
 
         let to_process_input = if input.len() > 1 {
             let tag = input[0].tag.clone();

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

@@ -140,6 +140,7 @@ fn to_string_tagged_value(v: &Value) -> Result<String, ShellError> {
         | UntaggedValue::Primitive(Primitive::Path(_))
         | UntaggedValue::Primitive(Primitive::Int(_)) => as_string(v),
         UntaggedValue::Primitive(Primitive::Date(d)) => Ok(d.to_string()),
+        UntaggedValue::Primitive(Primitive::Nothing) => Ok(String::new()),
         UntaggedValue::Table(_) => Ok(String::from("[Table]")),
         UntaggedValue::Row(_) => Ok(String::from("[Row]")),
         _ => Err(ShellError::labeled_error(
@@ -174,7 +175,7 @@ pub fn to_delimited_data(
     let name_span = name_tag.span;
 
     let stream = async_stream! {
-         let input: Vec<Value> = input.values.collect().await;
+         let input: Vec<Value> = input.collect().await;
 
          let to_process_input = if input.len() > 1 {
              let tag = input[0].tag.clone();

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

@@ -0,0 +1,121 @@
+use crate::commands::WholeStreamCommand;
+use crate::data::value::format_leaf;
+use crate::prelude::*;
+use futures::StreamExt;
+use nu_errors::ShellError;
+use nu_protocol::{Primitive, ReturnSuccess, Signature, UntaggedValue, Value};
+use nu_source::AnchorLocation;
+
+pub struct ToHTML;
+
+impl WholeStreamCommand for ToHTML {
+    fn name(&self) -> &str {
+        "to-html"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("to-html")
+    }
+
+    fn usage(&self) -> &str {
+        "Convert table into simple HTML"
+    }
+
+    fn run(
+        &self,
+        args: CommandArgs,
+        registry: &CommandRegistry,
+    ) -> Result<OutputStream, ShellError> {
+        to_html(args, registry)
+    }
+}
+
+fn to_html(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
+    let args = args.evaluate_once(registry)?;
+    let name_tag = args.name_tag();
+    //let name_span = name_tag.span;
+    let stream = async_stream! {
+        let input: Vec<Value> = args.input.collect().await;
+        let headers = nu_protocol::merge_descriptors(&input);
+        let mut output_string = "<html><body>".to_string();
+
+        if !headers.is_empty() && (headers.len() > 1 || headers[0] != "<value>") {
+            output_string.push_str("<table>");
+
+            output_string.push_str("<tr>");
+            for header in &headers {
+                output_string.push_str("<th>");
+                output_string.push_str(&htmlescape::encode_minimal(&header));
+                output_string.push_str("</th>");
+            }
+            output_string.push_str("</tr>");
+        }
+
+        for row in input {
+            match row.value {
+                UntaggedValue::Primitive(Primitive::Binary(b)) => {
+                    // This might be a bit much, but it's fun :)
+                    match row.tag.anchor {
+                        Some(AnchorLocation::Url(f)) |
+                        Some(AnchorLocation::File(f)) => {
+                            let extension = f.split('.').last().map(String::from);
+                            match extension {
+                                Some(s) if ["png", "jpg", "bmp", "gif", "tiff", "jpeg"].contains(&s.to_lowercase().as_str()) => {
+                                    output_string.push_str("<img src=\"data:image/");
+                                    output_string.push_str(&s);
+                                    output_string.push_str(";base64,");
+                                    output_string.push_str(&base64::encode(&b));
+                                    output_string.push_str("\">");
+                                }
+                                _ => {}
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+                UntaggedValue::Primitive(Primitive::String(ref b)) => {
+                    // This might be a bit much, but it's fun :)
+                    match row.tag.anchor {
+                        Some(AnchorLocation::Url(f)) |
+                        Some(AnchorLocation::File(f)) => {
+                            let extension = f.split('.').last().map(String::from);
+                            match extension {
+                                Some(s) if s.to_lowercase() == "svg" => {
+                                    output_string.push_str("<img src=\"data:image/svg+xml;base64,");
+                                    output_string.push_str(&base64::encode(&b.as_bytes()));
+                                    output_string.push_str("\">");
+                                    continue;
+                                }
+                                _ => {}
+                            }
+                        }
+                        _ => {}
+                    }
+                    output_string.push_str(&(htmlescape::encode_minimal(&format_leaf(&row.value).plain_string(100_000)).replace("\n", "<br>")));
+                }
+                UntaggedValue::Row(row) => {
+                    output_string.push_str("<tr>");
+                    for header in &headers {
+                        let data = row.get_data(header);
+                        output_string.push_str("<td>");
+                        output_string.push_str(&format_leaf(data.borrow()).plain_string(100_000));
+                        output_string.push_str("</td>");
+                    }
+                    output_string.push_str("</tr>");
+                }
+                p => {
+                    output_string.push_str(&(htmlescape::encode_minimal(&format_leaf(&p).plain_string(100_000)).replace("\n", "<br>")));
+                }
+            }
+        }
+
+        if !headers.is_empty() && (headers.len() > 1 || headers[0] != "<value>") {
+            output_string.push_str("</table>");
+        }
+        output_string.push_str("</body></html>");
+
+        yield ReturnSuccess::value(UntaggedValue::string(output_string).into_value(name_tag));
+    };
+
+    Ok(stream.to_output_stream())
+}

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

@@ -136,7 +136,7 @@ fn to_json(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
     let name_tag = args.name_tag();
     let name_span = name_tag.span;
     let stream = async_stream! {
-        let input: Vec<Value> = args.input.values.collect().await;
+        let input: Vec<Value> = args.input.collect().await;
 
         let to_process_input = if input.len() > 1 {
             let tag = input[0].tag.clone();

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

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

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

@@ -205,7 +205,7 @@ fn to_sqlite(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStre
     let args = args.evaluate_once(registry)?;
     let name_tag = args.name_tag();
     let stream = async_stream! {
-        let input: Vec<Value> = args.input.values.collect().await;
+        let input: Vec<Value> = args.input.collect().await;
 
         match sqlite_input_stream_to_bytes(input) {
             Ok(out) => yield ReturnSuccess::value(out),

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

@@ -98,7 +98,7 @@ fn to_toml(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
     let name_tag = args.name_tag();
     let name_span = name_tag.span;
     let stream = async_stream! {
-        let input: Vec<Value> = args.input.values.collect().await;
+        let input: Vec<Value> = args.input.collect().await;
 
         let to_process_input = if input.len() > 1 {
             let tag = input[0].tag.clone();

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

@@ -33,7 +33,7 @@ fn to_url(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream,
     let input = args.input;
 
     let stream = async_stream! {
-        let input: Vec<Value> = input.values.collect().await;
+        let input: Vec<Value> = input.collect().await;
 
         for value in input {
             match value {

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

@@ -130,7 +130,7 @@ fn to_yaml(args: CommandArgs, registry: &CommandRegistry) -> Result<OutputStream
     let name_span = name_tag.span;
 
     let stream = async_stream! {
-        let input: Vec<Value> = args.input.values.collect().await;
+        let input: Vec<Value> = args.input.collect().await;
 
         let to_process_input = if input.len() > 1 {
             let tag = input[0].tag.clone();

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

@@ -29,10 +29,8 @@ impl WholeStreamCommand for Trim {
 }
 
 fn trim(args: CommandArgs, _registry: &CommandRegistry) -> Result<OutputStream, ShellError> {
-    let input = args.input;
-
-    Ok(input
-        .values
+    Ok(args
+        .input
         .map(move |v| {
             let string = String::extract(&v)?;
             ReturnSuccess::value(UntaggedValue::string(string.trim()).into_value(v.tag()))

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

@@ -37,7 +37,7 @@ fn uniq(
     RunnableContext { input, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let uniq_values: IndexSet<_> = input.values.collect().await;
+        let uniq_values: IndexSet<_> = input.collect().await;
 
         for item in uniq_values.iter().map(|row| ReturnSuccess::value(row.clone())) {
             yield item;

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

@@ -1,8 +1,6 @@
 use crate::commands::WholeStreamCommand;
-
 use crate::prelude::*;
-use futures::StreamExt;
-use futures_util::pin_mut;
+
 use nu_errors::ShellError;
 use nu_protocol::{ReturnSuccess, ReturnValue, Signature, UntaggedValue};
 
@@ -34,14 +32,11 @@ impl WholeStreamCommand for What {
 }
 
 pub fn what(
-    WhatArgs {}: WhatArgs,
-    RunnableContext { input, .. }: RunnableContext,
+    _: WhatArgs,
+    RunnableContext { mut input, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let stream = async_stream! {
-        let values = input.values;
-        pin_mut!(values);
-
-        while let Some(row) = values.next().await {
+        while let Some(row) = input.next().await {
             let name = value::format_type(&row, 100);
             yield ReturnSuccess::value(UntaggedValue::string(name).into_value(Tag::unknown_anchor(row.tag.span)));
         }

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

@@ -1,8 +1,12 @@
 use crate::commands::PerItemCommand;
 use crate::context::CommandRegistry;
+use crate::evaluate::evaluate_baseline_expr;
 use crate::prelude::*;
 use nu_errors::ShellError;
-use nu_protocol::{CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue, Value};
+use nu_protocol::{
+    hir::ClassifiedCommand, CallInfo, ReturnSuccess, Scope, Signature, SyntaxShape, UntaggedValue,
+    Value,
+};
 
 pub struct Where;
 
@@ -14,7 +18,7 @@ impl PerItemCommand for Where {
     fn signature(&self) -> Signature {
         Signature::build("where").required(
             "condition",
-            SyntaxShape::Block,
+            SyntaxShape::Math,
             "the condition that must match",
         )
     }
@@ -26,37 +30,67 @@ impl PerItemCommand for Where {
     fn run(
         &self,
         call_info: &CallInfo,
-        _registry: &CommandRegistry,
+        registry: &CommandRegistry,
         _raw_args: &RawCommandArgs,
         input: Value,
     ) -> Result<OutputStream, ShellError> {
-        let condition = call_info.args.expect_nth(0)?;
-        let stream = match condition {
+        let block = call_info.args.expect_nth(0)?.clone();
+
+        let condition = match block {
             Value {
                 value: UntaggedValue::Block(block),
-                ..
+                tag,
             } => {
-                let result = block.invoke(&Scope::new(input.clone()));
-                match result {
-                    Ok(v) => {
-                        if v.is_true() {
-                            VecDeque::from(vec![Ok(ReturnSuccess::Value(input))])
-                        } else {
-                            VecDeque::new()
+                if block.block.len() != 1 {
+                    return Err(ShellError::labeled_error(
+                        "Expected a condition",
+                        "expected a condition",
+                        tag,
+                    ));
+                }
+                match block.block[0].list.get(0) {
+                    Some(item) => match item {
+                        ClassifiedCommand::Expr(expr) => expr.clone(),
+                        _ => {
+                            return Err(ShellError::labeled_error(
+                                "Expected a condition",
+                                "expected a condition",
+                                tag,
+                            ))
                         }
+                    },
+                    None => {
+                        return Err(ShellError::labeled_error(
+                            "Expected a condition",
+                            "expected a condition",
+                            tag,
+                        ));
                     }
-                    Err(e) => return Err(e),
                 }
             }
             Value { tag, .. } => {
                 return Err(ShellError::labeled_error(
                     "Expected a condition",
-                    "where needs a condition",
+                    "expected a condition",
                     tag,
-                ))
+                ));
             }
         };
 
+        //FIXME: should we use the scope that's brought in as well?
+        let condition = evaluate_baseline_expr(&condition, registry, &Scope::new(input.clone()))?;
+
+        let stream = match condition.as_bool() {
+            Ok(b) => {
+                if b {
+                    VecDeque::from(vec![Ok(ReturnSuccess::Value(input))])
+                } else {
+                    VecDeque::new()
+                }
+            }
+            Err(e) => return Err(e),
+        };
+
         Ok(stream.into())
     }
 }

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

@@ -78,7 +78,7 @@ struct WhichArgs {
 
 fn which(
     WhichArgs { application, all }: WhichArgs,
-    RunnableContext { commands, .. }: RunnableContext,
+    RunnableContext { registry, .. }: RunnableContext,
 ) -> Result<OutputStream, ShellError> {
     let external = application.starts_with('^');
     let item = if external {
@@ -87,66 +87,24 @@ fn which(
         application.item.clone()
     };
 
-    if all {
-        let stream = async_stream! {
-            if external {
-                if let Ok(Some(path)) = ichwh::which(&item).await {
-                    yield ReturnSuccess::value(entry_path!(item, path.into(), application.tag.clone()));
-                }
-            }
-
-            let builtin = commands.has(&item);
+    let stream = async_stream! {
+        if !external {
+            let builtin = registry.has(&item);
             if builtin {
                 yield ReturnSuccess::value(entry_builtin!(item, application.tag.clone()));
             }
+        }
 
-            if let Ok(paths) = ichwh::which_all(&item).await {
-                if !builtin && paths.len() == 0 {
-                    yield Err(ShellError::labeled_error(
-                        "Binary not found for argument, and argument is not a builtin",
-                        "not found",
-                        &application.tag,
-                    ));
-                } else {
-                    for path in paths {
-                        yield ReturnSuccess::value(entry_path!(item, path.into(), application.tag.clone()));
-                    }
-                }
-            } else {
-                yield Err(ShellError::labeled_error(
-                    "Error trying to find binary for argument",
-                    "error",
-                    &application.tag,
-                ));
+        if let Ok(paths) = ichwh::which_all(&item).await {
+            for path in paths {
+                yield ReturnSuccess::value(entry_path!(item, path.into(), application.tag.clone()));
             }
-        };
+        }
+    };
 
+    if all {
         Ok(stream.to_output_stream())
     } else {
-        let stream = async_stream! {
-            if external {
-                if let Ok(Some(path)) = ichwh::which(&item).await {
-                    yield ReturnSuccess::value(entry_path!(item, path.into(), application.tag.clone()));
-                }
-            } else if commands.has(&item) {
-                yield ReturnSuccess::value(entry_builtin!(item, application.tag.clone()));
-            } else {
-                match ichwh::which(&item).await {
-                    Ok(Some(path)) => yield ReturnSuccess::value(entry_path!(item, path.into(), application.tag.clone())),
-                    Ok(None) => yield Err(ShellError::labeled_error(
-                            "Binary not found for argument, and argument is not a builtin",
-                            "not found",
-                            &application.tag,
-                    )),
-                    Err(_) => yield Err(ShellError::labeled_error(
-                            "Error trying to find binary for argument",
-                            "error",
-                            &application.tag,
-                    )),
-                }
-            }
-        };
-
-        Ok(stream.to_output_stream())
+        Ok(stream.take(1).to_output_stream())
     }
 }

crates/nu-cli/src/context.rs

@@ -1,11 +1,13 @@
-use crate::commands::{command::CommandArgs, Command, UnevaluatedCallInfo};
+use crate::commands::{
+    command::CommandArgs, command::RawCommandArgs, Command, UnevaluatedCallInfo,
+};
 use crate::env::host::Host;
 use crate::shell::shell_manager::ShellManager;
 use crate::stream::{InputStream, OutputStream};
 use indexmap::IndexMap;
 use nu_errors::ShellError;
-use nu_parser::{hir, hir::syntax_shape::ExpandContext, hir::syntax_shape::SignatureRegistry};
-use nu_protocol::Signature;
+use nu_parser::SignatureRegistry;
+use nu_protocol::{hir, Scope, Signature};
 use nu_source::{Tag, Text};
 use parking_lot::Mutex;
 use std::error::Error;
@@ -40,12 +42,6 @@ impl CommandRegistry {
 }
 
 impl CommandRegistry {
-    pub(crate) fn empty() -> CommandRegistry {
-        CommandRegistry {
-            registry: Arc::new(Mutex::new(IndexMap::default())),
-        }
-    }
-
     pub(crate) fn get_command(&self, name: &str) -> Option<Arc<Command>> {
         let registry = self.registry.lock();
 
@@ -82,6 +78,9 @@ pub struct Context {
     pub current_errors: Arc<Mutex<Vec<ShellError>>>,
     pub ctrl_c: Arc<AtomicBool>,
     pub(crate) shell_manager: ShellManager,
+
+    #[cfg(windows)]
+    pub windows_drives_previous_cwd: Arc<Mutex<std::collections::HashMap<String, String>>>,
 }
 
 impl Context {
@@ -89,34 +88,73 @@ impl Context {
         &self.registry
     }
 
-    pub(crate) fn expand_context<'context>(
-        &'context self,
-        source: &'context Text,
-    ) -> ExpandContext {
-        ExpandContext::new(
-            Box::new(self.registry.clone()),
-            source,
-            self.shell_manager.homedir(),
-        )
+    pub(crate) fn from_raw(raw_args: &RawCommandArgs, registry: &CommandRegistry) -> Context {
+        #[cfg(windows)]
+        {
+            Context {
+                registry: registry.clone(),
+                host: raw_args.host.clone(),
+                current_errors: Arc::new(Mutex::new(vec![])),
+                ctrl_c: raw_args.ctrl_c.clone(),
+                shell_manager: raw_args.shell_manager.clone(),
+                windows_drives_previous_cwd: Arc::new(Mutex::new(std::collections::HashMap::new())),
+            }
+        }
+        #[cfg(not(windows))]
+        {
+            Context {
+                registry: registry.clone(),
+                host: raw_args.host.clone(),
+                current_errors: Arc::new(Mutex::new(vec![])),
+                ctrl_c: raw_args.ctrl_c.clone(),
+                shell_manager: raw_args.shell_manager.clone(),
+            }
+        }
     }
 
     pub(crate) fn basic() -> Result<Context, Box<dyn Error>> {
         let registry = CommandRegistry::new();
-        Ok(Context {
-            registry: registry.clone(),
-            host: Arc::new(parking_lot::Mutex::new(Box::new(
-                crate::env::host::BasicHost,
-            ))),
-            current_errors: Arc::new(Mutex::new(vec![])),
-            ctrl_c: Arc::new(AtomicBool::new(false)),
-            shell_manager: ShellManager::basic(registry)?,
-        })
+
+        #[cfg(windows)]
+        {
+            Ok(Context {
+                registry: registry.clone(),
+                host: Arc::new(parking_lot::Mutex::new(Box::new(
+                    crate::env::host::BasicHost,
+                ))),
+                current_errors: Arc::new(Mutex::new(vec![])),
+                ctrl_c: Arc::new(AtomicBool::new(false)),
+                shell_manager: ShellManager::basic(registry)?,
+                windows_drives_previous_cwd: Arc::new(Mutex::new(std::collections::HashMap::new())),
+            })
+        }
+
+        #[cfg(not(windows))]
+        {
+            Ok(Context {
+                registry: registry.clone(),
+                host: Arc::new(parking_lot::Mutex::new(Box::new(
+                    crate::env::host::BasicHost,
+                ))),
+                current_errors: Arc::new(Mutex::new(vec![])),
+                ctrl_c: Arc::new(AtomicBool::new(false)),
+                shell_manager: ShellManager::basic(registry)?,
+            })
+        }
     }
 
     pub(crate) fn error(&mut self, error: ShellError) {
         self.with_errors(|errors| errors.push(error))
     }
 
+    pub(crate) fn clear_errors(&mut self) {
+        self.current_errors.lock().clear()
+    }
+
+    pub(crate) fn get_errors(&self) -> Vec<ShellError> {
+        self.current_errors.lock().clone()
+    }
+
     pub(crate) fn maybe_print_errors(&mut self, source: Text) -> bool {
         let errors = self.current_errors.clone();
         let mut errors = errors.lock();
@@ -166,18 +204,18 @@ impl Context {
         command: Arc<Command>,
         name_tag: Tag,
         args: hir::Call,
-        source: &Text,
+        scope: &Scope,
         input: InputStream,
     ) -> OutputStream {
-        let command_args = self.command_args(args, input, source, name_tag);
+        let command_args = self.command_args(args, input, name_tag, scope);
         command.run(command_args, self.registry())
     }
 
-    fn call_info(&self, args: hir::Call, source: &Text, name_tag: Tag) -> UnevaluatedCallInfo {
+    fn call_info(&self, args: hir::Call, name_tag: Tag, scope: &Scope) -> UnevaluatedCallInfo {
         UnevaluatedCallInfo {
             args,
-            source: source.clone(),
             name_tag,
+            scope: scope.clone(),
         }
     }
 
@@ -185,14 +223,14 @@ impl Context {
         &self,
         args: hir::Call,
         input: InputStream,
-        source: &Text,
         name_tag: Tag,
+        scope: &Scope,
     ) -> CommandArgs {
         CommandArgs {
             host: self.host.clone(),
             ctrl_c: self.ctrl_c.clone(),
             shell_manager: self.shell_manager.clone(),
-            call_info: self.call_info(args, source, name_tag),
+            call_info: self.call_info(args, name_tag, scope),
             input,
         }
     }

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

@@ -1,18 +1,13 @@
 pub(crate) mod shape;
 
-use crate::context::CommandRegistry;
-use crate::evaluate::evaluate_baseline_expr;
 use bigdecimal::BigDecimal;
 use chrono::{DateTime, Utc};
 use derive_new::new;
-use log::trace;
 use nu_errors::ShellError;
-use nu_parser::{hir, CompareOperator};
 use nu_protocol::{
-    Evaluate, EvaluateTrait, Primitive, Scope, ShellTypeName, SpannedTypeName, TaggedDictBuilder,
-    UntaggedValue, Value,
+    hir, Primitive, ShellTypeName, SpannedTypeName, TaggedDictBuilder, UntaggedValue, Value,
 };
-use nu_source::{Tag, Text};
+use nu_source::Tag;
 use nu_value_ext::ValueExt;
 use num_bigint::BigInt;
 use num_traits::Zero;
@@ -23,49 +18,18 @@ use std::time::SystemTime;
 #[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, new, Serialize)]
 pub struct Operation {
     pub(crate) left: Value,
-    pub(crate) operator: CompareOperator,
+    pub(crate) operator: hir::Operator,
     pub(crate) right: Value,
 }
 
 #[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Hash, Serialize, Deserialize, new)]
 pub struct Block {
-    pub(crate) expressions: Vec<hir::SpannedExpression>,
-    pub(crate) source: Text,
+    pub(crate) commands: hir::Commands,
     pub(crate) tag: Tag,
 }
 
 interfaces!(Block: dyn ObjectHash);
 
-#[typetag::serde]
-impl EvaluateTrait for Block {
-    fn invoke(&self, scope: &Scope) -> Result<Value, ShellError> {
-        if self.expressions.is_empty() {
-            return Ok(UntaggedValue::nothing().into_value(&self.tag));
-        }
-
-        let mut last = Ok(UntaggedValue::nothing().into_value(&self.tag));
-
-        trace!(
-            "EXPRS = {:?}",
-            self.expressions
-                .iter()
-                .map(|e| format!("{:?}", e))
-                .collect::<Vec<_>>()
-        );
-
-        for expr in self.expressions.iter() {
-            last = evaluate_baseline_expr(&expr, &CommandRegistry::empty(), &scope, &self.source)
-        }
-
-        last
-    }
-
-    fn clone_box(&self) -> Evaluate {
-        let block = self.clone();
-        Evaluate::new(block)
-    }
-}
-
 #[derive(Serialize, Deserialize)]
 pub enum Switch {
     Present,
@@ -123,7 +87,8 @@ pub(crate) enum CompareValues {
     Decimals(BigDecimal, BigDecimal),
     String(String, String),
     Date(DateTime<Utc>, DateTime<Utc>),
-    DateDuration(DateTime<Utc>, u64),
+    DateDuration(DateTime<Utc>, i64),
+    Booleans(bool, bool),
 }
 
 impl CompareValues {
@@ -137,9 +102,14 @@ impl CompareValues {
                 use std::time::Duration;
 
                 // Create the datetime we're comparing against, as duration is an offset from now
-                let right: DateTime<Utc> = (SystemTime::now() - Duration::from_secs(*right)).into();
+                let right: DateTime<Utc> = if *right < 0 {
+                    (SystemTime::now() + Duration::from_secs((*right * -1) as u64)).into()
+                } else {
+                    (SystemTime::now() - Duration::from_secs(*right as u64)).into()
+                };
                 right.cmp(left)
             }
+            CompareValues::Booleans(left, right) => left.cmp(right),
         }
     }
 }
@@ -176,16 +146,27 @@ fn coerce_compare_primitive(
         (Decimal(left), Bytes(right)) => {
             CompareValues::Decimals(left.clone(), BigDecimal::from(*right))
         }
+        (Bytes(left), Bytes(right)) => {
+            CompareValues::Ints(BigInt::from(*left), BigInt::from(*right))
+        }
         (Bytes(left), Int(right)) => CompareValues::Ints(BigInt::from(*left), right.clone()),
         (Bytes(left), Decimal(right)) => {
             CompareValues::Decimals(BigDecimal::from(*left), right.clone())
         }
+        (Bytes(left), Nothing) => CompareValues::Ints(BigInt::from(*left), BigInt::from(0)),
+        (Nothing, Nothing) => CompareValues::Ints(BigInt::from(0), BigInt::from(0)),
+        (Nothing, Bytes(right)) => CompareValues::Ints(BigInt::from(0), BigInt::from(*right)),
+        (Int(left), Nothing) => CompareValues::Ints(left.clone(), BigInt::from(0)),
+        (Nothing, Int(right)) => CompareValues::Ints(BigInt::from(0), right.clone()),
+        (Decimal(left), Nothing) => CompareValues::Decimals(left.clone(), BigDecimal::from(0.0)),
+        (Nothing, Decimal(right)) => CompareValues::Decimals(BigDecimal::from(0.0), right.clone()),
         (String(left), String(right)) => CompareValues::String(left.clone(), right.clone()),
         (Line(left), String(right)) => CompareValues::String(left.clone(), right.clone()),
         (String(left), Line(right)) => CompareValues::String(left.clone(), right.clone()),
         (Line(left), Line(right)) => CompareValues::String(left.clone(), right.clone()),
         (Date(left), Date(right)) => CompareValues::Date(*left, *right),
         (Date(left), Duration(right)) => CompareValues::DateDuration(*left, *right),
+        (Boolean(left), Boolean(right)) => CompareValues::Booleans(*left, *right),
         _ => return Err((left.type_name(), right.type_name())),
     })
 }

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

@@ -27,7 +27,7 @@ pub enum InlineShape {
     Pattern(String),
     Boolean(bool),
     Date(DateTime<Utc>),
-    Duration(u64),
+    Duration(i64),
     Path(PathBuf),
     Binary,
 

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

@@ -36,13 +36,13 @@ pub(crate) fn dir_entry_dict(
     metadata: Option<&std::fs::Metadata>,
     tag: impl Into<Tag>,
     full: bool,
-    name_only: bool,
+    short_name: bool,
     with_symlink_targets: bool,
 ) -> Result<Value, ShellError> {
     let tag = tag.into();
     let mut dict = TaggedDictBuilder::new(&tag);
 
-    let name = if name_only {
+    let name = if short_name {
         filename.file_name().and_then(|s| s.to_str())
     } else {
         filename.to_str()

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

@@ -1,5 +1,4 @@
-use nu_parser::Number;
-use nu_protocol::Primitive;
+use nu_protocol::{hir::Number, Primitive};
 
 pub fn number(number: impl Into<Number>) -> Primitive {
     let number = number.into();

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

@@ -3,7 +3,8 @@ use crate::data::base::shape::{Column, InlineShape};
 use crate::data::primitive::style_primitive;
 use chrono::DateTime;
 use nu_errors::ShellError;
-use nu_parser::CompareOperator;
+use nu_protocol::hir::Operator;
+use nu_protocol::ShellTypeName;
 use nu_protocol::{Primitive, Type, UntaggedValue};
 use nu_source::{DebugDocBuilder, PrettyDebug, Tagged};
 
@@ -21,8 +22,91 @@ pub fn date_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
     Ok(UntaggedValue::Primitive(Primitive::Date(date)))
 }
 
+pub fn compute_values(
+    operator: Operator,
+    left: &UntaggedValue,
+    right: &UntaggedValue,
+) -> Result<UntaggedValue, (&'static str, &'static str)> {
+    match (left, right) {
+        (UntaggedValue::Primitive(lhs), UntaggedValue::Primitive(rhs)) => match (lhs, rhs) {
+            (Primitive::Bytes(x), Primitive::Bytes(y)) => {
+                let result = match operator {
+                    Operator::Plus => Ok(x + y),
+                    Operator::Minus => Ok(x - y),
+                    _ => Err((left.type_name(), right.type_name())),
+                }?;
+                Ok(UntaggedValue::Primitive(Primitive::Bytes(result)))
+            }
+            (Primitive::Int(x), Primitive::Int(y)) => match operator {
+                Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::Int(x + y))),
+                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::Int(x - y))),
+                Operator::Multiply => Ok(UntaggedValue::Primitive(Primitive::Int(x * y))),
+                Operator::Divide => {
+                    if x - (y * (x / y)) == num_bigint::BigInt::from(0) {
+                        Ok(UntaggedValue::Primitive(Primitive::Int(x / y)))
+                    } else {
+                        Ok(UntaggedValue::Primitive(Primitive::Decimal(
+                            bigdecimal::BigDecimal::from(x.clone())
+                                / bigdecimal::BigDecimal::from(y.clone()),
+                        )))
+                    }
+                }
+                _ => Err((left.type_name(), right.type_name())),
+            },
+            (Primitive::Decimal(x), Primitive::Int(y)) => {
+                let result = match operator {
+                    Operator::Plus => Ok(x + bigdecimal::BigDecimal::from(y.clone())),
+                    Operator::Minus => Ok(x - bigdecimal::BigDecimal::from(y.clone())),
+                    Operator::Multiply => Ok(x * bigdecimal::BigDecimal::from(y.clone())),
+                    Operator::Divide => Ok(x / bigdecimal::BigDecimal::from(y.clone())),
+                    _ => Err((left.type_name(), right.type_name())),
+                }?;
+                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
+            }
+            (Primitive::Int(x), Primitive::Decimal(y)) => {
+                let result = match operator {
+                    Operator::Plus => Ok(bigdecimal::BigDecimal::from(x.clone()) + y),
+                    Operator::Minus => Ok(bigdecimal::BigDecimal::from(x.clone()) - y),
+                    Operator::Multiply => Ok(bigdecimal::BigDecimal::from(x.clone()) * y),
+                    Operator::Divide => Ok(bigdecimal::BigDecimal::from(x.clone()) / y),
+                    _ => Err((left.type_name(), right.type_name())),
+                }?;
+                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
+            }
+            (Primitive::Decimal(x), Primitive::Decimal(y)) => {
+                let result = match operator {
+                    Operator::Plus => Ok(x + y),
+                    Operator::Minus => Ok(x - y),
+                    Operator::Multiply => Ok(x * y),
+                    Operator::Divide => Ok(x / y),
+                    _ => Err((left.type_name(), right.type_name())),
+                }?;
+                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
+            }
+            (Primitive::Date(x), Primitive::Date(y)) => {
+                let result = match operator {
+                    Operator::Minus => Ok(x.signed_duration_since(*y).num_seconds()),
+                    _ => Err((left.type_name(), right.type_name())),
+                }?;
+                Ok(UntaggedValue::Primitive(Primitive::Duration(result)))
+            }
+            (Primitive::Date(x), Primitive::Duration(y)) => {
+                let result = match operator {
+                    Operator::Plus => Ok(x
+                        .checked_add_signed(chrono::Duration::seconds(*y as i64))
+                        .expect("Overflowing add of duration")),
+                    _ => Err((left.type_name(), right.type_name())),
+                }?;
+                Ok(UntaggedValue::Primitive(Primitive::Date(result)))
+            }
+            _ => Err((left.type_name(), right.type_name())),
+        },
+        _ => Err((left.type_name(), right.type_name())),
+    }
+}
+
 pub fn compare_values(
-    operator: CompareOperator,
+    operator: Operator,
     left: &UntaggedValue,
     right: &UntaggedValue,
 ) -> Result<bool, (&'static str, &'static str)> {
@@ -34,15 +118,16 @@ pub fn compare_values(
             use std::cmp::Ordering;
 
             let result = match (operator, ordering) {
-                (CompareOperator::Equal, Ordering::Equal) => true,
-                (CompareOperator::NotEqual, Ordering::Less)
-                | (CompareOperator::NotEqual, Ordering::Greater) => true,
-                (CompareOperator::LessThan, Ordering::Less) => true,
-                (CompareOperator::GreaterThan, Ordering::Greater) => true,
-                (CompareOperator::GreaterThanOrEqual, Ordering::Greater)
-                | (CompareOperator::GreaterThanOrEqual, Ordering::Equal) => true,
-                (CompareOperator::LessThanOrEqual, Ordering::Less)
-                | (CompareOperator::LessThanOrEqual, Ordering::Equal) => true,
+                (Operator::Equal, Ordering::Equal) => true,
+                (Operator::NotEqual, Ordering::Less) | (Operator::NotEqual, Ordering::Greater) => {
+                    true
+                }
+                (Operator::LessThan, Ordering::Less) => true,
+                (Operator::GreaterThan, Ordering::Greater) => true,
+                (Operator::GreaterThanOrEqual, Ordering::Greater)
+                | (Operator::GreaterThanOrEqual, Ordering::Equal) => true,
+                (Operator::LessThanOrEqual, Ordering::Less)
+                | (Operator::LessThanOrEqual, Ordering::Equal) => true,
                 _ => false,
             };
 

crates/nu-cli/src/deserializer.rs

@@ -1,7 +1,8 @@
 use log::trace;
 use nu_errors::{CoerceInto, ShellError};
 use nu_protocol::{
-    CallInfo, ColumnPath, Evaluate, Primitive, RangeInclusion, ShellTypeName, UntaggedValue, Value,
+    hir::Block, CallInfo, ColumnPath, Primitive, RangeInclusion, ShellTypeName, UntaggedValue,
+    Value,
 };
 use nu_source::{HasSpan, Spanned, SpannedItem, Tagged, TaggedItem};
 use nu_value_ext::ValueExt;
@@ -368,7 +369,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut ConfigDeserializer<'de> {
                     ))
                 }
             };
-            return visit::<Evaluate, _>(block, name, fields, visitor);
+            return visit::<Block, _>(block, name, fields, visitor);
         }
 
         if name == "ColumnPath" {

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

@@ -275,7 +275,7 @@ mod tests {
             assert_eq!(
                 actual.path(),
                 Some(
-                    UntaggedValue::table(&vec![
+                    UntaggedValue::table(&[
                         UntaggedValue::string("/Users/andresrobalino/.volta/bin")
                             .into_untagged_value(),
                         UntaggedValue::string("/users/mosqueteros/bin").into_untagged_value(),

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

@@ -208,7 +208,7 @@ mod tests {
                 assert_eq!(actual, expected);
             });
 
-            // Now confirm in-memory environment variables synced appropiately
+            // Now confirm in-memory environment variables synced appropriately
             // including the newer one accounted for.
             let environment = actual.env.lock();
 

crates/nu-cli/src/evaluate/evaluate_args.rs

@@ -3,22 +3,19 @@ use crate::context::CommandRegistry;
 use crate::evaluate::evaluate_baseline_expr;
 use indexmap::IndexMap;
 use nu_errors::ShellError;
-use nu_parser::hir;
-use nu_protocol::{EvaluatedArgs, Scope, UntaggedValue, Value};
-use nu_source::Text;
+use nu_protocol::{hir, EvaluatedArgs, Scope, UntaggedValue, Value};
 
 pub(crate) fn evaluate_args(
     call: &hir::Call,
     registry: &CommandRegistry,
     scope: &Scope,
-    source: &Text,
 ) -> Result<EvaluatedArgs, ShellError> {
     let positional: Result<Option<Vec<_>>, _> = call
         .positional
         .as_ref()
         .map(|p| {
             p.iter()
-                .map(|e| evaluate_baseline_expr(e, registry, scope, source))
+                .map(|e| evaluate_baseline_expr(e, registry, scope))
                 .collect()
         })
         .transpose();
@@ -36,11 +33,9 @@ pub(crate) fn evaluate_args(
                     hir::NamedValue::PresentSwitch(tag) => {
                         results.insert(name.clone(), UntaggedValue::boolean(true).into_value(tag));
                     }
-                    hir::NamedValue::Value(expr) => {
-                        results.insert(
-                            name.clone(),
-                            evaluate_baseline_expr(expr, registry, scope, source)?,
-                        );
+                    hir::NamedValue::Value(_, expr) => {
+                        results
+                            .insert(name.clone(), evaluate_baseline_expr(expr, registry, scope)?);
                     }
 
                     _ => {}

crates/nu-cli/src/evaluate/evaluator.rs

@@ -1,28 +1,24 @@
 use crate::context::CommandRegistry;
-use crate::data::base::Block;
 use crate::evaluate::operator::apply_operator;
 use crate::prelude::*;
 use log::trace;
 use nu_errors::{ArgumentError, ShellError};
-use nu_parser::hir::{self, Expression, SpannedExpression};
+use nu_protocol::hir::{self, Expression, SpannedExpression};
 use nu_protocol::{
-    ColumnPath, Evaluate, Primitive, RangeInclusion, Scope, UnspannedPathMember, UntaggedValue,
-    Value,
+    ColumnPath, Primitive, RangeInclusion, Scope, UnspannedPathMember, UntaggedValue, Value,
 };
-use nu_source::Text;
 
 pub(crate) fn evaluate_baseline_expr(
     expr: &SpannedExpression,
     registry: &CommandRegistry,
     scope: &Scope,
-    source: &Text,
 ) -> Result<Value, ShellError> {
     let tag = Tag {
         span: expr.span,
         anchor: None,
     };
     match &expr.expr {
-        Expression::Literal(literal) => Ok(evaluate_literal(literal, expr.span, source)),
+        Expression::Literal(literal) => Ok(evaluate_literal(literal, expr.span)),
         Expression::ExternalWord => Err(ShellError::argument_error(
             "Invalid external word".spanned(tag.span),
             ArgumentError::InvalidExternalWord,
@@ -31,29 +27,35 @@ pub(crate) fn evaluate_baseline_expr(
         Expression::Synthetic(hir::Synthetic::String(s)) => {
             Ok(UntaggedValue::string(s).into_untagged_value())
         }
-        Expression::Variable(var) => evaluate_reference(var, scope, source, tag),
-        Expression::Command(_) => evaluate_command(tag, scope, source),
-        Expression::ExternalCommand(external) => evaluate_external(external, scope, source),
+        Expression::Variable(var) => evaluate_reference(var, scope, tag),
+        Expression::Command(_) => evaluate_command(tag, scope),
+        Expression::ExternalCommand(external) => evaluate_external(external, scope),
         Expression::Binary(binary) => {
-            let left = evaluate_baseline_expr(binary.left(), registry, scope, source)?;
-            let right = evaluate_baseline_expr(binary.right(), registry, scope, source)?;
+            // TODO: If we want to add short-circuiting, we'll need to move these down
+            let left = evaluate_baseline_expr(&binary.left, registry, scope)?;
+            let right = evaluate_baseline_expr(&binary.right, registry, scope)?;
 
             trace!("left={:?} right={:?}", left.value, right.value);
 
-            match apply_operator(**binary.op(), &left, &right) {
-                Ok(result) => Ok(result.into_value(tag)),
-                Err((left_type, right_type)) => Err(ShellError::coerce_error(
-                    left_type.spanned(binary.left().span),
-                    right_type.spanned(binary.right().span),
-                )),
+            match binary.op.expr {
+                Expression::Literal(hir::Literal::Operator(op)) => {
+                    match apply_operator(op, &left, &right) {
+                        Ok(result) => Ok(result.into_value(tag)),
+                        Err((left_type, right_type)) => Err(ShellError::coerce_error(
+                            left_type.spanned(binary.left.span),
+                            right_type.spanned(binary.right.span),
+                        )),
+                    }
+                }
+                _ => unreachable!(),
             }
         }
         Expression::Range(range) => {
-            let left = range.left();
-            let right = range.right();
+            let left = &range.left;
+            let right = &range.right;
 
-            let left = evaluate_baseline_expr(left, registry, scope, source)?;
-            let right = evaluate_baseline_expr(right, registry, scope, source)?;
+            let left = evaluate_baseline_expr(left, registry, scope)?;
+            let right = evaluate_baseline_expr(right, registry, scope)?;
             let left_span = left.tag.span;
             let right_span = right.tag.span;
 
@@ -72,23 +74,18 @@ pub(crate) fn evaluate_baseline_expr(
             let mut exprs = vec![];
 
             for expr in list {
-                let expr = evaluate_baseline_expr(expr, registry, scope, source)?;
+                let expr = evaluate_baseline_expr(expr, registry, scope)?;
                 exprs.push(expr);
             }
 
             Ok(UntaggedValue::Table(exprs).into_value(tag))
         }
-        Expression::Block(block) => Ok(UntaggedValue::Block(Evaluate::new(Block::new(
-            block.clone(),
-            source.clone(),
-            tag.clone(),
-        )))
-        .into_value(&tag)),
+        Expression::Block(block) => Ok(UntaggedValue::Block(block.clone()).into_value(&tag)),
         Expression::Path(path) => {
-            let value = evaluate_baseline_expr(path.head(), registry, scope, source)?;
+            let value = evaluate_baseline_expr(&path.head, registry, scope)?;
             let mut item = value;
 
-            for member in path.tail() {
+            for member in &path.tail {
                 let next = item.get_data_by_member(member);
 
                 match next {
@@ -107,7 +104,7 @@ pub(crate) fn evaluate_baseline_expr(
                                 return Err(ShellError::labeled_error(
                                     "Unknown column",
                                     format!("did you mean '{}'?", possible_matches[0].1),
-                                    &tag,
+                                    &member.span,
                                 ));
                             } else {
                                 return Err(err);
@@ -123,42 +120,46 @@ pub(crate) fn evaluate_baseline_expr(
             Ok(item.value.into_value(tag))
         }
         Expression::Boolean(_boolean) => unimplemented!(),
+        Expression::Garbage => unimplemented!(),
     }
 }
 
-fn evaluate_literal(literal: &hir::Literal, span: Span, source: &Text) -> Value {
+fn evaluate_literal(literal: &hir::Literal, span: Span) -> Value {
     match &literal {
         hir::Literal::ColumnPath(path) => {
-            let members = path
-                .iter()
-                .map(|member| member.to_path_member(source))
-                .collect();
+            let members = path.iter().map(|member| member.to_path_member()).collect();
 
             UntaggedValue::Primitive(Primitive::ColumnPath(ColumnPath::new(members)))
                 .into_value(span)
         }
         hir::Literal::Number(int) => match int {
-            nu_parser::Number::Int(i) => UntaggedValue::int(i.clone()).into_value(span),
-            nu_parser::Number::Decimal(d) => UntaggedValue::decimal(d.clone()).into_value(span),
+            nu_protocol::hir::Number::Int(i) => UntaggedValue::int(i.clone()).into_value(span),
+            nu_protocol::hir::Number::Decimal(d) => {
+                UntaggedValue::decimal(d.clone()).into_value(span)
+            }
         },
         hir::Literal::Size(int, unit) => unit.compute(&int).into_value(span),
-        hir::Literal::String(tag) => UntaggedValue::string(tag.slice(source)).into_value(span),
+        hir::Literal::String(string) => UntaggedValue::string(string).into_value(span),
         hir::Literal::GlobPattern(pattern) => UntaggedValue::pattern(pattern).into_value(span),
-        hir::Literal::Bare => UntaggedValue::string(span.slice(source)).into_value(span),
+        hir::Literal::Bare(bare) => UntaggedValue::string(bare.clone()).into_value(span),
+        hir::Literal::Operator(_) => unimplemented!("Not sure what to do with operator yet"),
     }
 }
 
-fn evaluate_reference(
-    name: &hir::Variable,
-    scope: &Scope,
-    source: &Text,
-    tag: Tag,
-) -> Result<Value, ShellError> {
+fn evaluate_reference(name: &hir::Variable, scope: &Scope, tag: Tag) -> Result<Value, ShellError> {
     trace!("Evaluating {:?} with Scope {:?}", name, scope);
     match name {
         hir::Variable::It(_) => Ok(scope.it.value.clone().into_value(tag)),
-        hir::Variable::Other(inner) => match inner.slice(source) {
-            x if x == "nu" => crate::evaluate::variables::nu(tag),
+        hir::Variable::Other(name, _) => match name {
+            x if x == "$nu" => crate::evaluate::variables::nu(tag),
+            x if x == "$true" => Ok(Value {
+                value: UntaggedValue::boolean(true),
+                tag,
+            }),
+            x if x == "$false" => Ok(Value {
+                value: UntaggedValue::boolean(false),
+                tag,
+            }),
             x => Ok(scope
                 .vars
                 .get(x)
@@ -169,16 +170,15 @@ fn evaluate_reference(
 }
 
 fn evaluate_external(
-    external: &hir::ExternalCommand,
+    external: &hir::ExternalStringCommand,
     _scope: &Scope,
-    _source: &Text,
 ) -> Result<Value, ShellError> {
     Err(ShellError::syntax_error(
-        "Unexpected external command".spanned(*external.name()),
+        "Unexpected external command".spanned(external.name.span),
     ))
 }
 
-fn evaluate_command(tag: Tag, _scope: &Scope, _source: &Text) -> Result<Value, ShellError> {
+fn evaluate_command(tag: Tag, _scope: &Scope) -> Result<Value, ShellError> {
     Err(ShellError::syntax_error(
         "Unexpected command".spanned(tag.span),
     ))

crates/nu-cli/src/evaluate/operator.rs

@@ -1,30 +1,43 @@
 use crate::data::value;
-use nu_parser::CompareOperator;
+use nu_protocol::hir::Operator;
 use nu_protocol::{Primitive, ShellTypeName, UntaggedValue, Value};
 use std::ops::Not;
 
 pub fn apply_operator(
-    op: CompareOperator,
+    op: Operator,
     left: &Value,
     right: &Value,
 ) -> Result<UntaggedValue, (&'static str, &'static str)> {
     match op {
-        CompareOperator::Equal
-        | CompareOperator::NotEqual
-        | CompareOperator::LessThan
-        | CompareOperator::GreaterThan
-        | CompareOperator::LessThanOrEqual
-        | CompareOperator::GreaterThanOrEqual => {
+        Operator::Equal
+        | Operator::NotEqual
+        | Operator::LessThan
+        | Operator::GreaterThan
+        | Operator::LessThanOrEqual
+        | Operator::GreaterThanOrEqual => {
             value::compare_values(op, left, right).map(UntaggedValue::boolean)
         }
-        CompareOperator::Contains => contains(left, right).map(UntaggedValue::boolean),
-        CompareOperator::NotContains => contains(left, right)
+        Operator::Contains => string_contains(left, right).map(UntaggedValue::boolean),
+        Operator::NotContains => string_contains(left, right)
             .map(Not::not)
             .map(UntaggedValue::boolean),
+        Operator::Plus => value::compute_values(op, left, right),
+        Operator::Minus => value::compute_values(op, left, right),
+        Operator::Multiply => value::compute_values(op, left, right),
+        Operator::Divide => value::compute_values(op, left, right),
+        Operator::In => table_contains(left, right).map(UntaggedValue::boolean),
+        Operator::And => match (left.as_bool(), right.as_bool()) {
+            (Ok(left), Ok(right)) => Ok(UntaggedValue::boolean(left && right)),
+            _ => Err((left.type_name(), right.type_name())),
+        },
+        Operator::Or => match (left.as_bool(), right.as_bool()) {
+            (Ok(left), Ok(right)) => Ok(UntaggedValue::boolean(left || right)),
+            _ => Err((left.type_name(), right.type_name())),
+        },
     }
 }
 
-fn contains(
+fn string_contains(
     left: &UntaggedValue,
     right: &UntaggedValue,
 ) -> Result<bool, (&'static str, &'static str)> {
@@ -48,3 +61,14 @@ fn contains(
         _ => Err((left.type_name(), right.type_name())),
     }
 }
+
+fn table_contains(
+    left: &UntaggedValue,
+    right: &UntaggedValue,
+) -> Result<bool, (&'static str, &'static str)> {
+    let left = left.clone();
+    match right {
+        UntaggedValue::Table(values) => Ok(values.iter().any(|x| x.value == left)),
+        _ => Err((left.type_name(), right.type_name())),
+    }
+}

crates/nu-cli/src/format.rs

@@ -1,12 +1,8 @@
-pub(crate) mod entries;
-pub(crate) mod generic;
-pub(crate) mod list;
 pub(crate) mod table;
 
 use crate::prelude::*;
 use nu_errors::ShellError;
 
-pub(crate) use entries::EntriesView;
 pub(crate) use table::TableView;
 
 pub(crate) trait RenderView {

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

@@ -1,50 +0,0 @@
-use crate::data::value;
-use crate::format::RenderView;
-use crate::prelude::*;
-use nu_errors::ShellError;
-use nu_protocol::Value;
-
-use derive_new::new;
-
-// An entries list is printed like this:
-//
-// name         : ...
-// name2        : ...
-// another_name : ...
-#[derive(new)]
-pub struct EntriesView {
-    entries: Vec<(String, String)>,
-}
-
-impl EntriesView {
-    pub(crate) fn from_value(value: &Value) -> EntriesView {
-        let descs = value.data_descriptors();
-        let mut entries = vec![];
-
-        for desc in descs {
-            let value = value.get_data(&desc);
-
-            let formatted_value = value::format_leaf(value.borrow()).plain_string(75);
-
-            entries.push((desc.clone(), formatted_value))
-        }
-
-        EntriesView::new(entries)
-    }
-}
-
-impl RenderView for EntriesView {
-    fn render_view(&self, _host: &mut dyn Host) -> Result<(), ShellError> {
-        if self.entries.is_empty() {
-            return Ok(());
-        }
-
-        if let Some(max_name_size) = self.entries.iter().map(|(n, _)| n.len()).max() {
-            for (name, value) in &self.entries {
-                outln!("{:width$} : {}", name, value, width = max_name_size)
-            }
-        }
-
-        Ok(())
-    }
-}