Move ls back to last-known-good state (#6175)

* revert the recent ls changes

* cargo fmt

.cargo/config.toml

@@ -12,17 +12,3 @@ rustflags = ["-C", "link-args=-stack:10000000", "-C", "target-feature=+crt-stati
 # set a 2 gb stack size (0x80000000 = 2147483648 bytes = 2 GB)
 # [target.x86_64-apple-darwin]
 # rustflags = ["-C", "link-args=-Wl,-stack_size,0x80000000"]
-
-# How to use mold in linux and mac
-
-# [target.x86_64-unknown-linux-gnu]
-# linker = "clang"
-# rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/mold"]
-
-# [target.x86_64-apple-darwin]
-# linker = "clang"
-# rustflags = ["-C", "link-arg=-fuse-ld=mold"]
-
-# [target.aarch64-apple-darwin]
-# linker = "clang"
-# rustflags = ["-C", "link-arg=-fuse-ld=mold"]

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -53,7 +53,7 @@ body:
         | features           | clipboard-cli, ctrlc, dataframe, default, rustyline, term, trash, uuid, which, zip                                                                                      |
         | installed_plugins  | binaryview, chart bar, chart line, fetch, from bson, from sqlite, inc, match, post, ps, query json, s3, selector, start, sys, textview, to bson, to sqlite, tree, xpath |
     validations:
-      required: true
+      required: false
   - type: textarea
     id: context
     attributes:

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,6 +1,5 @@
 name: Feature Request
 description: "When you want a new feature for something that doesn't already exist"
-labels: "enhancement"
 body:
   - type: textarea
     id: problem

.github/ISSUE_TEMPLATE/question.yml

@@ -1,21 +0,0 @@
-name: Question
-description: "When you have a question to ask"
-labels: "question"
-body:
-  - type: textarea
-    id: problem
-    attributes:
-      label: Question
-      description: Leave your question here
-      placeholder: |
-        A clear and concise question
-        Example: Is there any equivalent of bash's $CDPATH in Nu?
-    validations:
-      required: true
-  - type: textarea
-    id: context
-    attributes:
-      label: Additional context and details
-      description: Add any other context, screenshots or other media that will help us understand your question here, if needed.
-    validations:
-      required: false

.github/pull_request_template.md

@@ -1,24 +1,17 @@
-
 # Description
 
-_(Thank you for improving Nushell. Please, check our [contributing guide](../CONTRIBUTING.md) and talk to the core team before making major changes.)_
+(description of your pull request here)
 
-_(Description of your pull request goes here. **Provide examples and/or screenshots** if your changes affect the user experience.)_
+# Tests
 
-# User-Facing Changes
+Make sure you've done the following:
 
-_(List of all changes that impact the user experience here. This helps us keep track of breaking changes.)_
-
-# Tests + Formatting
-
-Don't forget to add tests that cover your changes.
+- [ ] Add tests that cover your changes, either in the command examples, the crate/tests folder, or in the /tests folder.
+- [ ] Try to think about corner cases and various ways how your changes could break. Cover them with tests.
+- [ ] If adding tests is not possible, please document in the PR body a minimal example with steps on how to reproduce so one can verify your change works.
 
 Make sure you've run and fixed any issues with these commands:
 
-- `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
-- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style
-- `cargo test --workspace` to check that all tests pass
-
-# After Submitting
-
-If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date.
+- [ ] `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
+- [ ] `cargo clippy --workspace --features=extra -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style
+- [ ] `cargo test --workspace --features=extra` to check that all the tests pass

.github/workflows/ci.yml

@@ -11,10 +11,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        # Pinning to Ubuntu 20.04 because building on newer Ubuntu versions causes linux-gnu
-        # builds to link against a too-new-for-many-Linux-installs glibc version. Consider
-        # revisiting this when 20.04 is closer to EOL (April 2025)
-        platform: [windows-latest, macos-latest, ubuntu-20.04]
+        platform: [windows-latest, macos-latest, ubuntu-latest]
         rust:
           - stable
 
@@ -23,16 +20,31 @@ jobs:
       NUSHELL_CARGO_TARGET: ci
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
-      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
 
-      - name: cargo fmt
-        run: cargo fmt --all -- --check
+      - uses: Swatinem/rust-cache@v1
+        with:
+          key: "v2" # increment this to bust the cache if needed
+
+      - name: Rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
 
       - name: Clippy
-        run: cargo clippy --workspace --exclude nu_plugin_* -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --features=extra --workspace --exclude nu_plugin_* -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
 
   nu-tests:
     env:
@@ -41,32 +53,44 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-20.04]
-        style: [default, dataframe]
+        platform: [windows-latest, macos-latest, ubuntu-latest]
+        style: [extra, default]
         rust:
           - stable
         include:
+          - style: extra
+            flags: "--features=extra"
           - style: default
             flags: ""
-          - style: dataframe
-            flags: "--features=dataframe"
         exclude:
-          # only test dataframes on Ubuntu (the fastest platform)
           - platform: windows-latest
-            style: dataframe
+            style: default
           - platform: macos-latest
-            style: dataframe
+            style: default
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
-      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      # Temporarily disabled; the cache was getting huge (2.6GB compressed) on Windows and causing issues.
+      # TODO: investigate why the cache was so big
+      # - uses: Swatinem/rust-cache@v1
+      #   with:
+      #     key: ${{ matrix.style }}v3 # increment this to bust the cache if needed
 
       - name: Tests
-        run: cargo test --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
 
   python-virtualenv:
     env:
@@ -75,7 +99,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [ubuntu-20.04, macos-latest, windows-latest]
+        platform: [ubuntu-latest, macos-latest, windows-latest]
         rust:
           - stable
         py:
@@ -84,23 +108,34 @@ jobs:
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
-      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      - uses: Swatinem/rust-cache@v1
+        with:
+          key: "2" # increment this to bust the cache if needed
 
       - name: Install Nushell
-        run: cargo install --locked --path=. --profile ci --no-default-features
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: --path=. --profile ci --no-default-features
 
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v2
         with:
           python-version: "3.10"
 
       - run: python -m pip install tox
 
       - name: Install virtualenv
-        run: git clone https://github.com/pypa/virtualenv.git
+        run: git clone https://github.com/pypa/virtualenv.git          
         shell: bash
 
       - name: Test Nushell in virtualenv
@@ -116,20 +151,30 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-20.04]
+        platform: [windows-latest, macos-latest, ubuntu-latest]
         rust:
           - stable
 
     runs-on: ${{ matrix.platform }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
-      - name: Setup Rust toolchain and cache
-        uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
 
       - name: Clippy
-        run: cargo clippy --package nu_plugin_* ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --package nu_plugin_* ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
 
       - name: Tests
-        run: cargo test --profile ci --package nu_plugin_*
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --profile ci --package nu_plugin_*

.github/workflows/manual.yml

@@ -1,41 +0,0 @@
-# This is a basic workflow that is manually triggered
-# Don't run it unless you know what you are doing
-
-name: Manual Workflow for Winget Submission
-
-# Controls when the action will run. Workflow runs when manually triggered using the UI
-# or API.
-on:
-  workflow_dispatch:
-    # Inputs the workflow accepts.
-    inputs:
-      ver:
-        # Friendly description to be shown in the UI instead of 'ver'
-        description: 'The nushell version to release'
-        # Default value if no value is explicitly provided
-        default: '0.66.0'
-        # Input has to be provided for the workflow to run
-        required: true
-      uri:
-        # Friendly description to be shown in the UI instead of 'uri'
-        description: 'The nushell windows .msi package URI to publish'
-        # Default value if no value is explicitly provided
-        default: 'https://github.com/nushell/nushell/releases/download/0.66.0/nu-0.66.0-x86_64-pc-windows-msvc.msi'
-        # Input has to be provided for the workflow to run
-        required: true
-
-# A workflow run is made up of one or more jobs that can run sequentially or in parallel
-jobs:
-  # This workflow contains a single job
-  rls-winget-pkg:
-    name: Publish winget package manually
-    # The type of runner that the job will run on
-    runs-on: windows-latest
-
-    # Steps represent a sequence of tasks that will be executed as part of the job
-    steps:
-    # Runs commands using the runners shell
-    - name: Submit package to Windows Package Manager Community Repository Manually
-      run: |
-          iwr https://github.com/microsoft/winget-create/releases/download/v1.0.4.0/wingetcreate.exe -OutFile wingetcreate.exe
-          .\wingetcreate.exe update Nushell.Nushell -s -v ${{ github.event.inputs.ver }} -u ${{ github.event.inputs.uri }} -t ${{ secrets.NUSHELL_PAT }}

.github/workflows/release-pkg.nu

@@ -6,21 +6,6 @@
 # REF:
 #   1. https://github.com/volks73/cargo-wix
 
-# Added 2022-11-29 when Windows packaging wouldn't work
-# because softprops/action-gh-release was broken
-# To run this manual for windows
-# let-env TARGET = 'x86_64-pc-windows-msvc'
-# let-env TARGET_RUSTFLAGS = ''
-# let-env GITHUB_WORKSPACE = 'C:\Users\dschroeder\source\repos\forks\nushell'
-# Pass 1 let-env _EXTRA_ = 'bin'
-# Pass 2 let-env _EXTRA_ = 'msi'
-# make sure 7z.exe is in your path https://www.7-zip.org/download.html
-# make sure aria2c.exe is in your path https://github.com/aria2/aria2
-# make sure you have the wixtools installed https://wixtoolset.org/
-# set os below like this because it's what github's runner is named
-# let os = 'windows-latest'
-
-
 # The main binary file to be released
 let bin = 'nu'
 let os = $env.OS
@@ -31,13 +16,8 @@ let flags = $env.TARGET_RUSTFLAGS
 let dist = $'($env.GITHUB_WORKSPACE)/output'
 let version = (open Cargo.toml | get package.version)
 
-$'Debugging info:'
-print { version: $version, bin: $bin, os: $os, target: $target, src: $src, flags: $flags, dist: $dist }; hr-line -b
-
 # $env
 
-let USE_UBUNTU = 'ubuntu-20.04'
-
 $'(char nl)Packaging ($bin) v($version) for ($target) in ($src)...'; hr-line -b
 if not ('Cargo.lock' | path exists) { cargo generate-lockfile }
 
@@ -46,9 +26,8 @@ $'Start building ($bin)...'; hr-line
 # ----------------------------------------------------------------------------
 # Build for Ubuntu and macOS
 # ----------------------------------------------------------------------------
-if $os in [$USE_UBUNTU, 'macos-latest'] {
-    if $os == $USE_UBUNTU {
-        sudo apt update
+if $os in ['ubuntu-latest', 'macos-latest'] {
+    if $os == 'ubuntu-latest' {
         sudo apt-get install libxcb-composite0-dev -y
     }
     if $target == 'aarch64-unknown-linux-gnu' {
@@ -59,14 +38,10 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
         sudo apt-get install pkg-config gcc-arm-linux-gnueabihf -y
         let-env CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER = 'arm-linux-gnueabihf-gcc'
         cargo-build-nu $flags
-    } else if $target == 'riscv64gc-unknown-linux-gnu' {
-        sudo apt-get install gcc-riscv64-linux-gnu -y
-        let-env CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER = 'riscv64-linux-gnu-gcc'
-        cargo-build-nu $flags
     } else {
         # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
         # Actually just for x86_64-unknown-linux-musl target
-        if $os == $USE_UBUNTU { sudo apt install musl-tools -y }
+        sudo apt install musl-tools -y
         cargo-build-nu $flags
     }
 }
@@ -75,10 +50,10 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
 # Build for Windows without static-link-openssl feature
 # ----------------------------------------------------------------------------
 if $os in ['windows-latest'] {
-    if ($flags | str trim | is-empty) {
-        cargo build --release --all --target $target
+    if ($flags | str trim | empty?) {
+        cargo build --release --all --target $target --features=extra
     } else {
-        cargo build --release --all --target $target $flags
+        cargo build --release --all --target $target --features=extra $flags
     }
 }
 
@@ -101,11 +76,11 @@ cp -v README.release.txt $'($dist)/README.txt'
 
 $'(char nl)Check binary release version detail:'; hr-line
 let ver = if $os == 'windows-latest' {
-    (do -i { ./output/nu.exe -c 'version' }) | str join
+    (do -i { ./output/nu.exe -c 'version' }) | str collect
 } else {
-    (do -i { ./output/nu -c 'version' }) | str join
+    (do -i { ./output/nu -c 'version' }) | str collect
 }
-if ($ver | str trim | is-empty) {
+if ($ver | str trim | empty?) {
     $'(ansi r)Incompatible nu binary...(ansi reset)'
 } else { $ver }
 
@@ -113,28 +88,21 @@ if ($ver | str trim | is-empty) {
 # Create a release archive and send it to output for the following steps
 # ----------------------------------------------------------------------------
 cd $dist; $'(char nl)Creating release archive...'; hr-line
-if $os in [$USE_UBUNTU, 'macos-latest'] {
+if $os in ['ubuntu-latest', 'macos-latest'] {
 
-    let files = (ls | get name)
-    let dest = $'($bin)-($version)-($target)'
-    let archive = $'($dist)/($dest).tar.gz'
+    $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
 
-    mkdir $dest
-    $files | each {|it| mv $it $dest } | ignore
-
-    $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls $dest
-
-    tar -czf $archive $dest
+    let archive = $'($dist)/($bin)-($version)-($target).tar.gz'
+    tar czf $archive *
     print $'archive: ---> ($archive)'; ls $archive
-    # REF: https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/
-    echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
+    echo $'::set-output name=archive::($archive)'
 
 } else if $os == 'windows-latest' {
 
     let releaseStem = $'($bin)-($version)-($target)'
 
     $'(char nl)Download less related stuffs...'; hr-line
-    aria2c https://github.com/jftuga/less-Windows/releases/download/less-v608/less.exe -o less.exe
+    aria2c https://github.com/jftuga/less-Windows/releases/download/less-v590/less.exe -o less.exe
     aria2c https://raw.githubusercontent.com/jftuga/less-Windows/master/LICENSE -o LICENSE-for-less.txt
 
     # Create Windows msi release package
@@ -145,10 +113,9 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
         cd $src; hr-line
         # Wix need the binaries be stored in target/release/
         cp -r $'($dist)/*' target/release/
-        cargo install cargo-wix --version 0.3.3
+        cargo install cargo-wix --version 0.3.2
         cargo wix --no-build --nocapture --package nu --output $wixRelease
-        print $'archive: ---> ($wixRelease)';
-        echo $"archive=($wixRelease)" | save --append $env.GITHUB_OUTPUT
+        echo $'::set-output name=archive::($wixRelease)'
 
     } else {
 
@@ -157,17 +124,17 @@ if $os in [$USE_UBUNTU, 'macos-latest'] {
         7z a $archive *
         print $'archive: ---> ($archive)';
         let pkg = (ls -f $archive | get name)
-        if not ($pkg | is-empty) {
-            echo $"archive=($pkg | get 0)" | save --append $env.GITHUB_OUTPUT
+        if not ($pkg | empty?) {
+            echo $'::set-output name=archive::($pkg | get 0)'
         }
     }
 }
 
 def 'cargo-build-nu' [ options: string ] {
-    if ($options | str trim | is-empty) {
-        cargo build --release --all --target $target --features=static-link-openssl
+    if ($options | str trim | empty?) {
+        cargo build --release --all --target $target --features=extra,static-link-openssl
     } else {
-        cargo build --release --all --target $target --features=static-link-openssl $options
+        cargo build --release --all --target $target --features=extra,static-link-openssl $options
     }
 }
 
@@ -176,7 +143,7 @@ def 'hr-line' [
     --blank-line(-b): bool
 ] {
     print $'(ansi g)---------------------------------------------------------------------------->(ansi reset)'
-    if $blank_line { char nl }
+    if $blank-line { char nl }
 }
 
 # Get the specified env key's value or ''

.github/workflows/release.yml

@@ -27,7 +27,6 @@ jobs:
         - x86_64-unknown-linux-musl
         - aarch64-unknown-linux-gnu
         - armv7-unknown-linux-gnueabihf
-        - riscv64gc-unknown-linux-gnu
         extra: ['bin']
         include:
         - target: aarch64-apple-darwin
@@ -45,37 +44,35 @@ jobs:
           os: windows-latest
           target_rustflags: ''
         - target: x86_64-unknown-linux-gnu
-          os: ubuntu-20.04
+          os: ubuntu-latest
           target_rustflags: ''
         - target: x86_64-unknown-linux-musl
-          os: ubuntu-20.04
+          os: ubuntu-latest
           target_rustflags: ''
         - target: aarch64-unknown-linux-gnu
-          os: ubuntu-20.04
+          os: ubuntu-latest
           target_rustflags: ''
         - target: armv7-unknown-linux-gnueabihf
-          os: ubuntu-20.04
-          target_rustflags: ''
-        - target: riscv64gc-unknown-linux-gnu
-          os: ubuntu-20.04
+          os: ubuntu-latest
           target_rustflags: ''
 
     runs-on: ${{matrix.os}}
 
     steps:
-    - uses: actions/checkout@v3.1.0
+    - uses: actions/checkout@v3.0.2
 
-    - name: Update Rust Toolchain Target
-      run: |
-        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
-
-    - name: Setup Rust toolchain and cache
-      uses: actions-rust-lang/setup-rust-toolchain@v1.3.4
+    - name: Install Rust Toolchain Components
+      uses: actions-rs/toolchain@v1.0.6
+      with:
+        override: true
+        profile: minimal
+        toolchain: stable
+        target: ${{ matrix.target }}
 
     - name: Setup Nushell
-      uses: hustcer/setup-nu@v3
+      uses: hustcer/setup-nu@v1
       with:
-        version: 0.72.1
+        version: 0.63.0
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -91,7 +88,7 @@ jobs:
 
     # REF: https://github.com/marketplace/actions/gh-release
     - name: Publish Archive
-      uses: softprops/action-gh-release@v0.1.13
+      uses: softprops/action-gh-release@v1
       if: ${{ startsWith(github.ref, 'refs/tags/') }}
       with:
         draft: true

.github/workflows/winget-submission.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       - name: Submit package to Windows Package Manager Community Repository
         run: |
-          iwr https://github.com/microsoft/winget-create/releases/download/v1.0.4.0/wingetcreate.exe -OutFile wingetcreate.exe
+          iwr https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
           $github = Get-Content '${{ github.event_path }}' | ConvertFrom-Json
           $installerUrl = $github.release.assets | Where-Object -Property name -match 'windows-msvc.msi' | Select -ExpandProperty browser_download_url -First 1
           .\wingetcreate.exe update Nushell.Nushell -s -v $github.release.tag_name -u $installerUrl -t ${{ secrets.NUSHELL_PAT }}

.gitignore

@@ -22,10 +22,6 @@ debian/nu/
 # VSCode's IDE items
 .vscode/*
 
-# Visual Studio Extension SourceGear Rust items
-VSWorkspaceSettings.json
-unstable_cargo_features.txt
-
 # Helix configuration folder
 .helix/*
 .helix
@@ -33,9 +29,3 @@ unstable_cargo_features.txt
 # Coverage tools
 lcov.info
 tarpaulin-report.html
-
-# Visual Studio
-.vs/*
-*.rsproj
-*.rsproj.user
-*.sln

CONTRIBUTING.md

@@ -1,23 +1,8 @@
 # Contributing
 
-Welcome to Nushell and thank you for considering contributing!
+Welcome to Nushell!
 
-## Review Process
-
-First of all, before diving into the code, if you want to create a new feature, change something significantly, and especially if the change is user-facing, it is a good practice to first get an approval from the core team before starting to work on it.
-This saves both your and our time if we realize the change needs to go another direction before spending time on it.
-So, please, reach out and tell us what you want to do.
-This will significantly increase the chance of your PR being accepted.
-
-The review process can be summarized as follows:
-1. You want to make some change to Nushell that is more involved than simple bug-fixing.
-2. Go to [Discord](https://discordapp.com/invite/NtAbbGn) or a [GitHub issue](https://github.com/nushell/nushell/issues/new/choose) and chat with some core team members and/or other contributors about it.
-3. After getting a green light from the core team, implement the feature, open a pull request (PR) and write a concise but comprehensive description of the change.
-4. If your PR includes any use-facing features (such as adding a flag to a command), clearly list them in the PR description.
-5. Then, core team members and other regular contributors will review the PR and suggest changes.
-6. When we all agree, the PR will be merged.
-7. If your PR includes any user-facing features, make sure the changes are also reflected in [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged.
-8. Congratulate yourself, you just improved 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)!
 
 ## Developing
 
@@ -31,18 +16,6 @@ cd nushell
 cargo build
 ```
 
-### Tests
-
-It is a good practice to cover your changes with a test. Also, try to think about corner cases and various ways how your changes could break. Cover those in the tests as well.
-
-Tests can be found in different places:
-* `/tests`
-* `src/tests`
-* command examples
-* crate-specific tests
-
-The most comprehensive test suite we have is the `nu-test-support` crate. For testing specific features, such as running Nushell in a REPL mode, we have so called "testbins". For simple tests, you can find `run_test()` and `fail_test()` functions.
-
 ### Useful Commands
 
 - Build and run Nushell:
@@ -51,21 +24,21 @@ The most comprehensive test suite we have is the `nu-test-support` crate. For te
   cargo run
   ```
 
-- Build and run with dataframe support.
+- Build and run with extra features. Currently extra features include dataframes and sqlite database support.
   ```shell
-  cargo run --features=dataframe
+  cargo run --features=extra
   ```
 
 - Run Clippy on Nushell:
 
   ```shell
-  cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+  cargo clippy --workspace --features=extra -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
   ```
 
 - Run all tests:
 
   ```shell
-  cargo test --workspace
+  cargo test --workspace --features=extra
   ```
 
 - Run all tests for a specific command
@@ -91,11 +64,5 @@ The most comprehensive test suite we have is the `nu-test-support` crate. For te
 - To view verbose logs when developing, enable the `trace` log level.
 
   ```shell
-  cargo run --release -- --log-level trace
-  ```
-
-- To redirect trace logs to a file, enable the `--log-target file` switch.
-  ```shell
-  cargo run --release -- --log-level trace --log-target file
-  open $"($nu.temp-path)/nu-($nu.pid).log"
+  cargo run --release --features=extra -- --log-level trace
   ```

Cargo.toml

@@ -8,19 +8,13 @@ exclude = ["images"]
 homepage = "https://www.nushell.sh"
 license = "MIT"
 name = "nu"
+readme = "README.md"
 repository = "https://github.com/nushell/nushell"
 rust-version = "1.60"
-version = "0.73.0"
+version = "0.66.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[package.metadata.binstall]
-pkg-url = "{ repo }/releases/download/{ version }/{ name }-{ version }-{ target }.{ archive-format }"
-pkg-fmt = "tgz"
-
-[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
-pkg-fmt = "zip"
-
 [workspace]
 members = [
 	"crates/nu-cli",
@@ -39,64 +33,55 @@ members = [
 ]
 
 [dependencies]
-chrono = { version = "0.4.23", features = ["serde"] }
-crossterm = "0.24.0"
+chrono = { version = "0.4.19", features = ["serde"] }
+crossterm = "0.23.0"
 ctrlc = "3.2.1"
 log = "0.4"
-miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
+miette = "5.1.0"
 nu-ansi-term = "0.46.0"
-nu-cli = { path="./crates/nu-cli", version = "0.73.0"  }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.73.0"  }
-nu-command = { path="./crates/nu-command", version = "0.73.0"  }
-nu-engine = { path="./crates/nu-engine", version = "0.73.0"  }
-nu-json = { path="./crates/nu-json", version = "0.73.0"  }
-nu-parser = { path="./crates/nu-parser", version = "0.73.0"  }
-nu-path = { path="./crates/nu-path", version = "0.73.0"  }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.73.0"  }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.73.0"  }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.73.0"  }
-nu-system = { path = "./crates/nu-system", version = "0.73.0" }
-nu-table = { path = "./crates/nu-table", version = "0.73.0"  }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.73.0"  }
-nu-utils = { path = "./crates/nu-utils", version = "0.73.0"  }
-reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
-
+nu-cli = { path="./crates/nu-cli", version = "0.66.2"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.66.2"  }
+nu-command = { path="./crates/nu-command", version = "0.66.3"  }
+nu-engine = { path="./crates/nu-engine", version = "0.66.2"  }
+nu-json = { path="./crates/nu-json", version = "0.66.2"  }
+nu-parser = { path="./crates/nu-parser", version = "0.66.2"  }
+nu-path = { path="./crates/nu-path", version = "0.66.2"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.66.2"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.66.2"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.66.2"  }
+nu-system = { path = "./crates/nu-system", version = "0.66.2" }
+nu-table = { path = "./crates/nu-table", version = "0.66.2"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.66.2"  }
+nu-utils = { path = "./crates/nu-utils", version = "0.66.2"  }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
+pretty_env_logger = "0.4.0"
 rayon = "1.5.1"
 is_executable = "1.0.1"
-simplelog = "0.12.0"
-time = "0.3.12"
 
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 # Our dependencies don't use OpenSSL on Windows
 openssl = { version = "0.10.38", features = ["vendored"], optional = true }
 signal-hook = { version = "0.3.14", default-features = false }
 
-
-[target.'cfg(windows)'.build-dependencies]
-winres = "0.1"
-
-[target.'cfg(target_family = "unix")'.dependencies]
-nix = { version = "0.25", default-features = false, features = ["signal", "process", "fs", "term"]}
-atty = "0.2"
-
 [dev-dependencies]
-nu-test-support = { path="./crates/nu-test-support", version = "0.73.0"  }
+nu-test-support = { path="./crates/nu-test-support", version = "0.66.2"  }
 tempfile = "3.2.0"
 assert_cmd = "2.0.2"
 pretty_assertions = "1.0.0"
 serial_test = "0.8.0"
 hamcrest2 = "0.3.0"
-rstest = {version = "0.15.0", default-features = false}
+rstest = "0.15.0"
 itertools = "0.10.3"
 
+[target.'cfg(windows)'.build-dependencies]
+winres = "0.1"
+
 [features]
 plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]
-# extra used to be more useful but now it's the same as default. Leaving it in for backcompat with existing build scripts
-extra = ["default"]
-default = ["plugin", "which-support", "trash-support", "sqlite"]
+default = ["plugin", "which-support", "trash-support"]
 stable = ["default"]
+extra = ["default", "dataframe", "database"]
 wasi = []
-
 # Enable to statically link OpenSSL; otherwise the system version will be used. Not enabled by default because it takes a while to build
 static-link-openssl = ["dep:openssl"]
 
@@ -109,8 +94,8 @@ trash-support = ["nu-command/trash-support"]
 # Dataframe feature for nushell
 dataframe = ["nu-command/dataframe"]
 
-# SQLite commands for nushell
-sqlite = ["nu-command/sqlite"]
+# Database commands for nushell
+database = ["nu-command/database"]
 
 [profile.release]
 opt-level = "s" # Optimize for size
@@ -135,8 +120,3 @@ debug = false
 [[bin]]
 name = "nu"
 path = "src/main.rs"
-
-# To use a development version of a dependency please use a global override here
-# changing versions in each sub-crate of the workspace is tedious
-[patch.crates-io]
-# reedline = { git = "https://github.com/nushell/reedline.git", branch = "main" }

README.md

@@ -1,6 +1,6 @@
 # Nushell <!-- omit in toc -->
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
-![Build Status](https://img.shields.io/github/actions/workflow/status/nushell/nushell/ci.yml?branch=main)
+![Build Status](https://img.shields.io/github/workflow/status/nushell/nushell/continuous-integration)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
 [![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
@@ -71,7 +71,7 @@ Additionally, commands can output structured data (you can think of this as a th
 Commands that work in the pipeline fit into one of three categories:
 
 -   Commands that produce a stream (e.g., `ls`)
--   Commands that filter a stream (e.g., `where type == "dir"`)
+-   Commands that filter a stream (eg, `where type == "dir"`)
 -   Commands that consume the output of the pipeline (e.g., `table`)
 
 Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing left to right.
@@ -126,13 +126,12 @@ For example, you can load a .toml file as structured data and explore it:
 > open Cargo.toml
 ╭──────────────────┬────────────────────╮
 │ bin              │ [table 1 row]      │
-│ dependencies     │ {record 25 fields} │
+│ dependencies     │ {record 24 fields} │
 │ dev-dependencies │ {record 8 fields}  │
 │ features         │ {record 10 fields} │
 │ package          │ {record 13 fields} │
-│ patch            │ {record 1 field}   │
 │ profile          │ {record 3 fields}  │
-│ target           │ {record 3 fields}  │
+│ target           │ {record 2 fields}  │
 │ workspace        │ {record 1 field}   │
 ╰──────────────────┴────────────────────╯
 ```
@@ -150,11 +149,11 @@ We can pipe this into a command that gets the contents of one of the columns:
 │ exclude       │ [list 1 item]                      │
 │ homepage      │ https://www.nushell.sh             │
 │ license       │ MIT                                │
-│ metadata      │ {record 1 field}                   │
 │ name          │ nu                                 │
+│ readme        │ README.md                          │
 │ repository    │ https://github.com/nushell/nushell │
 │ rust-version  │ 1.60                               │
-│ version       │ 0.72.0                             │
+│ version       │ 0.63.1                             │
 ╰───────────────┴────────────────────────────────────╯
 ```
 
@@ -162,7 +161,7 @@ And if needed we can drill down further:
 
 ```shell
 > open Cargo.toml | get package.version
-0.72.0
+0.63.1
 ```
 
 ### Plugins
@@ -207,7 +206,7 @@ Nu is under heavy development and will naturally change as it matures. The chart
 | Functions     |             |           |     |    X    |        | Functions and aliases are supported                                  |
 | Variables     |             |           |     |    X    |        | Nu supports variables and environment variables                      |
 | Completions   |             |           |     |    X    |        | Completions for filepaths                                            |
-| Type-checking |             |           |     |    x    |        | Commands check basic types, and input/output types                   |
+| Type-checking |             |           |  X  |         |        | Commands check basic types, but input/output isn't checked           |
 
 ## Officially Supported By
 

README.release.txt

@@ -1,3 +1,3 @@
 To use Nu plugins, use the register command to tell Nu where to find the plugin. For example:
 
-> register ./nu_plugin_query
+> register -e json ./nu_plugin_query

build-all-maclin.sh

@@ -1,8 +1,7 @@
-#!/usr/bin/env bash
-set -euo pipefail
+#!/bin/sh
 
 echo "---------------------------------------------------------------"
-echo "Building nushell (nu) with dataframes and all the plugins"
+echo "Building nushell (nu) with --features=extra and all the plugins"
 echo "---------------------------------------------------------------"
 echo ""
 
@@ -11,14 +10,13 @@ NU_PLUGINS=(
     'nu_plugin_gstat'
     'nu_plugin_inc'
     'nu_plugin_query'
-    'nu_plugin_custom_values'
 )
 
 echo "Building nushell"
-cargo build --features=dataframe
+cargo build --features=extra
 for plugin in "${NU_PLUGINS[@]}"
 do
-    echo '' && cd crates/"$plugin"
+    echo '' && cd crates/$plugin
     echo "Building $plugin..."
     echo "-----------------------------"
     cargo build && cd ../..

build-all-windows.cmd

@@ -1,11 +1,11 @@
 @echo off
 @echo -------------------------------------------------------------------
-@echo Building nushell (nu.exe) with dataframes and all the plugins
+@echo Building nushell (nu.exe) with --features=extra and all the plugins
 @echo -------------------------------------------------------------------
 @echo.
 
 echo Building nushell.exe
-cargo build cargo build --features=dataframe
+cargo build --features=extra
 @echo.
 
 @cd crates\nu_plugin_example
@@ -24,13 +24,9 @@ cargo build
 @echo.
 
 @cd ..\..\crates\nu_plugin_query
+
 echo Building nu_plugin_query.exe
 cargo build
 @echo.
 
-@cd ..\..\crates\nu_plugin_custom_values
-echo Building nu_plugin_custom_values.exe
-cargo build
-@echo.
-
 @cd ..\..

build-all.nu

@@ -1,17 +1,16 @@
 echo '-------------------------------------------------------------------'
-echo 'Building nushell (nu) with dataframes and all the plugins'
+echo 'Building nushell (nu) with --features=extra and all the plugins'
 echo '-------------------------------------------------------------------'
 
 echo $'(char nl)Building nushell'
 echo '----------------------------'
-cargo build --features=dataframe
+cargo build --features=extra
 
 let plugins = [
     nu_plugin_inc,
     nu_plugin_gstat,
     nu_plugin_query,
     nu_plugin_example,
-    nu_plugin_custom_values,
 ]
 
 for plugin in $plugins {

crates/nu-cli/Cargo.toml

@@ -1,39 +1,36 @@
 [package]
 authors = ["The Nushell Project Developers"]
 description = "CLI-related functionality for Nushell"
-repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.73.0"
+version = "0.66.2"
 
 [dev-dependencies]
-nu-test-support = { path="../nu-test-support", version = "0.73.0"  }
-nu-command = { path = "../nu-command", version = "0.73.0" }
-rstest = {version = "0.15.0", default-features = false}
+nu-test-support = { path="../nu-test-support", version = "0.66.2"  }
+nu-command = { path = "../nu-command", version = "0.66.2" }
+rstest = "0.15.0"
 
 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.73.0"  }
-nu-path = { path = "../nu-path", version = "0.73.0"  }
-nu-parser = { path = "../nu-parser", version = "0.73.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.73.0"  }
-nu-utils = { path = "../nu-utils", version = "0.73.0"  }
+nu-engine = { path = "../nu-engine", version = "0.66.2"  }
+nu-path = { path = "../nu-path", version = "0.66.2"  }
+nu-parser = { path = "../nu-parser", version = "0.66.2"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.2"  }
+nu-utils = { path = "../nu-utils", version = "0.66.2"  }
 nu-ansi-term = "0.46.0"
-nu-color-config = { path = "../nu-color-config", version = "0.73.0"  }
-reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
-
-atty = "0.2.14"
-chrono = { default-features = false, features = ["std"], version = "0.4.23" }
-crossterm = "0.24.0"
-fancy-regex = "0.10.0"
-fuzzy-matcher = "0.3.7"
-is_executable = "1.0.1"
-once_cell = "1.16.0"
-log = "0.4"
-miette = { version = "5.1.0", features = ["fancy-no-backtrace"] }
-percent-encoding = "2"
-sysinfo = "0.26.2"
+nu-color-config = { path = "../nu-color-config", version = "0.66.2"  }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
+crossterm = "0.23.0"
+miette = { version = "5.1.0", features = ["fancy"] }
 thiserror = "1.0.31"
+fuzzy-matcher = "0.3.7"
+
+chrono = "0.4.19"
+is_executable = "1.0.1"
+lazy_static = "1.4.0"
+log = "0.4"
+regex = "1.5.4"
+sysinfo = "0.24.1"
 
 [features]
 plugin = []

crates/nu-cli/src/commands.rs

@@ -15,6 +15,7 @@ pub fn evaluate_commands(
     engine_state: &mut EngineState,
     stack: &mut Stack,
     input: PipelineData,
+    is_perf_true: bool,
     table_mode: Option<Value>,
 ) -> Result<Option<i64>> {
     // Translate environment variables from Strings to Values
@@ -67,7 +68,9 @@ pub fn evaluate_commands(
         }
     };
 
-    info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
 
     Ok(exit_code)
 }

crates/nu-cli/src/completions/command_completions.rs

@@ -11,7 +11,6 @@ pub struct CommandCompletion {
     engine_state: Arc<EngineState>,
     flattened: Vec<(Span, FlatShape)>,
     flat_shape: FlatShape,
-    force_completion_after_space: bool,
 }
 
 impl CommandCompletion {
@@ -20,13 +19,11 @@ impl CommandCompletion {
         _: &StateWorkingSet,
         flattened: Vec<(Span, FlatShape)>,
         flat_shape: FlatShape,
-        force_completion_after_space: bool,
     ) -> Self {
         Self {
             engine_state,
             flattened,
             flat_shape,
-            force_completion_after_space,
         }
     }
 
@@ -60,7 +57,7 @@ impl CommandCompletion {
                                         .matches_str(&x.to_string_lossy(), prefix)),
                                     Some(true)
                                 )
-                                && is_executable::is_executable(item.path())
+                                && is_executable::is_executable(&item.path())
                             {
                                 if let Ok(name) = item.file_name().into_string() {
                                     executables.push(name);
@@ -94,7 +91,10 @@ impl CommandCompletion {
                 value: String::from_utf8_lossy(&x.0).to_string(),
                 description: x.1,
                 extra: None,
-                span: reedline::Span::new(span.start - offset, span.end - offset),
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
                 append_whitespace: true,
             });
 
@@ -105,7 +105,10 @@ impl CommandCompletion {
                 value: String::from_utf8_lossy(&x).to_string(),
                 description: None,
                 extra: None,
-                span: reedline::Span::new(span.start - offset, span.end - offset),
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
                 append_whitespace: true,
             });
 
@@ -113,8 +116,7 @@ impl CommandCompletion {
 
         let partial = working_set.get_span_contents(span);
         let partial = String::from_utf8_lossy(partial).to_string();
-
-        if find_externals {
+        let results = if find_externals {
             let results_external = self
                 .external_command_completion(&partial, match_algorithm)
                 .into_iter()
@@ -122,15 +124,15 @@ impl CommandCompletion {
                     value: x,
                     description: None,
                     extra: None,
-                    span: reedline::Span::new(span.start - offset, span.end - offset),
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
                     append_whitespace: true,
                 });
 
-            let results_strings: Vec<String> =
-                results.clone().into_iter().map(|x| x.value).collect();
-
             for external in results_external {
-                if results_strings.contains(&external.value) {
+                if results.contains(&external) {
                     results.push(Suggestion {
                         value: format!("^{}", external.value),
                         description: None,
@@ -146,7 +148,9 @@ impl CommandCompletion {
             results
         } else {
             results
-        }
+        };
+
+        results
     }
 }
 
@@ -181,7 +185,10 @@ impl Completer for CommandCompletion {
         let subcommands = if let Some(last) = last {
             self.complete_commands(
                 working_set,
-                Span::new(last.0.start, pos),
+                Span {
+                    start: last.0.start,
+                    end: pos,
+                },
                 offset,
                 false,
                 options.match_algorithm,
@@ -200,10 +207,6 @@ impl Completer for CommandCompletion {
             || ((span.end - span.start) == 0)
         {
             // we're in a gap or at a command
-            if working_set.get_span_contents(span).is_empty() && !self.force_completion_after_space
-            {
-                return vec![];
-            }
             self.complete_commands(
                 working_set,
                 span,

crates/nu-cli/src/completions/completer.rs

@@ -2,12 +2,10 @@ use crate::completions::{
     CommandCompletion, Completer, CompletionOptions, CustomCompletion, DirectoryCompletion,
     DotNuCompletion, FileCompletion, FlagCompletion, MatchAlgorithm, VariableCompletion,
 };
-use nu_engine::eval_block;
 use nu_parser::{flatten_expression, parse, FlatShape};
 use nu_protocol::{
-    ast::PipelineElement,
     engine::{EngineState, Stack, StateWorkingSet},
-    BlockId, PipelineData, Span, Value,
+    Span,
 };
 use reedline::{Completer as ReedlineCompleter, Suggestion};
 use std::str;
@@ -58,124 +56,98 @@ impl NuCompleter {
         suggestions
     }
 
-    fn external_completion(
-        &self,
-        block_id: BlockId,
-        spans: &[String],
-        offset: usize,
-        span: Span,
-    ) -> Option<Vec<Suggestion>> {
-        let stack = self.stack.clone();
-        let block = self.engine_state.get_block(block_id);
-        let mut callee_stack = stack.gather_captures(&block.captures);
-
-        // Line
-        if let Some(pos_arg) = block.signature.required_positional.get(0) {
-            if let Some(var_id) = pos_arg.var_id {
-                callee_stack.add_var(
-                    var_id,
-                    Value::List {
-                        vals: spans
-                            .iter()
-                            .map(|it| Value::string(it, Span::unknown()))
-                            .collect(),
-                        span: Span::unknown(),
-                    },
-                );
-            }
-        }
-
-        let result = eval_block(
-            &self.engine_state,
-            &mut callee_stack,
-            block,
-            PipelineData::empty(),
-            true,
-            true,
-        );
-
-        match result {
-            Ok(pd) => {
-                let value = pd.into_value(span);
-                if let Value::List { vals, span: _ } = value {
-                    let result =
-                        map_value_completions(vals.iter(), Span::new(span.start, span.end), offset);
-
-                    return Some(result);
-                }
-            }
-            Err(err) => println!("failed to eval completer block: {}", err),
-        }
-
-        None
-    }
-
     fn completion_helper(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
         let mut working_set = StateWorkingSet::new(&self.engine_state);
         let offset = working_set.next_span_start();
         let (mut new_line, alias_offset) = try_find_alias(line.as_bytes(), &working_set);
         let initial_line = line.to_string();
-        let alias_total_offset: usize = alias_offset.iter().sum();
-        new_line.insert(alias_total_offset + pos, b'a');
+        new_line.push(b'a');
         let pos = offset + pos;
-        let config = self.engine_state.get_config();
-
         let (output, _err) = parse(&mut working_set, Some("completer"), &new_line, false, &[]);
 
         for pipeline in output.pipelines.into_iter() {
-            for pipeline_element in pipeline.elements {
-                match pipeline_element {
-                    PipelineElement::Expression(_, expr)
-                    | PipelineElement::Redirection(_, _, expr)
-                    | PipelineElement::And(_, expr)
-                    | PipelineElement::Or(_, expr) => {
-                        let flattened: Vec<_> = flatten_expression(&working_set, &expr);
-                        let span_offset: usize = alias_offset.iter().sum();
-                        let mut spans: Vec<String> = vec![];
+            for expr in pipeline.expressions {
+                let flattened: Vec<_> = flatten_expression(&working_set, &expr);
+                let span_offset: usize = alias_offset.iter().sum();
 
-                        for (flat_idx, flat) in flattened.iter().enumerate() {
-                            // Read the current spam to string
-                            let current_span = working_set.get_span_contents(flat.0).to_vec();
-                            let current_span_str = String::from_utf8_lossy(&current_span);
+                for (flat_idx, flat) in flattened.iter().enumerate() {
+                    if pos + span_offset >= flat.0.start && pos + span_offset < flat.0.end {
+                        // Context variables
+                        let most_left_var =
+                            most_left_variable(flat_idx, &working_set, flattened.clone());
 
-                            // Skip the last 'a' as span item
-                            if flat_idx == flattened.len() - 1 {
-                                let mut chars = current_span_str.chars();
-                                chars.next_back();
-                                let current_span_str = chars.as_str().to_owned();
-                                spans.push(current_span_str.to_string());
-                            } else {
-                                spans.push(current_span_str.to_string());
+                        // Create a new span
+                        let new_span = if flat_idx == 0 {
+                            Span {
+                                start: flat.0.start,
+                                end: flat.0.end - 1 - span_offset,
                             }
+                        } else {
+                            Span {
+                                start: flat.0.start - span_offset,
+                                end: flat.0.end - 1 - span_offset,
+                            }
+                        };
 
-                            // Complete based on the last span
-                            if pos + span_offset >= flat.0.start && pos + span_offset < flat.0.end {
-                                // Context variables
-                                let most_left_var =
-                                    most_left_variable(flat_idx, &working_set, flattened.clone());
+                        // Parses the prefix
+                        let mut prefix = working_set.get_span_contents(flat.0).to_vec();
+                        prefix.remove(pos - (flat.0.start - span_offset));
 
-                                // Create a new span
-                                let new_span = if flat_idx == 0 {
-                                    Span::new(flat.0.start, flat.0.end - 1 - span_offset)
-                                } else {
-                                    Span::new(
-                                        flat.0.start - span_offset,
-                                        flat.0.end - 1 - span_offset,
-                                    )
-                                };
+                        // Variables completion
+                        if prefix.starts_with(b"$") || most_left_var.is_some() {
+                            let mut completer = VariableCompletion::new(
+                                self.engine_state.clone(),
+                                self.stack.clone(),
+                                most_left_var.unwrap_or((vec![], vec![])),
+                            );
 
-                                // Parses the prefix. Completion should look up to the cursor position, not after.
-                                let mut prefix = working_set.get_span_contents(flat.0).to_vec();
-                                let index = pos - (flat.0.start - span_offset);
-                                prefix.drain(index..);
+                            return self.process_completion(
+                                &mut completer,
+                                &working_set,
+                                prefix,
+                                new_span,
+                                offset,
+                                pos,
+                            );
+                        }
 
-                                // Variables completion
-                                if prefix.starts_with(b"$") || most_left_var.is_some() {
-                                    let mut completer = VariableCompletion::new(
-                                        self.engine_state.clone(),
-                                        self.stack.clone(),
-                                        most_left_var.unwrap_or((vec![], vec![])),
+                        // Flags completion
+                        if prefix.starts_with(b"-") {
+                            let mut completer = FlagCompletion::new(expr);
+
+                            return self.process_completion(
+                                &mut completer,
+                                &working_set,
+                                prefix,
+                                new_span,
+                                offset,
+                                pos,
+                            );
+                        }
+
+                        // Completions that depends on the previous expression (e.g: use, source)
+                        if flat_idx > 0 {
+                            if let Some(previous_expr) = flattened.get(flat_idx - 1) {
+                                // Read the content for the previous expression
+                                let prev_expr_str =
+                                    working_set.get_span_contents(previous_expr.0).to_vec();
+
+                                // Completion for .nu files
+                                if prev_expr_str == b"use" || prev_expr_str == b"source" {
+                                    let mut completer =
+                                        DotNuCompletion::new(self.engine_state.clone());
+
+                                    return self.process_completion(
+                                        &mut completer,
+                                        &working_set,
+                                        prefix,
+                                        new_span,
+                                        offset,
+                                        pos,
                                     );
+                                } else if prev_expr_str == b"ls" {
+                                    let mut completer =
+                                        FileCompletion::new(self.engine_state.clone());
 
                                     return self.process_completion(
                                         &mut completer,
@@ -186,196 +158,94 @@ impl NuCompleter {
                                         pos,
                                     );
                                 }
-
-                                // Flags completion
-                                if prefix.starts_with(b"-") {
-                                    // Try to complete flag internally
-                                    let mut completer = FlagCompletion::new(expr.clone());
-                                    let result = self.process_completion(
-                                        &mut completer,
-                                        &working_set,
-                                        prefix.clone(),
-                                        new_span,
-                                        offset,
-                                        pos,
-                                    );
-
-                                    if !result.is_empty() {
-                                        return result;
-                                    }
-
-                                    // We got no results for internal completion
-                                    // now we can check if external completer is set and use it
-                                    if let Some(block_id) = config.external_completer {
-                                        if let Some(external_result) = self
-                                            .external_completion(block_id, &spans, offset, new_span)
-                                        {
-                                            return external_result;
-                                        }
-                                    }
-                                }
-
-                                // specially check if it is currently empty - always complete commands
-                                if flat_idx == 0
-                                    && working_set.get_span_contents(new_span).is_empty()
-                                {
-                                    let mut completer = CommandCompletion::new(
-                                        self.engine_state.clone(),
-                                        &working_set,
-                                        flattened.clone(),
-                                        // flat_idx,
-                                        FlatShape::String,
-                                        true,
-                                    );
-                                    return self.process_completion(
-                                        &mut completer,
-                                        &working_set,
-                                        prefix,
-                                        new_span,
-                                        offset,
-                                        pos,
-                                    );
-                                }
-
-                                // Completions that depends on the previous expression (e.g: use, source-env)
-                                if flat_idx > 0 {
-                                    if let Some(previous_expr) = flattened.get(flat_idx - 1) {
-                                        // Read the content for the previous expression
-                                        let prev_expr_str =
-                                            working_set.get_span_contents(previous_expr.0).to_vec();
-
-                                        // Completion for .nu files
-                                        if prev_expr_str == b"use" || prev_expr_str == b"source-env"
-                                        {
-                                            let mut completer =
-                                                DotNuCompletion::new(self.engine_state.clone());
-
-                                            return self.process_completion(
-                                                &mut completer,
-                                                &working_set,
-                                                prefix,
-                                                new_span,
-                                                offset,
-                                                pos,
-                                            );
-                                        } else if prev_expr_str == b"ls" {
-                                            let mut completer =
-                                                FileCompletion::new(self.engine_state.clone());
-
-                                            return self.process_completion(
-                                                &mut completer,
-                                                &working_set,
-                                                prefix,
-                                                new_span,
-                                                offset,
-                                                pos,
-                                            );
-                                        }
-                                    }
-                                }
-
-                                // Match other types
-                                match &flat.1 {
-                                    FlatShape::Custom(decl_id) => {
-                                        let mut completer = CustomCompletion::new(
-                                            self.engine_state.clone(),
-                                            self.stack.clone(),
-                                            *decl_id,
-                                            initial_line,
-                                        );
-
-                                        return self.process_completion(
-                                            &mut completer,
-                                            &working_set,
-                                            prefix,
-                                            new_span,
-                                            offset,
-                                            pos,
-                                        );
-                                    }
-                                    FlatShape::Directory => {
-                                        let mut completer =
-                                            DirectoryCompletion::new(self.engine_state.clone());
-
-                                        return self.process_completion(
-                                            &mut completer,
-                                            &working_set,
-                                            prefix,
-                                            new_span,
-                                            offset,
-                                            pos,
-                                        );
-                                    }
-                                    FlatShape::Filepath | FlatShape::GlobPattern => {
-                                        let mut completer =
-                                            FileCompletion::new(self.engine_state.clone());
-
-                                        return self.process_completion(
-                                            &mut completer,
-                                            &working_set,
-                                            prefix,
-                                            new_span,
-                                            offset,
-                                            pos,
-                                        );
-                                    }
-                                    flat_shape => {
-                                        let mut completer = CommandCompletion::new(
-                                            self.engine_state.clone(),
-                                            &working_set,
-                                            flattened.clone(),
-                                            // flat_idx,
-                                            flat_shape.clone(),
-                                            false,
-                                        );
-
-                                        let mut out: Vec<_> = self.process_completion(
-                                            &mut completer,
-                                            &working_set,
-                                            prefix.clone(),
-                                            new_span,
-                                            offset,
-                                            pos,
-                                        );
-
-                                        if !out.is_empty() {
-                                            return out;
-                                        }
-
-                                        // Try to complete using an external completer (if set)
-                                        if let Some(block_id) = config.external_completer {
-                                            if let Some(external_result) = self.external_completion(
-                                                block_id, &spans, offset, new_span,
-                                            ) {
-                                                return external_result;
-                                            }
-                                        }
-
-                                        // Check for file completion
-                                        let mut completer =
-                                            FileCompletion::new(self.engine_state.clone());
-                                        out = self.process_completion(
-                                            &mut completer,
-                                            &working_set,
-                                            prefix,
-                                            new_span,
-                                            offset,
-                                            pos,
-                                        );
-
-                                        if !out.is_empty() {
-                                            return out;
-                                        }
-                                    }
-                                };
                             }
                         }
+
+                        // Match other types
+                        match &flat.1 {
+                            FlatShape::Custom(decl_id) => {
+                                let mut completer = CustomCompletion::new(
+                                    self.engine_state.clone(),
+                                    self.stack.clone(),
+                                    *decl_id,
+                                    initial_line,
+                                );
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
+                            FlatShape::Directory => {
+                                let mut completer =
+                                    DirectoryCompletion::new(self.engine_state.clone());
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
+                            FlatShape::Filepath | FlatShape::GlobPattern => {
+                                let mut completer = FileCompletion::new(self.engine_state.clone());
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
+                            flat_shape => {
+                                let mut completer = CommandCompletion::new(
+                                    self.engine_state.clone(),
+                                    &working_set,
+                                    flattened.clone(),
+                                    // flat_idx,
+                                    flat_shape.clone(),
+                                );
+
+                                let out: Vec<_> = self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix.clone(),
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+
+                                if out.is_empty() {
+                                    let mut completer =
+                                        FileCompletion::new(self.engine_state.clone());
+
+                                    return self.process_completion(
+                                        &mut completer,
+                                        &working_set,
+                                        prefix,
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
+                                }
+
+                                return out;
+                            }
+                        };
                     }
                 }
             }
         }
 
-        vec![]
+        return vec![];
     }
 }
 
@@ -432,7 +302,7 @@ fn search_alias(input: &[u8], working_set: &StateWorkingSet) -> Option<MatchedAl
     }
     // Push the rest to names vector.
     if pos < input.len() {
-        vec_names.push(input[pos..].to_owned());
+        vec_names.push((&input[pos..]).to_owned());
     }
 
     for name in &vec_names {
@@ -513,65 +383,3 @@ fn most_left_variable(
 
     Some((var, sublevels))
 }
-
-pub fn map_value_completions<'a>(
-    list: impl Iterator<Item = &'a Value>,
-    span: Span,
-    offset: usize,
-) -> Vec<Suggestion> {
-    list.filter_map(move |x| {
-        // Match for string values
-        if let Ok(s) = x.as_string() {
-            return Some(Suggestion {
-                value: s,
-                description: None,
-                extra: None,
-                span: reedline::Span {
-                    start: span.start - offset,
-                    end: span.end - offset,
-                },
-                append_whitespace: false,
-            });
-        }
-
-        // Match for record values
-        if let Ok((cols, vals)) = x.as_record() {
-            let mut suggestion = Suggestion {
-                value: String::from(""), // Initialize with empty string
-                description: None,
-                extra: None,
-                span: reedline::Span {
-                    start: span.start - offset,
-                    end: span.end - offset,
-                },
-                append_whitespace: false,
-            };
-
-            // Iterate the cols looking for `value` and `description`
-            cols.iter().zip(vals).for_each(|it| {
-                // Match `value` column
-                if it.0 == "value" {
-                    // Convert the value to string
-                    if let Ok(val_str) = it.1.as_string() {
-                        // Update the suggestion value
-                        suggestion.value = val_str;
-                    }
-                }
-
-                // Match `description` column
-                if it.0 == "description" {
-                    // Convert the value to string
-                    if let Ok(desc_str) = it.1.as_string() {
-                        // Update the suggestion value
-                        suggestion.description = Some(desc_str);
-                    }
-                }
-            });
-
-            return Some(suggestion);
-        }
-
-        None
-    })
-    .collect()
-}

crates/nu-cli/src/completions/custom_completions.rs

@@ -8,8 +8,6 @@ use nu_protocol::{
 use reedline::Suggestion;
 use std::sync::Arc;
 
-use super::completer::map_value_completions;
-
 pub struct CustomCompletion {
     engine_state: Arc<EngineState>,
     stack: Stack,
@@ -28,6 +26,69 @@ impl CustomCompletion {
             sort_by: SortBy::None,
         }
     }
+
+    fn map_completions<'a>(
+        &self,
+        list: impl Iterator<Item = &'a Value>,
+        span: Span,
+        offset: usize,
+    ) -> Vec<Suggestion> {
+        list.filter_map(move |x| {
+            // Match for string values
+            if let Ok(s) = x.as_string() {
+                return Some(Suggestion {
+                    value: s,
+                    description: None,
+                    extra: None,
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                    append_whitespace: false,
+                });
+            }
+
+            // Match for record values
+            if let Ok((cols, vals)) = x.as_record() {
+                let mut suggestion = Suggestion {
+                    value: String::from(""), // Initialize with empty string
+                    description: None,
+                    extra: None,
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                    append_whitespace: false,
+                };
+
+                // Iterate the cols looking for `value` and `description`
+                cols.iter().zip(vals).for_each(|it| {
+                    // Match `value` column
+                    if it.0 == "value" {
+                        // Convert the value to string
+                        if let Ok(val_str) = it.1.as_string() {
+                            // Update the suggestion value
+                            suggestion.value = val_str;
+                        }
+                    }
+
+                    // Match `description` column
+                    if it.0 == "description" {
+                        // Convert the value to string
+                        if let Ok(desc_str) = it.1.as_string() {
+                            // Update the suggestion value
+                            suggestion.description = Some(desc_str);
+                        }
+                    }
+                });
+
+                return Some(suggestion);
+            }
+
+            None
+        })
+        .collect()
+    }
 }
 
 impl Completer for CustomCompletion {
@@ -52,13 +113,13 @@ impl Completer for CustomCompletion {
                 head: span,
                 arguments: vec![
                     Argument::Positional(Expression {
-                        span: Span::unknown(),
+                        span: Span { start: 0, end: 0 },
                         ty: Type::String,
                         expr: Expr::String(self.line.clone()),
                         custom_completion: None,
                     }),
                     Argument::Positional(Expression {
-                        span: Span::unknown(),
+                        span: Span { start: 0, end: 0 },
                         ty: Type::Int,
                         expr: Expr::Int(line_pos as i64),
                         custom_completion: None,
@@ -67,7 +128,7 @@ impl Completer for CustomCompletion {
                 redirect_stdout: true,
                 redirect_stderr: true,
             },
-            PipelineData::empty(),
+            PipelineData::new(span),
         );
 
         let mut custom_completion_options = None;
@@ -83,7 +144,7 @@ impl Completer for CustomCompletion {
                             .and_then(|val| {
                                 val.as_list()
                                     .ok()
-                                    .map(|it| map_value_completions(it.iter(), span, offset))
+                                    .map(|it| self.map_completions(it.iter(), span, offset))
                             })
                             .unwrap_or_default();
                         let options = value.get_data_by_key("options");
@@ -128,7 +189,7 @@ impl Completer for CustomCompletion {
 
                         completions
                     }
-                    Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
+                    Value::List { vals, .. } => self.map_completions(vals.iter(), span, offset),
                     _ => vec![],
                 }
             }

crates/nu-cli/src/completions/directory_completions.rs

@@ -136,12 +136,8 @@ pub fn directory_completion(
                                     file_name.push(SEP);
                                 }
 
-                                // Fix files or folders with quotes or hash
-                                if path.contains('\'')
-                                    || path.contains('"')
-                                    || path.contains(' ')
-                                    || path.contains('#')
-                                {
+                                // Fix files or folders with quotes
+                                if path.contains('\'') || path.contains('"') || path.contains(' ') {
                                     path = format!("`{}`", path);
                                 }
 

crates/nu-cli/src/completions/file_completions.rs

@@ -141,12 +141,8 @@ pub fn file_path_completion(
                             file_name.push(SEP);
                         }
 
-                        // Fix files or folders with quotes or hashes
-                        if path.contains('\'')
-                            || path.contains('"')
-                            || path.contains(' ')
-                            || path.contains('#')
-                        {
+                        // Fix files or folders with quotes
+                        if path.contains('\'') || path.contains('"') || path.contains(' ') {
                             path = format!("`{}`", path);
                         }
 

crates/nu-cli/src/completions/variable_completions.rs

@@ -111,7 +111,10 @@ impl Completer for VariableCompletion {
                     &self.engine_state,
                     &self.stack,
                     nu_protocol::NU_VARIABLE_ID,
-                    nu_protocol::Span::new(current_span.start, current_span.end),
+                    nu_protocol::Span {
+                        start: current_span.start,
+                        end: current_span.end,
+                    },
                 ) {
                     for suggestion in
                         nested_suggestions(nuval, self.var_context.1.clone(), current_span)
@@ -131,7 +134,13 @@ impl Completer for VariableCompletion {
             // Completion other variable types
             if let Some(var_id) = var_id {
                 // Extract the variable value from the stack
-                let var = self.stack.get_var(var_id, Span::new(span.start, span.end));
+                let var = self.stack.get_var(
+                    var_id,
+                    Span {
+                        start: span.start,
+                        end: span.end,
+                    },
+                );
 
                 // If the value exists and it's of type Record
                 if let Ok(value) = var {
@@ -272,7 +281,7 @@ fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
 
                 // Current sublevel value not found
                 return Value::Nothing {
-                    span: Span::unknown(),
+                    span: Span { start: 0, end: 0 },
                 };
             }
             _ => return val,

crates/nu-cli/src/config_files.rs

@@ -8,7 +8,7 @@ use nu_path::canonicalize_with;
 use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
 #[cfg(feature = "plugin")]
 use nu_protocol::Spanned;
-use nu_protocol::{HistoryFileFormat, PipelineData};
+use nu_protocol::{HistoryFileFormat, PipelineData, Span};
 use std::path::PathBuf;
 
 #[cfg(feature = "plugin")]
@@ -23,6 +23,7 @@ pub fn read_plugin_file(
     stack: &mut Stack,
     plugin_file: Option<Spanned<String>>,
     storage_path: &str,
+    is_perf_true: bool,
 ) {
     // Reading signatures from signature file
     // The plugin.nu file stores the parsed signature collected from each registered plugin
@@ -30,7 +31,7 @@ pub fn read_plugin_file(
 
     let plugin_path = engine_state.plugin_signatures.clone();
     if let Some(plugin_path) = plugin_path {
-        let plugin_filename = plugin_path.to_string_lossy();
+        let plugin_filename = plugin_path.to_string_lossy().to_owned();
 
         if let Ok(contents) = std::fs::read(&plugin_path) {
             eval_source(
@@ -38,12 +39,14 @@ pub fn read_plugin_file(
                 stack,
                 &contents,
                 &plugin_filename,
-                PipelineData::empty(),
+                PipelineData::new(Span::new(0, 0)),
             );
         }
     }
 
-    info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    if is_perf_true {
+        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    }
 }
 
 #[cfg(feature = "plugin")]
@@ -77,7 +80,7 @@ pub fn eval_config_contents(
     stack: &mut Stack,
 ) {
     if config_path.exists() & config_path.is_file() {
-        let config_filename = config_path.to_string_lossy();
+        let config_filename = config_path.to_string_lossy().to_owned();
 
         if let Ok(contents) = std::fs::read(&config_path) {
             eval_source(
@@ -85,7 +88,7 @@ pub fn eval_config_contents(
                 stack,
                 &contents,
                 &config_filename,
-                PipelineData::empty(),
+                PipelineData::new(Span::new(0, 0)),
             );
 
             // Merge the environment in case env vars changed in the config

crates/nu-cli/src/eval_file.rs

@@ -2,13 +2,13 @@ use crate::util::{eval_source, report_error};
 use log::info;
 use log::trace;
 use miette::{IntoDiagnostic, Result};
-use nu_engine::{convert_env_values, current_dir};
+use nu_engine::convert_env_values;
 use nu_parser::parse;
-use nu_path::canonicalize_with;
+use nu_protocol::Type;
 use nu_protocol::{
     ast::Call,
     engine::{EngineState, Stack, StateWorkingSet},
-    Config, PipelineData, ShellError, Span, Type, Value,
+    Config, PipelineData, Span, Value,
 };
 use nu_utils::stdout_write_all_and_flush;
 
@@ -19,6 +19,7 @@ pub fn evaluate_file(
     engine_state: &mut EngineState,
     stack: &mut Stack,
     input: PipelineData,
+    is_perf_true: bool,
 ) -> Result<()> {
     // Translate environment variables from Strings to Values
     if let Some(e) = convert_env_values(engine_state, stack) {
@@ -27,75 +28,12 @@ pub fn evaluate_file(
         std::process::exit(1);
     }
 
-    let cwd = current_dir(engine_state, stack)?;
-
-    let file_path = {
-        match canonicalize_with(&path, &cwd) {
-            Ok(p) => p,
-            Err(e) => {
-                let working_set = StateWorkingSet::new(engine_state);
-                report_error(
-                    &working_set,
-                    &ShellError::FileNotFoundCustom(
-                        format!("Could not access file '{}': {:?}", path, e.to_string()),
-                        Span::unknown(),
-                    ),
-                );
-                std::process::exit(1);
-            }
-        }
-    };
-
-    let file_path_str = match file_path.to_str() {
-        Some(s) => s,
-        None => {
-            let working_set = StateWorkingSet::new(engine_state);
-            report_error(
-                &working_set,
-                &ShellError::NonUtf8Custom(
-                    format!(
-                        "Input file name '{}' is not valid UTF8",
-                        file_path.to_string_lossy()
-                    ),
-                    Span::unknown(),
-                ),
-            );
-            std::process::exit(1);
-        }
-    };
-
-    let file = match std::fs::read(&file_path).into_diagnostic() {
-        Ok(p) => p,
-        Err(e) => {
-            let working_set = StateWorkingSet::new(engine_state);
-            report_error(
-                &working_set,
-                &ShellError::FileNotFoundCustom(
-                    format!(
-                        "Could not read file '{}': {:?}",
-                        file_path_str,
-                        e.to_string()
-                    ),
-                    Span::unknown(),
-                ),
-            );
-            std::process::exit(1);
-        }
-    };
-
-    engine_state.start_in_file(Some(file_path_str));
-
-    let mut parent = file_path.clone();
-    parent.pop();
-
-    stack.add_env_var(
-        "FILE_PWD".to_string(),
-        Value::string(parent.to_string_lossy(), Span::unknown()),
-    );
+    let file = std::fs::read(&path).into_diagnostic()?;
 
     let mut working_set = StateWorkingSet::new(engine_state);
-    trace!("parsing file: {}", file_path_str);
-    let _ = parse(&mut working_set, Some(file_path_str), &file, false, &[]);
+    trace!("parsing file: {}", path);
+
+    let _ = parse(&mut working_set, Some(&path), &file, false, &[]);
 
     if working_set.find_decl(b"main", &Type::Any).is_some() {
         let args = format!("main {}", args.join(" "));
@@ -104,19 +42,21 @@ pub fn evaluate_file(
             engine_state,
             stack,
             &file,
-            file_path_str,
-            PipelineData::empty(),
+            &path,
+            PipelineData::new(Span::new(0, 0)),
         ) {
             std::process::exit(1);
         }
         if !eval_source(engine_state, stack, args.as_bytes(), "<commandline>", input) {
             std::process::exit(1);
         }
-    } else if !eval_source(engine_state, stack, &file, file_path_str, input) {
+    } else if !eval_source(engine_state, stack, &file, &path, input) {
         std::process::exit(1);
     }
 
-    info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
 
     Ok(())
 }
@@ -135,14 +75,6 @@ pub fn print_table_or_error(
     // Change the engine_state config to use the passed in configuration
     engine_state.set_config(config);
 
-    if let PipelineData::Value(Value::Error { error }, ..) = &pipeline_data {
-        let working_set = StateWorkingSet::new(engine_state);
-
-        report_error(&working_set, error);
-
-        std::process::exit(1);
-    }
-
     match engine_state.find_decl("table".as_bytes(), &[]) {
         Some(decl_id) => {
             let command = engine_state.get_decl(decl_id);

crates/nu-cli/src/menus/description_menu.rs

@@ -1,8 +1,8 @@
 use {
     nu_ansi_term::{ansi::RESET, Style},
     reedline::{
-        menu_functions::string_difference, Completer, Editor, Menu, MenuEvent, MenuTextStyle,
-        Painter, Suggestion, UndoBehavior,
+        menu_functions::string_difference, Completer, LineBuffer, Menu, MenuEvent, MenuTextStyle,
+        Painter, Suggestion,
     },
 };
 
@@ -372,7 +372,7 @@ impl DescriptionMenu {
         let description = self
             .get_value()
             .and_then(|suggestion| suggestion.description)
-            .unwrap_or_default()
+            .unwrap_or_else(|| "".to_string())
             .lines()
             .skip(self.skipped_rows)
             .take(self.working_details.description_rows)
@@ -459,7 +459,7 @@ impl Menu for DescriptionMenu {
     fn can_partially_complete(
         &mut self,
         _values_updated: bool,
-        _editor: &mut Editor,
+        _line_buffer: &mut LineBuffer,
         _completer: &mut dyn Completer,
     ) -> bool {
         false
@@ -481,21 +481,19 @@ impl Menu for DescriptionMenu {
     }
 
     /// Updates menu values
-    fn update_values(&mut self, editor: &mut Editor, completer: &mut dyn Completer) {
+    fn update_values(&mut self, line_buffer: &mut LineBuffer, completer: &mut dyn Completer) {
         if self.only_buffer_difference {
             if let Some(old_string) = &self.input {
-                let (start, input) = string_difference(editor.get_buffer(), old_string);
+                let (start, input) = string_difference(line_buffer.get_buffer(), old_string);
                 if !input.is_empty() {
                     self.reset_position();
                     self.values = completer.complete(input, start);
                 }
             }
         } else {
-            let trimmed_buffer = editor.get_buffer().replace('\n', " ");
-            self.values = completer.complete(
-                trimmed_buffer.as_str(),
-                editor.line_buffer().insertion_point(),
-            );
+            let trimmed_buffer = line_buffer.get_buffer().replace('\n', " ");
+            self.values =
+                completer.complete(trimmed_buffer.as_str(), line_buffer.insertion_point());
             self.reset_position();
         }
     }
@@ -504,7 +502,7 @@ impl Menu for DescriptionMenu {
     /// collected from the completer
     fn update_working_details(
         &mut self,
-        editor: &mut Editor,
+        line_buffer: &mut LineBuffer,
         completer: &mut dyn Completer,
         painter: &Painter,
     ) {
@@ -562,13 +560,13 @@ impl Menu for DescriptionMenu {
             match event {
                 MenuEvent::Activate(_) => {
                     self.reset_position();
-                    self.input = Some(editor.get_buffer().to_string());
-                    self.update_values(editor, completer);
+                    self.input = Some(line_buffer.get_buffer().to_string());
+                    self.update_values(line_buffer, completer);
                 }
                 MenuEvent::Deactivate => self.active = false,
                 MenuEvent::Edit(_) => {
                     self.reset_position();
-                    self.update_values(editor, completer);
+                    self.update_values(line_buffer, completer);
                     self.update_examples()
                 }
                 MenuEvent::NextElement => {
@@ -610,7 +608,7 @@ impl Menu for DescriptionMenu {
                     let description_rows = self
                         .get_value()
                         .and_then(|suggestion| suggestion.description)
-                        .unwrap_or_default()
+                        .unwrap_or_else(|| "".to_string())
                         .lines()
                         .count();
 
@@ -629,28 +627,27 @@ impl Menu for DescriptionMenu {
     }
 
     /// The buffer gets replaced in the Span location
-    fn replace_in_buffer(&self, editor: &mut Editor) {
+    fn replace_in_buffer(&self, line_buffer: &mut LineBuffer) {
         if let Some(Suggestion { value, span, .. }) = self.get_value() {
-            let start = span.start.min(editor.line_buffer().len());
-            let end = span.end.min(editor.line_buffer().len());
+            let start = span.start.min(line_buffer.len());
+            let end = span.end.min(line_buffer.len());
 
-            let replacement = if let Some(example_index) = self.example_index {
-                self.examples
+            let string_len = if let Some(example_index) = self.example_index {
+                let example = self
+                    .examples
                     .get(example_index)
-                    .expect("the example index is always checked")
+                    .expect("the example index is always checked");
+
+                line_buffer.replace(start..end, example);
+                example.len()
             } else {
-                &value
+                line_buffer.replace(start..end, &value);
+                value.len()
             };
 
-            editor.edit_buffer(
-                |lb| {
-                    lb.replace_range(start..end, replacement);
-                    let mut offset = lb.insertion_point();
-                    offset += lb.len().saturating_sub(end.saturating_sub(start));
-                    lb.set_insertion_point(offset);
-                },
-                UndoBehavior::CreateUndoPoint,
-            );
+            let mut offset = line_buffer.insertion_point();
+            offset += string_len.saturating_sub(end.saturating_sub(start));
+            line_buffer.set_insertion_point(offset);
         }
     }
 

crates/nu-cli/src/menus/help_completions.rs

@@ -17,7 +17,7 @@ impl NuHelpCompleter {
         //Vec<(Signature, Vec<Example>, bool, bool)> {
         let mut commands = full_commands
             .iter()
-            .filter(|(sig, _, _, _, _)| {
+            .filter(|(sig, _, _, _)| {
                 sig.name.to_lowercase().contains(&line.to_lowercase())
                     || sig.usage.to_lowercase().contains(&line.to_lowercase())
                     || sig
@@ -31,7 +31,7 @@ impl NuHelpCompleter {
             })
             .collect::<Vec<_>>();
 
-        commands.sort_by(|(a, _, _, _, _), (b, _, _, _, _)| {
+        commands.sort_by(|(a, _, _, _), (b, _, _, _)| {
             let a_distance = levenshtein_distance(line, &a.name);
             let b_distance = levenshtein_distance(line, &b.name);
             a_distance.cmp(&b_distance)
@@ -39,7 +39,7 @@ impl NuHelpCompleter {
 
         commands
             .into_iter()
-            .map(|(sig, examples, _, _, _)| {
+            .map(|(sig, examples, _, _)| {
                 let mut long_desc = String::new();
 
                 let usage = &sig.usage;

crates/nu-cli/src/menus/menu_completions.rs

@@ -42,14 +42,20 @@ impl Completer for NuMenuCompleter {
 
         if let Some(buffer) = block.signature.get_positional(0) {
             if let Some(buffer_id) = &buffer.var_id {
-                let line_buffer = Value::string(parsed.remainder, self.span);
+                let line_buffer = Value::String {
+                    val: parsed.remainder.to_string(),
+                    span: self.span,
+                };
                 self.stack.add_var(*buffer_id, line_buffer);
             }
         }
 
         if let Some(position) = block.signature.get_positional(1) {
             if let Some(position_id) = &position.var_id {
-                let line_buffer = Value::int(pos as i64, self.span);
+                let line_buffer = Value::Int {
+                    val: pos as i64,
+                    span: self.span,
+                };
                 self.stack.add_var(*position_id, line_buffer);
             }
         }

crates/nu-cli/src/print.rs

@@ -50,13 +50,14 @@ Since this command has no output, there is no point in piping it with other comm
         let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
         let no_newline = call.has_flag("no-newline");
         let to_stderr = call.has_flag("stderr");
+        let head = call.head;
 
         for arg in args {
             arg.into_pipeline_data()
                 .print(engine_state, stack, no_newline, to_stderr)?;
         }
 
-        Ok(PipelineData::empty())
+        Ok(PipelineData::new(head))
     }
 
     fn examples(&self) -> Vec<Example> {

crates/nu-cli/src/prompt.rs

@@ -17,7 +17,6 @@ pub struct NushellPrompt {
     default_vi_insert_prompt_indicator: Option<String>,
     default_vi_normal_prompt_indicator: Option<String>,
     default_multiline_indicator: Option<String>,
-    render_right_prompt_on_last_line: bool,
 }
 
 impl Default for NushellPrompt {
@@ -35,7 +34,6 @@ impl NushellPrompt {
             default_vi_insert_prompt_indicator: None,
             default_vi_normal_prompt_indicator: None,
             default_multiline_indicator: None,
-            render_right_prompt_on_last_line: false,
         }
     }
 
@@ -43,13 +41,8 @@ impl NushellPrompt {
         self.left_prompt_string = prompt_string;
     }
 
-    pub fn update_prompt_right(
-        &mut self,
-        prompt_string: Option<String>,
-        render_right_prompt_on_last_line: bool,
-    ) {
+    pub fn update_prompt_right(&mut self, prompt_string: Option<String>) {
         self.right_prompt_string = prompt_string;
-        self.render_right_prompt_on_last_line = render_right_prompt_on_last_line;
     }
 
     pub fn update_prompt_indicator(&mut self, prompt_indicator_string: Option<String>) {
@@ -75,7 +68,6 @@ impl NushellPrompt {
         prompt_indicator_string: Option<String>,
         prompt_multiline_indicator_string: Option<String>,
         prompt_vi: (Option<String>, Option<String>),
-        render_right_prompt_on_last_line: bool,
     ) {
         let (prompt_vi_insert_string, prompt_vi_normal_string) = prompt_vi;
 
@@ -86,8 +78,6 @@ impl NushellPrompt {
 
         self.default_vi_insert_prompt_indicator = prompt_vi_insert_string;
         self.default_vi_normal_prompt_indicator = prompt_vi_normal_string;
-
-        self.render_right_prompt_on_last_line = render_right_prompt_on_last_line;
     }
 
     fn default_wrapped_custom_string(&self, str: String) -> String {
@@ -172,8 +162,4 @@ impl Prompt for NushellPrompt {
             prefix, history_search.term
         ))
     }
-
-    fn right_prompt_on_last_line(&self) -> bool {
-        self.render_right_prompt_on_last_line
-    }
 }

crates/nu-cli/src/prompt_update.rs

@@ -4,7 +4,7 @@ use log::info;
 use nu_engine::eval_subexpression;
 use nu_protocol::{
     engine::{EngineState, Stack, StateWorkingSet},
-    Config, PipelineData, Value,
+    Config, PipelineData, Span, Value,
 };
 use reedline::Prompt;
 
@@ -25,11 +25,12 @@ fn get_prompt_string(
     config: &Config,
     engine_state: &EngineState,
     stack: &mut Stack,
+    is_perf_true: bool,
 ) -> Option<String> {
     stack
         .get_env_var(engine_state, prompt)
         .and_then(|v| match v {
-            Value::Closure {
+            Value::Block {
                 val: block_id,
                 captures,
                 ..
@@ -37,34 +38,20 @@ fn get_prompt_string(
                 let block = engine_state.get_block(block_id);
                 let mut stack = stack.captures_to_stack(&captures);
                 // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
-                let ret_val =
-                    eval_subexpression(engine_state, &mut stack, block, PipelineData::empty());
-                info!(
-                    "get_prompt_string (block) {}:{}:{}",
-                    file!(),
-                    line!(),
-                    column!()
+                let ret_val = eval_subexpression(
+                    engine_state,
+                    &mut stack,
+                    block,
+                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
                 );
-
-                match ret_val {
-                    Ok(ret_val) => Some(ret_val),
-                    Err(err) => {
-                        let working_set = StateWorkingSet::new(engine_state);
-                        report_error(&working_set, &err);
-                        None
-                    }
+                if is_perf_true {
+                    info!(
+                        "get_prompt_string (block) {}:{}:{}",
+                        file!(),
+                        line!(),
+                        column!()
+                    );
                 }
-            }
-            Value::Block { val: block_id, .. } => {
-                let block = engine_state.get_block(block_id);
-                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
-                let ret_val = eval_subexpression(engine_state, stack, block, PipelineData::empty());
-                info!(
-                    "get_prompt_string (block) {}:{}:{}",
-                    file!(),
-                    line!(),
-                    column!()
-                );
 
                 match ret_val {
                     Ok(ret_val) => Some(ret_val),
@@ -103,10 +90,17 @@ pub(crate) fn update_prompt<'prompt>(
     engine_state: &EngineState,
     stack: &Stack,
     nu_prompt: &'prompt mut NushellPrompt,
+    is_perf_true: bool,
 ) -> &'prompt dyn Prompt {
     let mut stack = stack.clone();
 
-    let left_prompt_string = get_prompt_string(PROMPT_COMMAND, config, engine_state, &mut stack);
+    let left_prompt_string = get_prompt_string(
+        PROMPT_COMMAND,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
 
     // Now that we have the prompt string lets ansify it.
     // <133 A><prompt><133 B><command><133 C><command output>
@@ -122,20 +116,45 @@ pub(crate) fn update_prompt<'prompt>(
         left_prompt_string
     };
 
-    let right_prompt_string =
-        get_prompt_string(PROMPT_COMMAND_RIGHT, config, engine_state, &mut stack);
+    let right_prompt_string = get_prompt_string(
+        PROMPT_COMMAND_RIGHT,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
 
-    let prompt_indicator_string =
-        get_prompt_string(PROMPT_INDICATOR, config, engine_state, &mut stack);
+    let prompt_indicator_string = get_prompt_string(
+        PROMPT_INDICATOR,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
 
-    let prompt_multiline_string =
-        get_prompt_string(PROMPT_MULTILINE_INDICATOR, config, engine_state, &mut stack);
+    let prompt_multiline_string = get_prompt_string(
+        PROMPT_MULTILINE_INDICATOR,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
 
-    let prompt_vi_insert_string =
-        get_prompt_string(PROMPT_INDICATOR_VI_INSERT, config, engine_state, &mut stack);
+    let prompt_vi_insert_string = get_prompt_string(
+        PROMPT_INDICATOR_VI_INSERT,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
 
-    let prompt_vi_normal_string =
-        get_prompt_string(PROMPT_INDICATOR_VI_NORMAL, config, engine_state, &mut stack);
+    let prompt_vi_normal_string = get_prompt_string(
+        PROMPT_INDICATOR_VI_NORMAL,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
 
     // apply the other indicators
     nu_prompt.update_all_prompt_strings(
@@ -144,11 +163,12 @@ pub(crate) fn update_prompt<'prompt>(
         prompt_indicator_string,
         prompt_multiline_string,
         (prompt_vi_insert_string, prompt_vi_normal_string),
-        config.render_right_prompt_on_last_line,
     );
 
     let ret_val = nu_prompt as &dyn Prompt;
-    info!("update_prompt {}:{}:{}", file!(), line!(), column!());
+    if is_perf_true {
+        info!("update_prompt {}:{}:{}", file!(), line!(), column!());
+    }
 
     ret_val
 }

crates/nu-cli/src/reedline_config.rs

@@ -1,11 +1,11 @@
 use super::DescriptionMenu;
 use crate::{menus::NuMenuCompleter, NuHelpCompleter};
 use crossterm::event::{KeyCode, KeyModifiers};
-use nu_color_config::{color_record_to_nustyle, lookup_ansi_color_style};
+use nu_color_config::lookup_ansi_color_style;
 use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_protocol::{
-    create_menus,
+    color_value_string, create_menus,
     engine::{EngineState, Stack, StateWorkingSet},
     extract_value, Config, IntoPipelineData, ParsedKeybinding, ParsedMenu, PipelineData,
     ShellError, Span, Value,
@@ -114,7 +114,7 @@ pub(crate) fn add_menus(
             let res = eval_block(&engine_state, &mut temp_stack, &block, input, false, false)?;
 
             if let PipelineData::Value(value, None) = res {
-                for menu in create_menus(&value)? {
+                for menu in create_menus(&value, config)? {
                     line_editor =
                         add_menu(line_editor, &menu, engine_state.clone(), stack, config)?;
                 }
@@ -159,11 +159,14 @@ macro_rules! add_style {
     ($name:expr, $cols: expr, $vals:expr, $span:expr, $config: expr, $menu:expr, $f:expr) => {
         $menu = match extract_value($name, $cols, $vals, $span) {
             Ok(text) => {
-                let style = match text {
-                    Value::String { val, .. } => lookup_ansi_color_style(&val),
-                    Value::Record { .. } => color_record_to_nustyle(&text),
-                    _ => lookup_ansi_color_style("green"),
+                let text = match text {
+                    Value::String { val, .. } => val.clone(),
+                    Value::Record { cols, vals, span } => {
+                        color_value_string(span, cols, vals, $config).into_string("", $config)
+                    }
+                    _ => "green".to_string(),
                 };
+                let style = lookup_ansi_color_style(&text);
                 $f($menu, style)
             }
             Err(_) => $menu,
@@ -248,7 +251,7 @@ pub(crate) fn add_columnar_menu(
         Value::Nothing { .. } => {
             Ok(line_editor.with_menu(ReedlineMenu::EngineCompleter(Box::new(columnar_menu))))
         }
-        Value::Closure {
+        Value::Block {
             val,
             captures,
             span,
@@ -334,7 +337,7 @@ pub(crate) fn add_list_menu(
         Value::Nothing { .. } => {
             Ok(line_editor.with_menu(ReedlineMenu::HistoryMenu(Box::new(list_menu))))
         }
-        Value::Closure {
+        Value::Block {
             val,
             captures,
             span,
@@ -456,7 +459,7 @@ pub(crate) fn add_description_menu(
                 completer,
             }))
         }
-        Value::Closure {
+        Value::Block {
             val,
             captures,
             span,
@@ -474,7 +477,7 @@ pub(crate) fn add_description_menu(
             }))
         }
         _ => Err(ShellError::UnsupportedConfigValue(
-            "closure or omitted value".to_string(),
+            "block or omitted value".to_string(),
             menu.source.into_abbreviated_string(config),
             menu.source.span()?,
         )),
@@ -488,7 +491,7 @@ fn add_menu_keybindings(keybindings: &mut Keybindings) {
         KeyCode::Tab,
         ReedlineEvent::UntilFound(vec![
             ReedlineEvent::Menu("completion_menu".to_string()),
-            ReedlineEvent::Edit(vec![EditCommand::Complete]),
+            ReedlineEvent::MenuNext,
         ]),
     );
 
@@ -663,7 +666,6 @@ fn add_parsed_keybinding(
 
             KeyCode::Char(char)
         }
-        "space" => KeyCode::Char(' '),
         "down" => KeyCode::Down,
         "up" => KeyCode::Up,
         "left" => KeyCode::Left,
@@ -812,6 +814,7 @@ fn event_from_record(
 ) -> Result<ReedlineEvent, ShellError> {
     let event = match name {
         "none" => ReedlineEvent::None,
+        "actionhandler" => ReedlineEvent::ActionHandler,
         "clearscreen" => ReedlineEvent::ClearScreen,
         "clearscrollback" => ReedlineEvent::ClearScrollback,
         "historyhintcomplete" => ReedlineEvent::HistoryHintComplete,
@@ -819,8 +822,6 @@ fn event_from_record(
         "ctrld" => ReedlineEvent::CtrlD,
         "ctrlc" => ReedlineEvent::CtrlC,
         "enter" => ReedlineEvent::Enter,
-        "submit" => ReedlineEvent::Submit,
-        "submitornewline" => ReedlineEvent::SubmitOrNewline,
         "esc" | "escape" => ReedlineEvent::Esc,
         "up" => ReedlineEvent::Up,
         "down" => ReedlineEvent::Down,
@@ -961,7 +962,6 @@ fn edit_from_record(
             let char = extract_char(value, config)?;
             EditCommand::MoveLeftBefore(char)
         }
-        "complete" => EditCommand::Complete,
         e => {
             return Err(ShellError::UnsupportedConfigValue(
                 "reedline EditCommand".to_string(),
@@ -990,7 +990,10 @@ mod test {
     #[test]
     fn test_send_event() {
         let cols = vec!["send".to_string()];
-        let vals = vec![Value::string("Enter", Span::test_data())];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
 
         let span = Span::test_data();
         let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
@@ -1010,7 +1013,10 @@ mod test {
     #[test]
     fn test_edit_event() {
         let cols = vec!["edit".to_string()];
-        let vals = vec![Value::string("Clear", Span::test_data())];
+        let vals = vec![Value::String {
+            val: "Clear".to_string(),
+            span: Span::test_data(),
+        }];
 
         let span = Span::test_data();
         let b = EventType::try_from_columns(&cols, &vals, &span).unwrap();
@@ -1034,8 +1040,14 @@ mod test {
     fn test_send_menu() {
         let cols = vec!["send".to_string(), "name".to_string()];
         let vals = vec![
-            Value::string("Menu", Span::test_data()),
-            Value::string("history_menu", Span::test_data()),
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
         ];
 
         let span = Span::test_data();
@@ -1061,8 +1073,14 @@ mod test {
         // Menu event
         let cols = vec!["send".to_string(), "name".to_string()];
         let vals = vec![
-            Value::string("Menu", Span::test_data()),
-            Value::string("history_menu", Span::test_data()),
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
         ];
 
         let menu_event = Value::Record {
@@ -1073,7 +1091,10 @@ mod test {
 
         // Enter event
         let cols = vec!["send".to_string()];
-        let vals = vec![Value::string("Enter", Span::test_data())];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
 
         let enter_event = Value::Record {
             cols,
@@ -1114,8 +1135,14 @@ mod test {
         // Menu event
         let cols = vec!["send".to_string(), "name".to_string()];
         let vals = vec![
-            Value::string("Menu", Span::test_data()),
-            Value::string("history_menu", Span::test_data()),
+            Value::String {
+                val: "Menu".to_string(),
+                span: Span::test_data(),
+            },
+            Value::String {
+                val: "history_menu".to_string(),
+                span: Span::test_data(),
+            },
         ];
 
         let menu_event = Value::Record {
@@ -1126,7 +1153,10 @@ mod test {
 
         // Enter event
         let cols = vec!["send".to_string()];
-        let vals = vec![Value::string("Enter", Span::test_data())];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
 
         let enter_event = Value::Record {
             cols,
@@ -1154,7 +1184,10 @@ mod test {
     #[test]
     fn test_error() {
         let cols = vec!["not_exist".to_string()];
-        let vals = vec![Value::string("Enter", Span::test_data())];
+        let vals = vec![Value::String {
+            val: "Enter".to_string(),
+            span: Span::test_data(),
+        }];
 
         let span = Span::test_data();
         let b = EventType::try_from_columns(&cols, &vals, &span);

crates/nu-cli/src/repl.rs

@@ -5,23 +5,21 @@ use crate::{
     util::{eval_source, get_guaranteed_cwd, report_error, report_error_new},
     NuHighlighter, NuValidator, NushellPrompt,
 };
+use lazy_static::lazy_static;
 use log::{info, trace, warn};
 use miette::{IntoDiagnostic, Result};
-use nu_color_config::StyleComputer;
-use nu_engine::{convert_env_values, eval_block, eval_block_with_early_return};
-use nu_parser::{lex, parse, trim_quotes_str};
+use nu_color_config::get_color_config;
+use nu_engine::{convert_env_values, eval_block};
+use nu_parser::{lex, parse};
 use nu_protocol::{
     ast::PathMember,
-    engine::{EngineState, ReplOperation, Stack, StateWorkingSet},
-    format_duration, BlockId, HistoryFileFormat, PipelineData, PositionalArg, ShellError, Span,
-    Spanned, Type, Value, VarId,
-};
-use reedline::{DefaultHinter, EditCommand, Emacs, SqliteBackedHistory, Vi};
-use std::{
-    io::{self, Write},
-    sync::atomic::Ordering,
-    time::Instant,
+    engine::{EngineState, Stack, StateWorkingSet},
+    BlockId, HistoryFileFormat, PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId,
 };
+use reedline::{DefaultHinter, Emacs, SqliteBackedHistory, Vi};
+use regex::Regex;
+use std::io::{self, Write};
+use std::{sync::atomic::Ordering, time::Instant};
 use sysinfo::SystemExt;
 
 // According to Daniel Imms @Tyriar, we need to do these this way:
@@ -38,30 +36,22 @@ pub fn evaluate_repl(
     engine_state: &mut EngineState,
     stack: &mut Stack,
     nushell_path: &str,
-    prerun_command: Option<Spanned<String>>,
+    is_perf_true: bool,
 ) -> Result<()> {
     use reedline::{FileBackedHistory, Reedline, Signal};
 
-    // Guard against invocation without a connected terminal.
-    // reedline / crossterm event polling will fail without a connected tty
-    if !atty::is(atty::Stream::Stdin) {
-        return Err(std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "Nushell launched as a REPL, but STDIN is not a TTY; either launch in a valid terminal or provide arguments to invoke a script!",
-        ))
-        .into_diagnostic();
-    }
-
     let mut entry_num = 0;
 
     let mut nu_prompt = NushellPrompt::new();
 
-    info!(
-        "translate environment vars {}:{}:{}",
-        file!(),
-        line!(),
-        column!()
-    );
+    if is_perf_true {
+        info!(
+            "translate environment vars {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
 
     // Translate environment variables from Strings to Values
     if let Some(e) = convert_env_values(engine_state, stack) {
@@ -72,37 +62,45 @@ pub fn evaluate_repl(
     // seed env vars
     stack.add_env_var(
         "CMD_DURATION_MS".into(),
-        Value::string("0823", Span::unknown()),
+        Value::String {
+            val: "0823".to_string(),
+            span: Span { start: 0, end: 0 },
+        },
     );
 
-    stack.add_env_var("LAST_EXIT_CODE".into(), Value::int(0, Span::unknown()));
-
-    info!(
-        "load config initially {}:{}:{}",
-        file!(),
-        line!(),
-        column!()
+    stack.add_env_var(
+        "LAST_EXIT_CODE".into(),
+        Value::Int {
+            val: 0,
+            span: Span { start: 0, end: 0 },
+        },
     );
 
-    info!("setup reedline {}:{}:{}", file!(), line!(), column!());
-
-    let mut line_editor = Reedline::create();
-
-    // Now that reedline is created, get the history session id and store it in engine_state
-    let hist_sesh = match line_editor.get_history_session_id() {
-        Some(id) => i64::from(id),
-        None => 0,
-    };
-    engine_state.history_session_id = hist_sesh;
+    if is_perf_true {
+        info!(
+            "load config initially {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
 
+    // Get the config once for the history `max_history_size`
+    // Updating that will not be possible in one session
     let config = engine_state.get_config();
 
+    if is_perf_true {
+        info!("setup reedline {}:{}:{}", file!(), line!(), column!());
+    }
+    let mut line_editor = Reedline::create();
     let history_path = crate::config_files::get_history_path(
         nushell_path,
         engine_state.config.history_file_format,
     );
     if let Some(history_path) = history_path.as_deref() {
-        info!("setup history {}:{}:{}", file!(), line!(), column!());
+        if is_perf_true {
+            info!("setup history {}:{}:{}", file!(), line!(), column!());
+        }
 
         let history: Box<dyn reedline::History> = match engine_state.config.history_file_format {
             HistoryFileFormat::PlainText => Box::new(
@@ -121,35 +119,15 @@ pub fn evaluate_repl(
 
     let sys = sysinfo::System::new();
 
-    let show_banner = config.show_banner;
-    let use_ansi = config.use_ansi_coloring;
-    if show_banner {
-        let banner = get_banner(engine_state, stack);
-        if use_ansi {
-            println!("{}", banner);
-        } else {
-            println!("{}", nu_utils::strip_ansi_string_likely(banner));
-        }
-    }
-
-    if let Some(s) = prerun_command {
-        eval_source(
-            engine_state,
-            stack,
-            s.item.as_bytes(),
-            &format!("entry #{}", entry_num),
-            PipelineData::empty(),
-        );
-        engine_state.merge_env(stack, get_guaranteed_cwd(engine_state, stack))?;
-    }
-
     loop {
-        info!(
-            "load config each loop {}:{}:{}",
-            file!(),
-            line!(),
-            column!()
-        );
+        if is_perf_true {
+            info!(
+                "load config each loop {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
 
         let cwd = get_guaranteed_cwd(engine_state, stack);
 
@@ -170,9 +148,15 @@ pub fn evaluate_repl(
 
         let config = engine_state.get_config();
 
-        info!("setup colors {}:{}:{}", file!(), line!(), column!());
+        if is_perf_true {
+            info!("setup colors {}:{}:{}", file!(), line!(), column!());
+        }
 
-        info!("update reedline {}:{}:{}", file!(), line!(), column!());
+        let color_hm = get_color_config(config);
+
+        if is_perf_true {
+            info!("update reedline {}:{}:{}", file!(), line!(), column!());
+        }
         let engine_reference = std::sync::Arc::new(engine_state.clone());
         line_editor = line_editor
             .with_highlighter(Box::new(NuHighlighter {
@@ -190,14 +174,10 @@ pub fn evaluate_repl(
             .with_partial_completions(config.partial_completions)
             .with_ansi_colors(config.use_ansi_coloring);
 
-        let style_computer = StyleComputer::from_config(engine_state, stack);
-
         line_editor = if config.use_ansi_coloring {
-            line_editor.with_hinter(Box::new({
-                // As of Nov 2022, "hints" color_config closures only get `null` passed in.
-                let style = style_computer.compute("hints", &Value::nothing(Span::unknown()));
-                DefaultHinter::default().with_style(style)
-            }))
+            line_editor.with_hinter(Box::new(
+                DefaultHinter::default().with_style(color_hm["hints"]),
+            ))
         } else {
             line_editor.disable_hints()
         };
@@ -233,14 +213,18 @@ pub fn evaluate_repl(
         };
 
         if config.sync_history_on_enter {
-            info!("sync history {}:{}:{}", file!(), line!(), column!());
+            if is_perf_true {
+                info!("sync history {}:{}:{}", file!(), line!(), column!());
+            }
 
             if let Err(e) = line_editor.sync_history() {
                 warn!("Failed to sync history: {}", e);
             }
         }
 
-        info!("setup keybindings {}:{}:{}", file!(), line!(), column!());
+        if is_perf_true {
+            info!("setup keybindings {}:{}:{}", file!(), line!(), column!());
+        }
 
         // Changing the line editor based on the found keybindings
         line_editor = match create_keybindings(config) {
@@ -264,12 +248,14 @@ pub fn evaluate_repl(
             }
         };
 
-        info!("prompt_update {}:{}:{}", file!(), line!(), column!());
+        if is_perf_true {
+            info!("prompt_update {}:{}:{}", file!(), line!(), column!());
+        }
 
         // Right before we start our prompt and take input from the user,
         // fire the "pre_prompt" hook
         if let Some(hook) = config.hooks.pre_prompt.clone() {
-            if let Err(err) = eval_hook(engine_state, stack, None, vec![], &hook) {
+            if let Err(err) = eval_hook(engine_state, stack, vec![], &hook) {
                 report_error_new(engine_state, &err);
             }
         }
@@ -284,31 +270,32 @@ pub fn evaluate_repl(
         }
 
         let config = engine_state.get_config();
-        let prompt = prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt);
+        let prompt =
+            prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt, is_perf_true);
 
         entry_num += 1;
 
-        info!(
-            "finished setup, starting repl {}:{}:{}",
-            file!(),
-            line!(),
-            column!()
-        );
+        if is_perf_true {
+            info!(
+                "finished setup, starting repl {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
 
         let input = line_editor.read_line(prompt);
         let shell_integration = config.shell_integration;
 
         match input {
             Ok(Signal::Success(s)) => {
-                let hostname = sys.host_name();
                 let history_supports_meta =
                     matches!(config.history_file_format, HistoryFileFormat::Sqlite);
-                if history_supports_meta && !s.is_empty() && line_editor.has_last_command_context()
-                {
+                if history_supports_meta && !s.is_empty() {
                     line_editor
                         .update_last_command_context(&|mut c| {
                             c.start_timestamp = Some(chrono::Utc::now());
-                            c.hostname = hostname.clone();
+                            c.hostname = sys.host_name();
 
                             c.cwd = Some(StateWorkingSet::new(engine_state).get_cwd());
                             c
@@ -316,35 +303,42 @@ pub fn evaluate_repl(
                         .into_diagnostic()?; // todo: don't stop repl if error here?
                 }
 
-                engine_state
-                    .repl_buffer_state
-                    .lock()
-                    .expect("repl buffer state mutex")
-                    .replace(line_editor.current_buffer_contents().to_string());
-
                 // Right before we start running the code the user gave us,
                 // fire the "pre_execution" hook
                 if let Some(hook) = config.hooks.pre_execution.clone() {
-                    if let Err(err) = eval_hook(engine_state, stack, None, vec![], &hook) {
+                    if let Err(err) = eval_hook(engine_state, stack, vec![], &hook) {
                         report_error_new(engine_state, &err);
                     }
                 }
 
                 if shell_integration {
+                    run_ansi_sequence(RESET_APPLICATION_MODE)?;
                     run_ansi_sequence(PRE_EXECUTE_MARKER)?;
+                    // if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                    //     let path = cwd.as_string()?;
+                    //     // Try to abbreviate string for windows title
+                    //     let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                    //         path.replace(&p.as_path().display().to_string(), "~")
+                    //     } else {
+                    //         path
+                    //     };
+
+                    //     // Set window title too
+                    //     // https://tldp.org/HOWTO/Xterm-Title-3.html
+                    //     // ESC]0;stringBEL -- Set icon name and window title to string
+                    //     // ESC]1;stringBEL -- Set icon name to string
+                    //     // ESC]2;stringBEL -- Set window title to string
+                    //     run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
+                    // }
                 }
 
                 let start_time = Instant::now();
                 let tokens = lex(s.as_bytes(), 0, &[], &[], false);
                 // Check if this is a single call to a directory, if so auto-cd
                 let cwd = nu_engine::env::current_dir_str(engine_state, stack)?;
+                let path = nu_path::expand_path_with(&s, &cwd);
 
-                let mut orig = s.clone();
-                if orig.starts_with('`') {
-                    orig = trim_quotes_str(&orig).to_string()
-                }
-
-                let path = nu_path::expand_path_with(&orig, &cwd);
+                let orig = s.clone();
 
                 if looks_like_path(&orig) && path.is_dir() && tokens.0.len() == 1 {
                     // We have an auto-cd
@@ -366,7 +360,7 @@ pub fn evaluate_repl(
                         "OLDPWD".into(),
                         Value::String {
                             val: cwd.clone(),
-                            span: Span::unknown(),
+                            span: Span { start: 0, end: 0 },
                         },
                     );
 
@@ -376,7 +370,7 @@ pub fn evaluate_repl(
                         "PWD".into(),
                         Value::String {
                             val: path.clone(),
-                            span: Span::unknown(),
+                            span: Span { start: 0, end: 0 },
                         },
                     );
                     let cwd = Value::String { val: cwd, span };
@@ -397,24 +391,10 @@ pub fn evaluate_repl(
                         0
                     };
 
-                    let last_shell = stack.get_env_var(engine_state, "NUSHELL_LAST_SHELL");
-                    let last_shell = if let Some(v) = last_shell {
-                        v.as_integer().unwrap_or_default() as usize
-                    } else {
-                        0
-                    };
-
                     shells[current_shell] = Value::String { val: path, span };
 
                     stack.add_env_var("NUSHELL_SHELLS".into(), Value::List { vals: shells, span });
-                    stack.add_env_var(
-                        "NUSHELL_LAST_SHELL".into(),
-                        Value::Int {
-                            val: last_shell as i64,
-                            span,
-                        },
-                    );
-                } else if !s.trim().is_empty() {
+                } else {
                     trace!("eval source: {}", s);
 
                     eval_source(
@@ -422,7 +402,7 @@ pub fn evaluate_repl(
                         stack,
                         s.as_bytes(),
                         &format!("entry #{}", entry_num),
-                        PipelineData::empty(),
+                        PipelineData::new(Span::new(0, 0)),
                     );
                 }
                 let cmd_duration = start_time.elapsed();
@@ -431,12 +411,11 @@ pub fn evaluate_repl(
                     "CMD_DURATION_MS".into(),
                     Value::String {
                         val: format!("{}", cmd_duration.as_millis()),
-                        span: Span::unknown(),
+                        span: Span { start: 0, end: 0 },
                     },
                 );
 
-                if history_supports_meta && !s.is_empty() && line_editor.has_last_command_context()
-                {
+                if history_supports_meta && !s.is_empty() {
                     line_editor
                         .update_last_command_context(&|mut c| {
                             c.duration = Some(cmd_duration);
@@ -452,21 +431,6 @@ pub fn evaluate_repl(
                     run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
                     if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
                         let path = cwd.as_string()?;
-
-                        // Communicate the path as OSC 7 (often used for spawning new tabs in the same dir)
-                        run_ansi_sequence(&format!(
-                            "\x1b]7;file://{}{}{}\x1b\\",
-                            percent_encoding::utf8_percent_encode(
-                                &hostname.unwrap_or_else(|| "localhost".to_string()),
-                                percent_encoding::CONTROLS
-                            ),
-                            if path.starts_with('/') { "" } else { "/" },
-                            percent_encoding::utf8_percent_encode(
-                                &path,
-                                percent_encoding::CONTROLS
-                            )
-                        ))?;
-
                         // Try to abbreviate string for windows title
                         let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
                             path.replace(&p.as_path().display().to_string(), "~")
@@ -481,25 +445,6 @@ pub fn evaluate_repl(
                         // ESC]2;stringBEL -- Set window title to string
                         run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
                     }
-                    run_ansi_sequence(RESET_APPLICATION_MODE)?;
-                }
-
-                let mut ops = engine_state
-                    .repl_operation_queue
-                    .lock()
-                    .expect("repl op queue mutex");
-                while let Some(op) = ops.pop_front() {
-                    match op {
-                        ReplOperation::Append(s) => line_editor.run_edit_commands(&[
-                            EditCommand::MoveToEnd,
-                            EditCommand::InsertString(s),
-                        ]),
-                        ReplOperation::Insert(s) => {
-                            line_editor.run_edit_commands(&[EditCommand::InsertString(s)])
-                        }
-                        ReplOperation::Replace(s) => line_editor
-                            .run_edit_commands(&[EditCommand::Clear, EditCommand::InsertString(s)]),
-                    }
                 }
             }
             Ok(Signal::CtrlC) => {
@@ -519,11 +464,7 @@ pub fn evaluate_repl(
             Err(err) => {
                 let message = err.to_string();
                 if !message.contains("duration") {
-                    eprintln!("Error: {:?}", err);
-                    // TODO: Identify possible error cases where a hard failure is preferable
-                    // Ignoring and reporting could hide bigger problems
-                    // e.g. https://github.com/nushell/nushell/issues/6452
-                    // Alternatively only allow that expected failures let the REPL loop
+                    println!("Error: {:?}", err);
                 }
                 if shell_integration {
                     run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
@@ -535,113 +476,6 @@ pub fn evaluate_repl(
     Ok(())
 }
 
-fn get_banner(engine_state: &mut EngineState, stack: &mut Stack) -> String {
-    let age = match eval_string_with_input(
-        engine_state,
-        stack,
-        None,
-        "(date now) - ('2019-05-10 09:59:12-0700' | into datetime)",
-    ) {
-        Ok(Value::Duration { val, .. }) => format_duration(val),
-        _ => "".to_string(),
-    };
-
-    let banner = format!(
-        r#"{}     __  ,
-{} .--()°'.' {}Welcome to {}Nushell{},
-{}'|, . ,'   {}based on the {}nu{} language,
-{} !_-(_\    {}where all data is structured!
-
-Please join our {}Discord{} community at {}https://discord.gg/NtAbbGn{}
-Our {}GitHub{} repository is at {}https://github.com/nushell/nushell{}
-Our {}Documentation{} is located at {}http://nushell.sh{}
-{}Tweet{} us at {}@nu_shell{}
-
-It's been this long since {}Nushell{}'s first commit:
-{}
-
-{}You can disable this banner using the {}config nu{}{} command
-to modify the config.nu file and setting show_banner to false.
-
-let-env config = {{
-    show_banner: false
-    ...
-}}{}
-"#,
-        "\x1b[32m",   //start line 1 green
-        "\x1b[32m",   //start line 2
-        "\x1b[0m",    //before welcome
-        "\x1b[32m",   //before nushell
-        "\x1b[0m",    //after nushell
-        "\x1b[32m",   //start line 3
-        "\x1b[0m",    //before based
-        "\x1b[32m",   //before nu
-        "\x1b[0m",    //after nu
-        "\x1b[32m",   //start line 4
-        "\x1b[0m",    //before where
-        "\x1b[35m",   //before Discord purple
-        "\x1b[0m",    //after Discord
-        "\x1b[35m",   //before Discord URL
-        "\x1b[0m",    //after Discord URL
-        "\x1b[1;32m", //before GitHub green_bold
-        "\x1b[0m",    //after GitHub
-        "\x1b[1;32m", //before GitHub URL
-        "\x1b[0m",    //after GitHub URL
-        "\x1b[32m",   //before Documentation
-        "\x1b[0m",    //after Documentation
-        "\x1b[32m",   //before Documentation URL
-        "\x1b[0m",    //after Documentation URL
-        "\x1b[36m",   //before Tweet blue
-        "\x1b[0m",    //after Tweet
-        "\x1b[1;36m", //before @nu_shell cyan_bold
-        "\x1b[0m",    //after @nu_shell
-        "\x1b[32m",   //before Nushell
-        "\x1b[0m",    //after Nushell
-        age,
-        "\x1b[2;37m", //before banner disable dim white
-        "\x1b[2;36m", //before config nu dim cyan
-        "\x1b[0m",    //after config nu
-        "\x1b[2;37m", //after config nu dim white
-        "\x1b[0m",    //after banner disable
-    );
-
-    banner
-}
-
-// Taken from Nana's simple_eval
-/// Evaluate a block of Nu code, optionally with input.
-/// For example, source="$in * 2" will multiply the value in input by 2.
-pub fn eval_string_with_input(
-    engine_state: &mut EngineState,
-    stack: &mut Stack,
-    input: Option<Value>,
-    source: &str,
-) -> Result<Value, ShellError> {
-    let (block, delta) = {
-        let mut working_set = StateWorkingSet::new(engine_state);
-        let (output, _) = parse(&mut working_set, None, source.as_bytes(), false, &[]);
-
-        (output, working_set.render())
-    };
-
-    engine_state.merge_delta(delta)?;
-
-    let input_as_pipeline_data = match input {
-        Some(input) => PipelineData::Value(input, None),
-        None => PipelineData::empty(),
-    };
-
-    eval_block(
-        engine_state,
-        stack,
-        &block,
-        input_as_pipeline_data,
-        false,
-        true,
-    )
-    .map(|x| x.into_value(Span::test_data()))
-}
-
 pub fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
     let exit_code = stack
         .get_env_var(engine_state, "LAST_EXIT_CODE")
@@ -677,7 +511,6 @@ pub fn eval_env_change_hook(
                         eval_hook(
                             engine_state,
                             stack,
-                            None,
                             vec![("$before".into(), before), ("$after".into(), after.clone())],
                             hook_value,
                         )?;
@@ -703,24 +536,15 @@ pub fn eval_env_change_hook(
 pub fn eval_hook(
     engine_state: &mut EngineState,
     stack: &mut Stack,
-    input: Option<PipelineData>,
     arguments: Vec<(String, Value)>,
     value: &Value,
-) -> Result<PipelineData, ShellError> {
+) -> Result<(), ShellError> {
     let value_span = value.span()?;
 
-    // Hooks can optionally be a record in this form:
-    // {
-    //     condition: {|before, after| ... }  # block that evaluates to true/false
-    //     code: # block or a string
-    // }
-    // The condition block will be run to check whether the main hook (in `code`) should be run.
-    // If it returns true (the default if a condition block is not specified), the hook should be run.
     let condition_path = PathMember::String {
         val: "condition".to_string(),
         span: value_span,
     };
-    let mut output = PipelineData::empty();
 
     let code_path = PathMember::String {
         val: "code".to_string(),
@@ -730,7 +554,7 @@ pub fn eval_hook(
     match value {
         Value::List { vals, .. } => {
             for val in vals {
-                eval_hook(engine_state, stack, None, arguments.clone(), val)?;
+                eval_hook(engine_state, stack, arguments.clone(), val)?
             }
         }
         Value::Record { .. } => {
@@ -741,33 +565,24 @@ pub fn eval_hook(
                             val: block_id,
                             span: block_span,
                             ..
-                        }
-                        | Value::Closure {
-                            val: block_id,
-                            span: block_span,
-                            ..
                         } => {
                             match run_hook_block(
                                 engine_state,
                                 stack,
                                 block_id,
-                                None,
                                 arguments.clone(),
                                 block_span,
                             ) {
-                                Ok(pipeline_data) => {
-                                    if let PipelineData::Value(Value::Bool { val, .. }, ..) =
-                                        pipeline_data
-                                    {
-                                        val
-                                    } else {
+                                Ok(value) => match value {
+                                    Value::Bool { val, .. } => val,
+                                    other => {
                                         return Err(ShellError::UnsupportedConfigValue(
                                             "boolean output".to_string(),
-                                            "other PipelineData variant".to_string(),
-                                            block_span,
+                                            format!("{}", other.get_type()),
+                                            other.span()?,
                                         ));
                                     }
-                                }
+                                },
                                 Err(err) => {
                                     return Err(err);
                                 }
@@ -802,7 +617,6 @@ pub fn eval_hook(
                                     name.as_bytes().to_vec(),
                                     val.span()?,
                                     Type::Any,
-                                    false,
                                 );
 
                                 vars.push((var_id, val));
@@ -824,7 +638,7 @@ pub fn eval_hook(
                         };
 
                         engine_state.merge_delta(delta)?;
-                        let input = PipelineData::empty();
+                        let input = PipelineData::new(value_span);
 
                         let var_ids: Vec<VarId> = vars
                             .into_iter()
@@ -835,9 +649,7 @@ pub fn eval_hook(
                             .collect();
 
                         match eval_block(engine_state, stack, &block, input, false, false) {
-                            Ok(pipeline_data) => {
-                                output = pipeline_data;
-                            }
+                            Ok(_) => {}
                             Err(err) => {
                                 report_error_new(engine_state, &err);
                             }
@@ -846,34 +658,18 @@ pub fn eval_hook(
                         for var_id in var_ids.iter() {
                             stack.vars.remove(var_id);
                         }
+
+                        let cwd = get_guaranteed_cwd(engine_state, stack);
+                        engine_state.merge_env(stack, cwd)?;
                     }
                     Value::Block {
                         val: block_id,
                         span: block_span,
                         ..
                     } => {
-                        run_hook_block(
-                            engine_state,
-                            stack,
-                            block_id,
-                            input,
-                            arguments,
-                            block_span,
-                        )?;
-                    }
-                    Value::Closure {
-                        val: block_id,
-                        span: block_span,
-                        ..
-                    } => {
-                        run_hook_block(
-                            engine_state,
-                            stack,
-                            block_id,
-                            input,
-                            arguments,
-                            block_span,
-                        )?;
+                        run_hook_block(engine_state, stack, block_id, arguments, block_span)?;
+                        let cwd = get_guaranteed_cwd(engine_state, stack);
+                        engine_state.merge_env(stack, cwd)?;
                     }
                     other => {
                         return Err(ShellError::UnsupportedConfigValue(
@@ -890,28 +686,7 @@ pub fn eval_hook(
             span: block_span,
             ..
         } => {
-            output = run_hook_block(
-                engine_state,
-                stack,
-                *block_id,
-                input,
-                arguments,
-                *block_span,
-            )?;
-        }
-        Value::Closure {
-            val: block_id,
-            span: block_span,
-            ..
-        } => {
-            output = run_hook_block(
-                engine_state,
-                stack,
-                *block_id,
-                input,
-                arguments,
-                *block_span,
-            )?;
+            run_hook_block(engine_state, stack, *block_id, arguments, *block_span)?;
         }
         other => {
             return Err(ShellError::UnsupportedConfigValue(
@@ -922,23 +697,19 @@ pub fn eval_hook(
         }
     }
 
-    let cwd = get_guaranteed_cwd(engine_state, stack);
-    engine_state.merge_env(stack, cwd)?;
-
-    Ok(output)
+    Ok(())
 }
 
-fn run_hook_block(
+pub fn run_hook_block(
     engine_state: &EngineState,
     stack: &mut Stack,
     block_id: BlockId,
-    optional_input: Option<PipelineData>,
     arguments: Vec<(String, Value)>,
     span: Span,
-) -> Result<PipelineData, ShellError> {
+) -> Result<Value, ShellError> {
     let block = engine_state.get_block(block_id);
 
-    let input = optional_input.unwrap_or_else(PipelineData::empty);
+    let input = PipelineData::new(span);
 
     let mut callee_stack = stack.gather_captures(&block.captures);
 
@@ -957,30 +728,29 @@ fn run_hook_block(
         }
     }
 
-    match eval_block_with_early_return(engine_state, &mut callee_stack, block, input, false, false)
-    {
-        Ok(pipeline_data) => {
-            if let PipelineData::Value(Value::Error { error }, _) = pipeline_data {
-                return Err(error);
-            }
+    match eval_block(engine_state, &mut callee_stack, block, input, false, false) {
+        Ok(pipeline_data) => match pipeline_data.into_value(span) {
+            Value::Error { error } => Err(error),
+            val => {
+                // If all went fine, preserve the environment of the called block
+                let caller_env_vars = stack.get_env_var_names(engine_state);
 
-            // If all went fine, preserve the environment of the called block
-            let caller_env_vars = stack.get_env_var_names(engine_state);
-
-            // remove env vars that are present in the caller but not in the callee
-            // (the callee hid them)
-            for var in caller_env_vars.iter() {
-                if !callee_stack.has_env_var(engine_state, var) {
-                    stack.remove_env_var(engine_state, var);
+                // remove env vars that are present in the caller but not in the callee
+                // (the callee hid them)
+                for var in caller_env_vars.iter() {
+                    if !callee_stack.has_env_var(engine_state, var) {
+                        stack.remove_env_var(engine_state, var);
+                    }
                 }
-            }
 
-            // add new env vars from callee to caller
-            for (var, value) in callee_stack.get_stack_env_vars() {
-                stack.add_env_var(var, value);
+                // add new env vars from callee to caller
+                for (var, value) in callee_stack.get_stack_env_vars() {
+                    stack.add_env_var(var, value);
+                }
+
+                Ok(val)
             }
-            Ok(pipeline_data)
-        }
+        },
         Err(err) => Err(err),
     }
 }
@@ -992,7 +762,7 @@ fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
             return Err(ShellError::GenericError(
                 "Error writing ansi sequence".into(),
                 err.to_string(),
-                Some(Span::unknown()),
+                Some(Span { start: 0, end: 0 }),
                 None,
                 Vec::new(),
             ));
@@ -1002,25 +772,24 @@ fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
         ShellError::GenericError(
             "Error flushing stdio".into(),
             e.to_string(),
-            Some(Span::unknown()),
+            Some(Span { start: 0, end: 0 }),
             None,
             Vec::new(),
         )
     })
 }
 
-// Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
-#[cfg(windows)]
-static DRIVE_PATH_REGEX: once_cell::sync::Lazy<fancy_regex::Regex> =
-    once_cell::sync::Lazy::new(|| {
-        fancy_regex::Regex::new(r"^[a-zA-Z]:[/\\]?").expect("Internal error: regex creation")
-    });
+lazy_static! {
+    // Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
+    static ref DRIVE_PATH_REGEX: Regex =
+        Regex::new(r"^[a-zA-Z]:[/\\]?").expect("Internal error: regex creation");
+}
 
 // A best-effort "does this string look kinda like a path?" function to determine whether to auto-cd
 fn looks_like_path(orig: &str) -> bool {
     #[cfg(windows)]
     {
-        if DRIVE_PATH_REGEX.is_match(orig).unwrap_or(false) {
+        if DRIVE_PATH_REGEX.is_match(orig) {
             return true;
         }
     }

crates/nu-cli/src/syntax_highlight.rs

@@ -1,10 +1,9 @@
 use log::trace;
 use nu_ansi_term::Style;
-use nu_color_config::{get_matching_brackets_style, get_shape_color};
+use nu_color_config::get_shape_color;
 use nu_parser::{flatten_block, parse, FlatShape};
-use nu_protocol::ast::{Argument, Block, Expr, Expression, PipelineElement};
 use nu_protocol::engine::{EngineState, StateWorkingSet};
-use nu_protocol::{Config, Span};
+use nu_protocol::Config;
 use reedline::{Highlighter, StyledText};
 
 pub struct NuHighlighter {
@@ -16,12 +15,10 @@ impl Highlighter for NuHighlighter {
     fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
         trace!("highlighting: {}", line);
 
-        let mut working_set = StateWorkingSet::new(&self.engine_state);
-        let block = {
-            let (block, _) = parse(&mut working_set, None, line.as_bytes(), false, &[]);
-            block
-        };
         let (shapes, global_span_offset) = {
+            let mut working_set = StateWorkingSet::new(&self.engine_state);
+            let (block, _) = parse(&mut working_set, None, line.as_bytes(), false, &[]);
+
             let shapes = flatten_block(&working_set, &block);
             (shapes, self.engine_state.next_span_start())
         };
@@ -29,15 +26,6 @@ impl Highlighter for NuHighlighter {
         let mut output = StyledText::default();
         let mut last_seen_span = global_span_offset;
 
-        let global_cursor_offset = _cursor + global_span_offset;
-        let matching_brackets_pos = find_matching_brackets(
-            line,
-            &working_set,
-            &block,
-            global_span_offset,
-            global_cursor_offset,
-        );
-
         for shape in &shapes {
             if shape.0.end <= last_seen_span
                 || last_seen_span < global_span_offset
@@ -56,75 +44,166 @@ impl Highlighter for NuHighlighter {
             let next_token = line
                 [(shape.0.start - global_span_offset)..(shape.0.end - global_span_offset)]
                 .to_string();
-
-            macro_rules! add_colored_token_with_bracket_highlight {
-                ($shape:expr, $span:expr, $text:expr) => {{
-                    let spans = split_span_by_highlight_positions(
-                        line,
-                        &$span,
-                        &matching_brackets_pos,
-                        global_span_offset,
-                    );
-                    spans.iter().for_each(|(part, highlight)| {
-                        let start = part.start - $span.start;
-                        let end = part.end - $span.start;
-                        let text = (&next_token[start..end]).to_string();
-                        let mut style = get_shape_color($shape.to_string(), &self.config);
-                        if *highlight {
-                            style = get_matching_brackets_style(style, &self.config);
-                        }
-                        output.push((style, text));
-                    });
-                }};
-            }
-
-            macro_rules! add_colored_token {
-                ($shape:expr, $text:expr) => {
-                    output.push((get_shape_color($shape.to_string(), &self.config), $text))
-                };
-            }
-
             match shape.1 {
-                FlatShape::Garbage => add_colored_token!(shape.1, next_token),
-                FlatShape::Nothing => add_colored_token!(shape.1, next_token),
-                FlatShape::Binary => add_colored_token!(shape.1, next_token),
-                FlatShape::Bool => add_colored_token!(shape.1, next_token),
-                FlatShape::Int => add_colored_token!(shape.1, next_token),
-                FlatShape::Float => add_colored_token!(shape.1, next_token),
-                FlatShape::Range => add_colored_token!(shape.1, next_token),
-                FlatShape::InternalCall => add_colored_token!(shape.1, next_token),
-                FlatShape::External => add_colored_token!(shape.1, next_token),
-                FlatShape::ExternalArg => add_colored_token!(shape.1, next_token),
-                FlatShape::Literal => add_colored_token!(shape.1, next_token),
-                FlatShape::Operator => add_colored_token!(shape.1, next_token),
-                FlatShape::Signature => add_colored_token!(shape.1, next_token),
-                FlatShape::String => add_colored_token!(shape.1, next_token),
-                FlatShape::StringInterpolation => add_colored_token!(shape.1, next_token),
-                FlatShape::DateTime => add_colored_token!(shape.1, next_token),
+                FlatShape::Garbage => output.push((
+                    // nushell Garbage
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Nothing => output.push((
+                    // nushell Nothing
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Binary => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Bool => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Int => {
+                    // nushell Int
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Float => {
+                    // nushell Decimal
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Range => output.push((
+                    // nushell DotDot ?
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::InternalCall => output.push((
+                    // nushell InternalCommand
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::External => {
+                    // nushell ExternalCommand
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::ExternalArg => {
+                    // nushell ExternalWord
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Literal => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Operator => output.push((
+                    // nushell Operator
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Signature => output.push((
+                    // nushell ?
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::String => {
+                    // nushell String
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::StringInterpolation => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::DateTime => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
                 FlatShape::List => {
-                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
                 }
                 FlatShape::Table => {
-                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
                 }
                 FlatShape::Record => {
-                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
                 }
-
                 FlatShape::Block => {
-                    add_colored_token_with_bracket_highlight!(shape.1, shape.0, next_token)
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
                 }
-
-                FlatShape::Filepath => add_colored_token!(shape.1, next_token),
-                FlatShape::Directory => add_colored_token!(shape.1, next_token),
-                FlatShape::GlobPattern => add_colored_token!(shape.1, next_token),
-                FlatShape::Variable => add_colored_token!(shape.1, next_token),
-                FlatShape::Flag => add_colored_token!(shape.1, next_token),
-                FlatShape::Pipe => add_colored_token!(shape.1, next_token),
-                FlatShape::And => add_colored_token!(shape.1, next_token),
-                FlatShape::Or => add_colored_token!(shape.1, next_token),
-                FlatShape::Redirection => add_colored_token!(shape.1, next_token),
-                FlatShape::Custom(..) => add_colored_token!(shape.1, next_token),
+                FlatShape::Filepath => output.push((
+                    // nushell Path
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Directory => output.push((
+                    // nushell Directory
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::GlobPattern => output.push((
+                    // nushell GlobPattern
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Variable => output.push((
+                    // nushell Variable
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Flag => {
+                    // nushell Flag
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Custom(..) => output.push((
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
             }
             last_seen_span = shape.0.end;
         }
@@ -137,299 +216,3 @@ impl Highlighter for NuHighlighter {
         output
     }
 }
-
-fn split_span_by_highlight_positions(
-    line: &str,
-    span: &Span,
-    highlight_positions: &Vec<usize>,
-    global_span_offset: usize,
-) -> Vec<(Span, bool)> {
-    let mut start = span.start;
-    let mut result: Vec<(Span, bool)> = Vec::new();
-    for pos in highlight_positions {
-        if start <= *pos && pos < &span.end {
-            if start < *pos {
-                result.push((Span::new(start, *pos), false));
-            }
-            let span_str = &line[pos - global_span_offset..span.end - global_span_offset];
-            let end = span_str
-                .chars()
-                .next()
-                .map(|c| pos + get_char_length(c))
-                .unwrap_or(pos + 1);
-            result.push((Span::new(*pos, end), true));
-            start = end;
-        }
-    }
-    if start < span.end {
-        result.push((Span::new(start, span.end), false));
-    }
-    result
-}
-
-fn find_matching_brackets(
-    line: &str,
-    working_set: &StateWorkingSet,
-    block: &Block,
-    global_span_offset: usize,
-    global_cursor_offset: usize,
-) -> Vec<usize> {
-    const BRACKETS: &str = "{}[]()";
-
-    // calculate first bracket position
-    let global_end_offset = line.len() + global_span_offset;
-    let global_bracket_pos =
-        if global_cursor_offset == global_end_offset && global_end_offset > global_span_offset {
-            // cursor is at the end of a non-empty string -- find block end at the previous position
-            if let Some(last_char) = line.chars().last() {
-                global_cursor_offset - get_char_length(last_char)
-            } else {
-                global_cursor_offset
-            }
-        } else {
-            // cursor is in the middle of a string -- find block end at the current position
-            global_cursor_offset
-        };
-
-    // check that position contains bracket
-    let match_idx = global_bracket_pos - global_span_offset;
-    if match_idx >= line.len()
-        || !BRACKETS.contains(get_char_at_index(line, match_idx).unwrap_or_default())
-    {
-        return Vec::new();
-    }
-
-    // find matching bracket by finding matching block end
-    let matching_block_end = find_matching_block_end_in_block(
-        line,
-        working_set,
-        block,
-        global_span_offset,
-        global_bracket_pos,
-    );
-    if let Some(pos) = matching_block_end {
-        let matching_idx = pos - global_span_offset;
-        if BRACKETS.contains(get_char_at_index(line, matching_idx).unwrap_or_default()) {
-            return if global_bracket_pos < pos {
-                vec![global_bracket_pos, pos]
-            } else {
-                vec![pos, global_bracket_pos]
-            };
-        }
-    }
-    Vec::new()
-}
-
-fn find_matching_block_end_in_block(
-    line: &str,
-    working_set: &StateWorkingSet,
-    block: &Block,
-    global_span_offset: usize,
-    global_cursor_offset: usize,
-) -> Option<usize> {
-    for p in &block.pipelines {
-        for e in &p.elements {
-            match e {
-                PipelineElement::Expression(_, e)
-                | PipelineElement::Redirection(_, _, e)
-                | PipelineElement::And(_, e)
-                | PipelineElement::Or(_, e) => {
-                    if e.span.contains(global_cursor_offset) {
-                        if let Some(pos) = find_matching_block_end_in_expr(
-                            line,
-                            working_set,
-                            e,
-                            global_span_offset,
-                            global_cursor_offset,
-                        ) {
-                            return Some(pos);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    None
-}
-
-fn find_matching_block_end_in_expr(
-    line: &str,
-    working_set: &StateWorkingSet,
-    expression: &Expression,
-    global_span_offset: usize,
-    global_cursor_offset: usize,
-) -> Option<usize> {
-    macro_rules! find_in_expr_or_continue {
-        ($inner_expr:ident) => {
-            if let Some(pos) = find_matching_block_end_in_expr(
-                line,
-                working_set,
-                $inner_expr,
-                global_span_offset,
-                global_cursor_offset,
-            ) {
-                return Some(pos);
-            }
-        };
-    }
-
-    if expression.span.contains(global_cursor_offset) && expression.span.start >= global_span_offset
-    {
-        let expr_first = expression.span.start;
-        let span_str = &line
-            [expression.span.start - global_span_offset..expression.span.end - global_span_offset];
-        let expr_last = span_str
-            .chars()
-            .last()
-            .map(|c| expression.span.end - get_char_length(c))
-            .unwrap_or(expression.span.start);
-
-        return match &expression.expr {
-            Expr::Bool(_) => None,
-            Expr::Int(_) => None,
-            Expr::Float(_) => None,
-            Expr::Binary(_) => None,
-            Expr::Range(..) => None,
-            Expr::Var(_) => None,
-            Expr::VarDecl(_) => None,
-            Expr::ExternalCall(..) => None,
-            Expr::Operator(_) => None,
-            Expr::UnaryNot(_) => None,
-            Expr::Keyword(..) => None,
-            Expr::ValueWithUnit(..) => None,
-            Expr::DateTime(_) => None,
-            Expr::Filepath(_) => None,
-            Expr::Directory(_) => None,
-            Expr::GlobPattern(_) => None,
-            Expr::String(_) => None,
-            Expr::CellPath(_) => None,
-            Expr::ImportPattern(_) => None,
-            Expr::Overlay(_) => None,
-            Expr::Signature(_) => None,
-            Expr::Nothing => None,
-            Expr::Garbage => None,
-
-            Expr::Table(hdr, rows) => {
-                if expr_last == global_cursor_offset {
-                    // cursor is at table end
-                    Some(expr_first)
-                } else if expr_first == global_cursor_offset {
-                    // cursor is at table start
-                    Some(expr_last)
-                } else {
-                    // cursor is inside table
-                    for inner_expr in hdr {
-                        find_in_expr_or_continue!(inner_expr);
-                    }
-                    for row in rows {
-                        for inner_expr in row {
-                            find_in_expr_or_continue!(inner_expr);
-                        }
-                    }
-                    None
-                }
-            }
-
-            Expr::Record(exprs) => {
-                if expr_last == global_cursor_offset {
-                    // cursor is at record end
-                    Some(expr_first)
-                } else if expr_first == global_cursor_offset {
-                    // cursor is at record start
-                    Some(expr_last)
-                } else {
-                    // cursor is inside record
-                    for (k, v) in exprs {
-                        find_in_expr_or_continue!(k);
-                        find_in_expr_or_continue!(v);
-                    }
-                    None
-                }
-            }
-
-            Expr::Call(call) => {
-                for arg in &call.arguments {
-                    let opt_expr = match arg {
-                        Argument::Named((_, _, opt_expr)) => opt_expr.as_ref(),
-                        Argument::Positional(inner_expr) => Some(inner_expr),
-                    };
-
-                    if let Some(inner_expr) = opt_expr {
-                        find_in_expr_or_continue!(inner_expr);
-                    }
-                }
-                None
-            }
-
-            Expr::FullCellPath(b) => find_matching_block_end_in_expr(
-                line,
-                working_set,
-                &b.head,
-                global_span_offset,
-                global_cursor_offset,
-            ),
-
-            Expr::BinaryOp(lhs, op, rhs) => {
-                find_in_expr_or_continue!(lhs);
-                find_in_expr_or_continue!(op);
-                find_in_expr_or_continue!(rhs);
-                None
-            }
-
-            Expr::Block(block_id)
-            | Expr::Closure(block_id)
-            | Expr::RowCondition(block_id)
-            | Expr::Subexpression(block_id) => {
-                if expr_last == global_cursor_offset {
-                    // cursor is at block end
-                    Some(expr_first)
-                } else if expr_first == global_cursor_offset {
-                    // cursor is at block start
-                    Some(expr_last)
-                } else {
-                    // cursor is inside block
-                    let nested_block = working_set.get_block(*block_id);
-                    find_matching_block_end_in_block(
-                        line,
-                        working_set,
-                        nested_block,
-                        global_span_offset,
-                        global_cursor_offset,
-                    )
-                }
-            }
-
-            Expr::StringInterpolation(inner_expr) => {
-                for inner_expr in inner_expr {
-                    find_in_expr_or_continue!(inner_expr);
-                }
-                None
-            }
-
-            Expr::List(inner_expr) => {
-                if expr_last == global_cursor_offset {
-                    // cursor is at list end
-                    Some(expr_first)
-                } else if expr_first == global_cursor_offset {
-                    // cursor is at list start
-                    Some(expr_last)
-                } else {
-                    // cursor is inside list
-                    for inner_expr in inner_expr {
-                        find_in_expr_or_continue!(inner_expr);
-                    }
-                    None
-                }
-            }
-        };
-    }
-    None
-}
-
-fn get_char_at_index(s: &str, index: usize) -> Option<char> {
-    s[index..].chars().next()
-}
-
-fn get_char_length(c: char) -> usize {
-    c.to_string().len()
-}

crates/nu-cli/src/util.rs

@@ -1,11 +1,11 @@
-use crate::repl::eval_hook;
+use log::trace;
 use nu_engine::eval_block;
 use nu_parser::{escape_quote_string, lex, parse, unescape_unquote_string, Token, TokenContents};
 use nu_protocol::engine::StateWorkingSet;
 use nu_protocol::CliError;
 use nu_protocol::{
     engine::{EngineState, Stack},
-    print_if_stream, PipelineData, ShellError, Span, Value,
+    PipelineData, ShellError, Span, Value,
 };
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
@@ -204,6 +204,8 @@ pub fn eval_source(
     fname: &str,
     input: PipelineData,
 ) -> bool {
+    trace!("eval_source");
+
     let (block, delta) = {
         let mut working_set = StateWorkingSet::new(engine_state);
         let (output, err) = parse(
@@ -229,41 +231,23 @@ pub fn eval_source(
     }
 
     match eval_block(engine_state, stack, &block, input, false, false) {
-        Ok(pipeline_data) => {
-            let config = engine_state.get_config();
-            let result;
-            if let PipelineData::ExternalStream {
-                stdout: stream,
-                stderr: stderr_stream,
-                exit_code,
-                ..
-            } = pipeline_data
-            {
-                result = print_if_stream(stream, stderr_stream, false, exit_code);
-            } else if let Some(hook) = config.hooks.display_output.clone() {
-                match eval_hook(engine_state, stack, Some(pipeline_data), vec![], &hook) {
-                    Err(err) => {
-                        result = Err(err);
-                    }
-                    Ok(val) => {
-                        result = val.print(engine_state, stack, false, false);
-                    }
+        Ok(mut pipeline_data) => {
+            if let PipelineData::ExternalStream { exit_code, .. } = &mut pipeline_data {
+                if let Some(exit_code) = exit_code.take().and_then(|it| it.last()) {
+                    stack.add_env_var("LAST_EXIT_CODE".to_string(), exit_code);
+                } else {
+                    set_last_exit_code(stack, 0);
                 }
             } else {
-                result = pipeline_data.print(engine_state, stack, true, false);
+                set_last_exit_code(stack, 0);
             }
 
-            match result {
-                Err(err) => {
-                    let working_set = StateWorkingSet::new(engine_state);
+            if let Err(err) = pipeline_data.print(engine_state, stack, false, false) {
+                let working_set = StateWorkingSet::new(engine_state);
 
-                    report_error(&working_set, &err);
+                report_error(&working_set, &err);
 
-                    return false;
-                }
-                Ok(exit_code) => {
-                    set_last_exit_code(stack, exit_code);
-                }
+                return false;
             }
 
             // reset vt processing, aka ansi because illbehaved externals can break it
@@ -289,7 +273,10 @@ pub fn eval_source(
 fn set_last_exit_code(stack: &mut Stack, exit_code: i64) {
     stack.add_env_var(
         "LAST_EXIT_CODE".to_string(),
-        Value::int(exit_code, Span::unknown()),
+        Value::Int {
+            val: exit_code,
+            span: Span { start: 0, end: 0 },
+        },
     );
 }
 

crates/nu-cli/tests/alias.rs

@@ -0,0 +1,65 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use support::{match_suggestions, new_engine};
+
+#[test]
+fn alias_of_command_and_flags() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls -l"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("ll t", 4);
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn alias_of_basic_command() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls "#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("ll t", 4);
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn alias_of_another_alias() {
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Create an alias
+    let alias = r#"alias ll = ls -la"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir.clone()).is_ok());
+    // Create the second alias
+    let alias = r#"alias lf = ll -f"#;
+    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let suggestions = completer.complete("lf t", 4);
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
+
+    match_suggestions(expected_paths, suggestions)
+}

crates/nu-cli/tests/completions.rs

@@ -1,752 +0,0 @@
-pub mod support;
-
-use nu_cli::NuCompleter;
-use nu_parser::parse;
-use nu_protocol::engine::StateWorkingSet;
-use reedline::{Completer, Suggestion};
-use rstest::{fixture, rstest};
-use support::{completions_helpers::new_quote_engine, file, folder, match_suggestions, new_engine};
-
-#[fixture]
-fn completer() -> NuCompleter {
-    // Create a new engine
-    let (dir, _, mut engine, mut stack) = new_engine();
-
-    // Add record value as example
-    let record = "def tst [--mod -s] {}";
-    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
-
-    // Instantiate a new completer
-    NuCompleter::new(std::sync::Arc::new(engine), stack)
-}
-
-#[fixture]
-fn completer_strings() -> NuCompleter {
-    // Create a new engine
-    let (dir, _, mut engine, mut stack) = new_engine();
-
-    // Add record value as example
-    let record = r#"def animals [] { ["cat", "dog", "eel" ] }
-    def my-command [animal: string@animals] { print $animal }"#;
-    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
-
-    // Instantiate a new completer
-    NuCompleter::new(std::sync::Arc::new(engine), stack)
-}
-
-#[test]
-fn variables_dollar_sign_with_varialblecompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "$ ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    assert_eq!(7, suggestions.len());
-}
-
-#[rstest]
-fn variables_double_dash_argument_with_flagcompletion(mut completer: NuCompleter) {
-    let suggestions = completer.complete("tst --", 6);
-    let expected: Vec<String> = vec!["--help".into(), "--mod".into()];
-    // dbg!(&expected, &suggestions);
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn variables_single_dash_argument_with_flagcompletion(mut completer: NuCompleter) {
-    let suggestions = completer.complete("tst -", 5);
-    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn variables_command_with_commandcompletion(mut completer_strings: NuCompleter) {
-    let suggestions = completer_strings.complete("my-c ", 4);
-    let expected: Vec<String> = vec!["my-command".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn variables_subcommands_with_customcompletion(mut completer_strings: NuCompleter) {
-    let suggestions = completer_strings.complete("my-command ", 11);
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn variables_customcompletion_subcommands_with_customcompletion_2(
-    mut completer_strings: NuCompleter,
-) {
-    let suggestions = completer_strings.complete("my-command ", 11);
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[test]
-fn dotnu_completions() {
-    // Create a new engine
-    let (_, _, engine, stack) = new_engine();
-
-    // Instatiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    // Test source completion
-    let completion_str = "source-env ".to_string();
-    let suggestions = completer.complete(&completion_str, completion_str.len());
-
-    assert_eq!(1, suggestions.len());
-    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
-
-    // Test use completion
-    let completion_str = "use ".to_string();
-    let suggestions = completer.complete(&completion_str, completion_str.len());
-
-    assert_eq!(1, suggestions.len());
-    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
-}
-
-#[test]
-#[ignore]
-fn external_completer_trailing_space() {
-    // https://github.com/nushell/nushell/issues/6378
-    let block = "let external_completer = {|spans| $spans}";
-    let input = "gh alias ".to_string();
-
-    let suggestions = run_external_completion(block, &input);
-    assert_eq!(3, suggestions.len());
-    assert_eq!("gh", suggestions.get(0).unwrap().value);
-    assert_eq!("alias", suggestions.get(1).unwrap().value);
-    assert_eq!("", suggestions.get(2).unwrap().value);
-}
-
-#[test]
-fn external_completer_no_trailing_space() {
-    let block = "let external_completer = {|spans| $spans}";
-    let input = "gh alias".to_string();
-
-    let suggestions = run_external_completion(block, &input);
-    assert_eq!(2, suggestions.len());
-    assert_eq!("gh", suggestions.get(0).unwrap().value);
-    assert_eq!("alias", suggestions.get(1).unwrap().value);
-}
-
-#[test]
-fn external_completer_pass_flags() {
-    let block = "let external_completer = {|spans| $spans}";
-    let input = "gh api --".to_string();
-
-    let suggestions = run_external_completion(block, &input);
-    assert_eq!(3, suggestions.len());
-    assert_eq!("gh", suggestions.get(0).unwrap().value);
-    assert_eq!("api", suggestions.get(1).unwrap().value);
-    assert_eq!("--", suggestions.get(2).unwrap().value);
-}
-
-#[test]
-fn file_completions() {
-    // Create a new engine
-    let (dir, dir_str, engine, stack) = new_engine();
-
-    // Instatiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    // Test completions for the current folder
-    let target_dir = format!("cp {}", dir_str);
-    let suggestions = completer.complete(&target_dir, target_dir.len());
-
-    // Create the expected values
-    let expected_paths: Vec<String> = vec![
-        file(dir.join("nushell")),
-        folder(dir.join("test_a")),
-        folder(dir.join("test_b")),
-        folder(dir.join("another")),
-        file(dir.join("custom_completion.nu")),
-        file(dir.join(".hidden_file")),
-        folder(dir.join(".hidden_folder")),
-    ];
-
-    // Match the results
-    match_suggestions(expected_paths, suggestions);
-
-    // Test completions for a file
-    let target_dir = format!("cp {}", folder(dir.join("another")));
-    let suggestions = completer.complete(&target_dir, target_dir.len());
-
-    // Create the expected values
-    let expected_paths: Vec<String> = vec![file(dir.join("another").join("newfile"))];
-
-    // Match the results
-    match_suggestions(expected_paths, suggestions);
-}
-
-#[test]
-fn command_ls_with_filecompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "ls ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-#[test]
-fn command_open_with_filecompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "open ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn command_rm_with_globcompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "rm ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn command_cp_with_globcompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "cp ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn command_save_with_filecompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "save ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn command_touch_with_filecompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "touch ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn command_watch_with_filecompletion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "watch ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn file_completion_quoted() {
-    let (_, _, engine, stack) = new_quote_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "open ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    let expected_paths: Vec<String> = vec![
-        "`te st.txt`".to_string(),
-        "`te#st.txt`".to_string(),
-        "`te'st.txt`".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn flag_completions() {
-    // Create a new engine
-    let (_, _, engine, stack) = new_engine();
-
-    // Instatiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-    // Test completions for the 'ls' flags
-    let suggestions = completer.complete("ls -", 4);
-
-    assert_eq!(14, suggestions.len());
-
-    let expected: Vec<String> = vec![
-        "--all".into(),
-        "--directory".into(),
-        "--du".into(),
-        "--full-paths".into(),
-        "--help".into(),
-        "--long".into(),
-        "--short-names".into(),
-        "-D".into(),
-        "-a".into(),
-        "-d".into(),
-        "-f".into(),
-        "-h".into(),
-        "-l".into(),
-        "-s".into(),
-    ];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-}
-
-#[test]
-fn folder_with_directorycompletions() {
-    // Create a new engine
-    let (dir, dir_str, engine, stack) = new_engine();
-
-    // Instatiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    // Test completions for the current folder
-    let target_dir = format!("cd {}", dir_str);
-    let suggestions = completer.complete(&target_dir, target_dir.len());
-
-    // Create the expected values
-    let expected_paths: Vec<String> = vec![
-        folder(dir.join("test_a")),
-        folder(dir.join("test_b")),
-        folder(dir.join("another")),
-        folder(dir.join(".hidden_folder")),
-    ];
-
-    // Match the results
-    match_suggestions(expected_paths, suggestions);
-}
-
-#[test]
-fn variables_completions() {
-    // Create a new engine
-    let (dir, _, mut engine, mut stack) = new_engine();
-
-    // Add record value as example
-    let record = "let actor = { name: 'Tom Hardy', age: 44 }";
-    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
-
-    // Instatiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    // Test completions for $nu
-    let suggestions = completer.complete("$nu.", 4);
-
-    assert_eq!(9, suggestions.len());
-
-    let expected: Vec<String> = vec![
-        "config-path".into(),
-        "env-path".into(),
-        "history-path".into(),
-        "home-path".into(),
-        "loginshell-path".into(),
-        "os-info".into(),
-        "pid".into(),
-        "scope".into(),
-        "temp-path".into(),
-    ];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $nu.h (filter)
-    let suggestions = completer.complete("$nu.h", 5);
-
-    assert_eq!(2, suggestions.len());
-
-    let expected: Vec<String> = vec!["history-path".into(), "home-path".into()];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for custom var
-    let suggestions = completer.complete("$actor.", 7);
-
-    assert_eq!(2, suggestions.len());
-
-    let expected: Vec<String> = vec!["age".into(), "name".into()];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for custom var (filtering)
-    let suggestions = completer.complete("$actor.n", 8);
-
-    assert_eq!(1, suggestions.len());
-
-    let expected: Vec<String> = vec!["name".into()];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $env
-    let suggestions = completer.complete("$env.", 5);
-
-    assert_eq!(2, suggestions.len());
-
-    let expected: Vec<String> = vec!["PWD".into(), "TEST".into()];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-
-    // Test completions for $env
-    let suggestions = completer.complete("$env.T", 6);
-
-    assert_eq!(1, suggestions.len());
-
-    let expected: Vec<String> = vec!["TEST".into()];
-
-    // Match results
-    match_suggestions(expected, suggestions);
-}
-
-#[test]
-fn alias_of_command_and_flags() {
-    let (dir, _, mut engine, mut stack) = new_engine();
-
-    // Create an alias
-    let alias = r#"alias ll = ls -l"#;
-    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let suggestions = completer.complete("ll t", 4);
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn alias_of_basic_command() {
-    let (dir, _, mut engine, mut stack) = new_engine();
-
-    // Create an alias
-    let alias = r#"alias ll = ls "#;
-    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let suggestions = completer.complete("ll t", 4);
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[test]
-fn alias_of_another_alias() {
-    let (dir, _, mut engine, mut stack) = new_engine();
-
-    // Create an alias
-    let alias = r#"alias ll = ls -la"#;
-    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir.clone()).is_ok());
-    // Create the second alias
-    let alias = r#"alias lf = ll -f"#;
-    assert!(support::merge_input(alias.as_bytes(), &mut engine, &mut stack, dir).is_ok());
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let suggestions = completer.complete("lf t", 4);
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec!["test_a\\".to_string(), "test_b\\".to_string()];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec!["test_a/".to_string(), "test_b/".to_string()];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-fn run_external_completion(block: &str, input: &str) -> Vec<Suggestion> {
-    // Create a new engine
-    let (dir, _, mut engine_state, mut stack) = new_engine();
-    let (_, delta) = {
-        let mut working_set = StateWorkingSet::new(&engine_state);
-        let (block, err) = parse(&mut working_set, None, block.as_bytes(), false, &[]);
-        assert!(err.is_none());
-
-        (block, working_set.render())
-    };
-
-    assert!(engine_state.merge_delta(delta).is_ok());
-
-    // Merge environment into the permanent state
-    assert!(engine_state.merge_env(&mut stack, &dir).is_ok());
-
-    let latest_block_id = engine_state.num_blocks() - 1;
-
-    // Change config adding the external completer
-    let mut config = engine_state.get_config().clone();
-    config.external_completer = Some(latest_block_id);
-    engine_state.set_config(&config);
-
-    // Instatiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine_state), stack);
-
-    completer.complete(input, input.len())
-}
-
-#[test]
-fn unknown_command_completion() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let target_dir = "thiscommanddoesnotexist ";
-    let suggestions = completer.complete(target_dir, target_dir.len());
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions)
-}
-
-#[rstest]
-fn flagcompletion_triggers_after_cursor(mut completer: NuCompleter) {
-    let suggestions = completer.complete("tst -h", 5);
-    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn customcompletion_triggers_after_cursor(mut completer_strings: NuCompleter) {
-    let suggestions = completer_strings.complete("my-command c", 11);
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn customcompletion_triggers_after_cursor_piped(mut completer_strings: NuCompleter) {
-    let suggestions = completer_strings.complete("my-command c | ls", 11);
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[rstest]
-fn flagcompletion_triggers_after_cursor_piped(mut completer: NuCompleter) {
-    let suggestions = completer.complete("tst -h | ls", 5);
-    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
-    match_suggestions(expected, suggestions);
-}
-
-#[test]
-fn filecompletions_triggers_after_cursor() {
-    let (_, _, engine, stack) = new_engine();
-
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
-
-    let suggestions = completer.complete("cp   test_c", 3);
-
-    #[cfg(windows)]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a\\".to_string(),
-        "test_b\\".to_string(),
-        "another\\".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder\\".to_string(),
-    ];
-    #[cfg(not(windows))]
-    let expected_paths: Vec<String> = vec![
-        "nushell".to_string(),
-        "test_a/".to_string(),
-        "test_b/".to_string(),
-        "another/".to_string(),
-        "custom_completion.nu".to_string(),
-        ".hidden_file".to_string(),
-        ".hidden_folder/".to_string(),
-    ];
-
-    match_suggestions(expected_paths, suggestions);
-}

crates/nu-cli/tests/custom_completions.rs

@@ -0,0 +1,69 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use rstest::{fixture, rstest};
+use support::{match_suggestions, new_engine};
+
+#[fixture]
+fn completer() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = "def tst [--mod -s] {}";
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
+#[fixture]
+fn completer_strings() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = r#"def animals [] { ["cat", "dog", "eel" ] }
+    def my-command [animal: string@animals] { print $animal }"#;
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
+#[rstest]
+fn variables_completions_double_dash_argument(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst --", 6);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into()];
+    // dbg!(&expected, &suggestions);
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_single_dash_argument(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst -", 5);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_command(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 9);
+    let expected: Vec<String> = vec!["my-command".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_subcommands(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_subcommands_2(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}

crates/nu-cli/tests/dotnu_completions.rs

@@ -0,0 +1,28 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use support::new_engine;
+
+#[test]
+fn dotnu_completions() {
+    // Create a new engine
+    let (_, _, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test source completion
+    let completion_str = "source ".to_string();
+    let suggestions = completer.complete(&completion_str, completion_str.len());
+
+    assert_eq!(1, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
+
+    // Test use completion
+    let completion_str = "use ".to_string();
+    let suggestions = completer.complete(&completion_str, completion_str.len());
+
+    assert_eq!(1, suggestions.len());
+    assert_eq!("custom_completion.nu", suggestions.get(0).unwrap().value);
+}

crates/nu-cli/tests/file_completions.rs

@@ -0,0 +1,272 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use support::{file, folder, match_suggestions, new_engine};
+
+#[test]
+fn file_completions() {
+    // Create a new engine
+    let (dir, dir_str, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test completions for the current folder
+    let target_dir = format!("cp {}", dir_str);
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        file(dir.join("nushell")),
+        folder(dir.join("test_a")),
+        folder(dir.join("test_b")),
+        folder(dir.join("another")),
+        file(dir.join("custom_completion.nu")),
+        file(dir.join(".hidden_file")),
+        folder(dir.join(".hidden_folder")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+
+    // Test completions for a file
+    let target_dir = format!("cp {}", folder(dir.join("another")));
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![file(dir.join("another").join("newfile"))];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+}
+
+#[test]
+fn command_ls_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "ls ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+#[test]
+fn command_open_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "open ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_rm_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "rm ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_cp_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "cp ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_save_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "save ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_touch_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "touch ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}
+
+#[test]
+fn command_watch_completion() {
+    let (_, _, engine, stack) = new_engine();
+
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    let target_dir = "watch ";
+    let suggestions = completer.complete(target_dir, target_dir.len());
+
+    #[cfg(windows)]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a\\".to_string(),
+        "test_b\\".to_string(),
+        "another\\".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder\\".to_string(),
+    ];
+    #[cfg(not(windows))]
+    let expected_paths: Vec<String> = vec![
+        "nushell".to_string(),
+        "test_a/".to_string(),
+        "test_b/".to_string(),
+        "another/".to_string(),
+        "custom_completion.nu".to_string(),
+        ".hidden_file".to_string(),
+        ".hidden_folder/".to_string(),
+    ];
+
+    match_suggestions(expected_paths, suggestions)
+}

crates/nu-cli/tests/flag_completions.rs

@@ -0,0 +1,38 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use support::{match_suggestions, new_engine};
+
+#[test]
+fn flag_completions() {
+    // Create a new engine
+    let (_, _, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+    // Test completions for the 'ls' flags
+    let suggestions = completer.complete("ls -", 4);
+
+    assert_eq!(14, suggestions.len());
+
+    let expected: Vec<String> = vec![
+        "--all".into(),
+        "--directory".into(),
+        "--du".into(),
+        "--full-paths".into(),
+        "--help".into(),
+        "--long".into(),
+        "--short-names".into(),
+        "-D".into(),
+        "-a".into(),
+        "-d".into(),
+        "-f".into(),
+        "-h".into(),
+        "-l".into(),
+        "-s".into(),
+    ];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+}

crates/nu-cli/tests/folder_completions.rs

@@ -0,0 +1,29 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use support::{folder, match_suggestions, new_engine};
+
+#[test]
+fn folder_completions() {
+    // Create a new engine
+    let (dir, dir_str, engine, stack) = new_engine();
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test completions for the current folder
+    let target_dir = format!("cd {}", dir_str);
+    let suggestions = completer.complete(&target_dir, target_dir.len());
+
+    // Create the expected values
+    let expected_paths: Vec<String> = vec![
+        folder(dir.join("test_a")),
+        folder(dir.join("test_b")),
+        folder(dir.join("another")),
+        folder(dir.join(".hidden_folder")),
+    ];
+
+    // Match the results
+    match_suggestions(expected_paths, suggestions);
+}

crates/nu-cli/tests/support/completions_helpers.rs

@@ -33,53 +33,20 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
         "PWD".to_string(),
         Value::String {
             val: dir_str.clone(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
+            span: nu_protocol::Span {
+                start: 0,
+                end: dir_str.len(),
+            },
         },
     );
     stack.add_env_var(
         "TEST".to_string(),
         Value::String {
             val: "NUSHELL".to_string(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
-    );
-
-    // Merge environment into the permanent state
-    let merge_result = engine_state.merge_env(&mut stack, &dir);
-    assert!(merge_result.is_ok());
-
-    (dir, dir_str, engine_state, stack)
-}
-
-pub fn new_quote_engine() -> (PathBuf, String, EngineState, Stack) {
-    // Target folder inside assets
-    let dir = fs::fixtures().join("quoted_completions");
-    let mut dir_str = dir
-        .clone()
-        .into_os_string()
-        .into_string()
-        .unwrap_or_default();
-    dir_str.push(SEP);
-
-    // Create a new engine with default context
-    let mut engine_state = create_default_context();
-
-    // New stack
-    let mut stack = Stack::new();
-
-    // Add pwd as env var
-    stack.add_env_var(
-        "PWD".to_string(),
-        Value::String {
-            val: dir_str.clone(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
-        },
-    );
-    stack.add_env_var(
-        "TEST".to_string(),
-        Value::String {
-            val: "NUSHELL".to_string(),
-            span: nu_protocol::Span::new(0, dir_str.len()),
+            span: nu_protocol::Span {
+                start: 0,
+                end: dir_str.len(),
+            },
         },
     );
 
@@ -137,7 +104,9 @@ pub fn merge_input(
         (block, working_set.render())
     };
 
-    engine_state.merge_delta(delta)?;
+    if let Err(err) = engine_state.merge_delta(delta) {
+        return Err(err);
+    }
 
     assert!(eval_block(
         engine_state,
@@ -145,7 +114,7 @@ pub fn merge_input(
         &block,
         PipelineData::Value(
             Value::Nothing {
-                span: Span::unknown(),
+                span: Span { start: 0, end: 0 },
             },
             None
         ),

crates/nu-cli/tests/variables_completions.rs

@@ -0,0 +1,88 @@
+pub mod support;
+
+use nu_cli::NuCompleter;
+use reedline::Completer;
+use support::{match_suggestions, new_engine};
+
+#[test]
+fn variables_completions() {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = "let actor = { name: 'Tom Hardy', age: 44 }";
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instatiate a new completer
+    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+
+    // Test completions for $nu
+    let suggestions = completer.complete("$nu.", 4);
+
+    assert_eq!(9, suggestions.len());
+
+    let expected: Vec<String> = vec![
+        "config-path".into(),
+        "env-path".into(),
+        "history-path".into(),
+        "home-path".into(),
+        "loginshell-path".into(),
+        "os-info".into(),
+        "pid".into(),
+        "scope".into(),
+        "temp-path".into(),
+    ];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for $nu.h (filter)
+    let suggestions = completer.complete("$nu.h", 5);
+
+    assert_eq!(2, suggestions.len());
+
+    let expected: Vec<String> = vec!["history-path".into(), "home-path".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for custom var
+    let suggestions = completer.complete("$actor.", 7);
+
+    assert_eq!(2, suggestions.len());
+
+    let expected: Vec<String> = vec!["age".into(), "name".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for custom var (filtering)
+    let suggestions = completer.complete("$actor.n", 8);
+
+    assert_eq!(1, suggestions.len());
+
+    let expected: Vec<String> = vec!["name".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for $env
+    let suggestions = completer.complete("$env.", 5);
+
+    assert_eq!(2, suggestions.len());
+
+    let expected: Vec<String> = vec!["PWD".into(), "TEST".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+
+    // Test completions for $env
+    let suggestions = completer.complete("$env.T", 6);
+
+    assert_eq!(1, suggestions.len());
+
+    let expected: Vec<String> = vec!["TEST".into()];
+
+    // Match results
+    match_suggestions(expected, suggestions);
+}

crates/nu-color-config/Cargo.toml

@@ -1,22 +1,14 @@
 [package]
 authors = ["The Nushell Project Developers"]
 description = "Color configuration code used by Nushell"
-repository = "https://github.com/nushell/nushell/tree/main/crates/nu-color-config"
 edition = "2021"
 license = "MIT"
 name = "nu-color-config"
-version = "0.73.0"
+version = "0.66.2"
 
 [dependencies]
-serde = { version="1.0.123", features=["derive"] }
-# used only for text_style Alignments
-tabled = { version = "0.10.0", features = ["color"], default-features = false }
-
-nu-protocol = { path = "../nu-protocol", version = "0.73.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.2"  }
 nu-ansi-term = "0.46.0"
-nu-utils = { path = "../nu-utils", version = "0.73.0" }
-nu-engine = { path = "../nu-engine", version = "0.73.0" }
-nu-json = { path="../nu-json", version = "0.73.0"  }
-
-[dev-dependencies]
-nu-test-support = { path="../nu-test-support", version = "0.73.0"  }
+nu-json = { path = "../nu-json", version = "0.66.2"  }
+nu-table = { path = "../nu-table", version = "0.66.2"  }
+serde = { version="1.0.123", features=["derive"] }

crates/nu-color-config/src/color_config.rs

@@ -1,89 +1,418 @@
-use crate::{
-    nu_style::{color_from_hex, lookup_style},
-    parse_nustyle, NuStyle,
-};
-use nu_ansi_term::Style;
-use nu_protocol::Value;
+use crate::nu_style::{color_from_hex, color_string_to_nustyle};
+use nu_ansi_term::{Color, Style};
+use nu_protocol::Config;
+use nu_table::{Alignment, TextStyle};
 use std::collections::HashMap;
 
 pub fn lookup_ansi_color_style(s: &str) -> Style {
     if s.starts_with('#') {
-        color_from_hex(s)
-            .ok()
-            .and_then(|c| c.map(|c| c.normal()))
-            .unwrap_or_default()
+        match color_from_hex(s) {
+            Ok(c) => match c {
+                Some(c) => c.normal(),
+                None => Style::default(),
+            },
+            Err(_) => Style::default(),
+        }
     } else if s.starts_with('{') {
         color_string_to_nustyle(s.to_string())
     } else {
-        lookup_style(s)
+        match s {
+            "g" | "green" => Color::Green.normal(),
+            "gb" | "green_bold" => Color::Green.bold(),
+            "gu" | "green_underline" => Color::Green.underline(),
+            "gi" | "green_italic" => Color::Green.italic(),
+            "gd" | "green_dimmed" => Color::Green.dimmed(),
+            "gr" | "green_reverse" => Color::Green.reverse(),
+            "gbl" | "green_blink" => Color::Green.blink(),
+            "gst" | "green_strike" => Color::Green.strikethrough(),
+
+            "lg" | "light_green" => Color::LightGreen.normal(),
+            "lgb" | "light_green_bold" => Color::LightGreen.bold(),
+            "lgu" | "light_green_underline" => Color::LightGreen.underline(),
+            "lgi" | "light_green_italic" => Color::LightGreen.italic(),
+            "lgd" | "light_green_dimmed" => Color::LightGreen.dimmed(),
+            "lgr" | "light_green_reverse" => Color::LightGreen.reverse(),
+            "lgbl" | "light_green_blink" => Color::LightGreen.blink(),
+            "lgst" | "light_green_strike" => Color::LightGreen.strikethrough(),
+
+            "r" | "red" => Color::Red.normal(),
+            "rb" | "red_bold" => Color::Red.bold(),
+            "ru" | "red_underline" => Color::Red.underline(),
+            "ri" | "red_italic" => Color::Red.italic(),
+            "rd" | "red_dimmed" => Color::Red.dimmed(),
+            "rr" | "red_reverse" => Color::Red.reverse(),
+            "rbl" | "red_blink" => Color::Red.blink(),
+            "rst" | "red_strike" => Color::Red.strikethrough(),
+
+            "lr" | "light_red" => Color::LightRed.normal(),
+            "lrb" | "light_red_bold" => Color::LightRed.bold(),
+            "lru" | "light_red_underline" => Color::LightRed.underline(),
+            "lri" | "light_red_italic" => Color::LightRed.italic(),
+            "lrd" | "light_red_dimmed" => Color::LightRed.dimmed(),
+            "lrr" | "light_red_reverse" => Color::LightRed.reverse(),
+            "lrbl" | "light_red_blink" => Color::LightRed.blink(),
+            "lrst" | "light_red_strike" => Color::LightRed.strikethrough(),
+
+            "u" | "blue" => Color::Blue.normal(),
+            "ub" | "blue_bold" => Color::Blue.bold(),
+            "uu" | "blue_underline" => Color::Blue.underline(),
+            "ui" | "blue_italic" => Color::Blue.italic(),
+            "ud" | "blue_dimmed" => Color::Blue.dimmed(),
+            "ur" | "blue_reverse" => Color::Blue.reverse(),
+            "ubl" | "blue_blink" => Color::Blue.blink(),
+            "ust" | "blue_strike" => Color::Blue.strikethrough(),
+
+            "lu" | "light_blue" => Color::LightBlue.normal(),
+            "lub" | "light_blue_bold" => Color::LightBlue.bold(),
+            "luu" | "light_blue_underline" => Color::LightBlue.underline(),
+            "lui" | "light_blue_italic" => Color::LightBlue.italic(),
+            "lud" | "light_blue_dimmed" => Color::LightBlue.dimmed(),
+            "lur" | "light_blue_reverse" => Color::LightBlue.reverse(),
+            "lubl" | "light_blue_blink" => Color::LightBlue.blink(),
+            "lust" | "light_blue_strike" => Color::LightBlue.strikethrough(),
+
+            "b" | "black" => Color::Black.normal(),
+            "bb" | "black_bold" => Color::Black.bold(),
+            "bu" | "black_underline" => Color::Black.underline(),
+            "bi" | "black_italic" => Color::Black.italic(),
+            "bd" | "black_dimmed" => Color::Black.dimmed(),
+            "br" | "black_reverse" => Color::Black.reverse(),
+            "bbl" | "black_blink" => Color::Black.blink(),
+            "bst" | "black_strike" => Color::Black.strikethrough(),
+
+            "ligr" | "light_gray" => Color::LightGray.normal(),
+            "ligrb" | "light_gray_bold" => Color::LightGray.bold(),
+            "ligru" | "light_gray_underline" => Color::LightGray.underline(),
+            "ligri" | "light_gray_italic" => Color::LightGray.italic(),
+            "ligrd" | "light_gray_dimmed" => Color::LightGray.dimmed(),
+            "ligrr" | "light_gray_reverse" => Color::LightGray.reverse(),
+            "ligrbl" | "light_gray_blink" => Color::LightGray.blink(),
+            "ligrst" | "light_gray_strike" => Color::LightGray.strikethrough(),
+
+            "y" | "yellow" => Color::Yellow.normal(),
+            "yb" | "yellow_bold" => Color::Yellow.bold(),
+            "yu" | "yellow_underline" => Color::Yellow.underline(),
+            "yi" | "yellow_italic" => Color::Yellow.italic(),
+            "yd" | "yellow_dimmed" => Color::Yellow.dimmed(),
+            "yr" | "yellow_reverse" => Color::Yellow.reverse(),
+            "ybl" | "yellow_blink" => Color::Yellow.blink(),
+            "yst" | "yellow_strike" => Color::Yellow.strikethrough(),
+
+            "ly" | "light_yellow" => Color::LightYellow.normal(),
+            "lyb" | "light_yellow_bold" => Color::LightYellow.bold(),
+            "lyu" | "light_yellow_underline" => Color::LightYellow.underline(),
+            "lyi" | "light_yellow_italic" => Color::LightYellow.italic(),
+            "lyd" | "light_yellow_dimmed" => Color::LightYellow.dimmed(),
+            "lyr" | "light_yellow_reverse" => Color::LightYellow.reverse(),
+            "lybl" | "light_yellow_blink" => Color::LightYellow.blink(),
+            "lyst" | "light_yellow_strike" => Color::LightYellow.strikethrough(),
+
+            "p" | "purple" => Color::Purple.normal(),
+            "pb" | "purple_bold" => Color::Purple.bold(),
+            "pu" | "purple_underline" => Color::Purple.underline(),
+            "pi" | "purple_italic" => Color::Purple.italic(),
+            "pd" | "purple_dimmed" => Color::Purple.dimmed(),
+            "pr" | "purple_reverse" => Color::Purple.reverse(),
+            "pbl" | "purple_blink" => Color::Purple.blink(),
+            "pst" | "purple_strike" => Color::Purple.strikethrough(),
+
+            "lp" | "light_purple" => Color::LightPurple.normal(),
+            "lpb" | "light_purple_bold" => Color::LightPurple.bold(),
+            "lpu" | "light_purple_underline" => Color::LightPurple.underline(),
+            "lpi" | "light_purple_italic" => Color::LightPurple.italic(),
+            "lpd" | "light_purple_dimmed" => Color::LightPurple.dimmed(),
+            "lpr" | "light_purple_reverse" => Color::LightPurple.reverse(),
+            "lpbl" | "light_purple_blink" => Color::LightPurple.blink(),
+            "lpst" | "light_purple_strike" => Color::LightPurple.strikethrough(),
+
+            "c" | "cyan" => Color::Cyan.normal(),
+            "cb" | "cyan_bold" => Color::Cyan.bold(),
+            "cu" | "cyan_underline" => Color::Cyan.underline(),
+            "ci" | "cyan_italic" => Color::Cyan.italic(),
+            "cd" | "cyan_dimmed" => Color::Cyan.dimmed(),
+            "cr" | "cyan_reverse" => Color::Cyan.reverse(),
+            "cbl" | "cyan_blink" => Color::Cyan.blink(),
+            "cst" | "cyan_strike" => Color::Cyan.strikethrough(),
+
+            "lc" | "light_cyan" => Color::LightCyan.normal(),
+            "lcb" | "light_cyan_bold" => Color::LightCyan.bold(),
+            "lcu" | "light_cyan_underline" => Color::LightCyan.underline(),
+            "lci" | "light_cyan_italic" => Color::LightCyan.italic(),
+            "lcd" | "light_cyan_dimmed" => Color::LightCyan.dimmed(),
+            "lcr" | "light_cyan_reverse" => Color::LightCyan.reverse(),
+            "lcbl" | "light_cyan_blink" => Color::LightCyan.blink(),
+            "lcst" | "light_cyan_strike" => Color::LightCyan.strikethrough(),
+
+            "w" | "white" => Color::White.normal(),
+            "wb" | "white_bold" => Color::White.bold(),
+            "wu" | "white_underline" => Color::White.underline(),
+            "wi" | "white_italic" => Color::White.italic(),
+            "wd" | "white_dimmed" => Color::White.dimmed(),
+            "wr" | "white_reverse" => Color::White.reverse(),
+            "wbl" | "white_blink" => Color::White.blink(),
+            "wst" | "white_strike" => Color::White.strikethrough(),
+
+            "dgr" | "dark_gray" => Color::DarkGray.normal(),
+            "dgrb" | "dark_gray_bold" => Color::DarkGray.bold(),
+            "dgru" | "dark_gray_underline" => Color::DarkGray.underline(),
+            "dgri" | "dark_gray_italic" => Color::DarkGray.italic(),
+            "dgrd" | "dark_gray_dimmed" => Color::DarkGray.dimmed(),
+            "dgrr" | "dark_gray_reverse" => Color::DarkGray.reverse(),
+            "dgrbl" | "dark_gray_blink" => Color::DarkGray.blink(),
+            "dgrst" | "dark_gray_strike" => Color::DarkGray.strikethrough(),
+
+            "def" | "default" => Color::Default.normal(),
+            "defb" | "default_bold" => Color::Default.bold(),
+            "defu" | "default_underline" => Color::Default.underline(),
+            "defi" | "default_italic" => Color::Default.italic(),
+            "defd" | "default_dimmed" => Color::Default.dimmed(),
+            "defr" | "default_reverse" => Color::Default.reverse(),
+
+            _ => Color::White.normal(),
+        }
     }
 }
 
-pub fn get_color_map(colors: &HashMap<String, Value>) -> HashMap<String, Style> {
-    let mut hm: HashMap<String, Style> = HashMap::new();
+fn update_hashmap(key: &str, val: &str, hm: &mut HashMap<String, Style>) {
+    // eprintln!("key: {}, val: {}", &key, &val);
+    let color = lookup_ansi_color_style(val);
+    if let Some(v) = hm.get_mut(key) {
+        *v = color;
+    } else {
+        hm.insert(key.to_string(), color);
+    }
+}
 
-    for (key, value) in colors {
-        parse_map_entry(&mut hm, key, value);
+pub fn get_color_config(config: &Config) -> HashMap<String, Style> {
+    let config = config;
+
+    // create the hashmap
+    let mut hm: HashMap<String, Style> = HashMap::new();
+    // set some defaults
+    // hm.insert("primitive_line".to_string(), Color::White.normal());
+    // hm.insert("primitive_pattern".to_string(), Color::White.normal());
+    // hm.insert("primitive_path".to_string(), Color::White.normal());
+    hm.insert("separator".to_string(), Color::White.normal());
+    hm.insert(
+        "leading_trailing_space_bg".to_string(),
+        Style::default().on(Color::Rgb(128, 128, 128)),
+    );
+    hm.insert("header".to_string(), Color::Green.bold());
+    hm.insert("empty".to_string(), Color::Blue.normal());
+    hm.insert("bool".to_string(), Color::White.normal());
+    hm.insert("int".to_string(), Color::White.normal());
+    hm.insert("filesize".to_string(), Color::White.normal());
+    hm.insert("duration".to_string(), Color::White.normal());
+    hm.insert("date".to_string(), Color::White.normal());
+    hm.insert("range".to_string(), Color::White.normal());
+    hm.insert("float".to_string(), Color::White.normal());
+    hm.insert("string".to_string(), Color::White.normal());
+    hm.insert("nothing".to_string(), Color::White.normal());
+    hm.insert("binary".to_string(), Color::White.normal());
+    hm.insert("cellpath".to_string(), Color::White.normal());
+    hm.insert("row_index".to_string(), Color::Green.bold());
+    hm.insert("record".to_string(), Color::White.normal());
+    hm.insert("list".to_string(), Color::White.normal());
+    hm.insert("block".to_string(), Color::White.normal());
+    hm.insert("hints".to_string(), Color::DarkGray.normal());
+
+    for (key, value) in &config.color_config {
+        let value = value
+            .as_string()
+            .expect("the only values for config color must be strings");
+        update_hashmap(key, &value, &mut hm);
+
+        // eprintln!(
+        //     "config: {}:{}\t\t\thashmap: {}:{:?}",
+        //     &key, &value, &key, &hm[key]
+        // );
     }
 
     hm
 }
 
-fn parse_map_entry(hm: &mut HashMap<String, Style>, key: &str, value: &Value) {
-    let value = match value {
-        Value::String { val, .. } => Some(lookup_ansi_color_style(val)),
-        Value::Record { cols, vals, .. } => get_style_from_value(cols, vals).map(parse_nustyle),
-        _ => None,
-    };
-    if let Some(value) = value {
-        hm.entry(key.to_owned()).or_insert(value);
-    }
-}
-
-fn get_style_from_value(cols: &[String], vals: &[Value]) -> Option<NuStyle> {
-    let mut was_set = false;
-    let mut style = NuStyle::from(Style::default());
-    for (col, val) in cols.iter().zip(vals) {
-        match col.as_str() {
-            "bg" => {
-                if let Value::String { val, .. } = val {
-                    style.bg = Some(val.clone());
-                    was_set = true;
-                }
+// This function will assign a text style to a primitive, or really any string that's
+// in the hashmap. The hashmap actually contains the style to be applied.
+pub fn style_primitive(primitive: &str, color_hm: &HashMap<String, Style>) -> TextStyle {
+    match primitive {
+        "bool" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
             }
-            "fg" => {
-                if let Value::String { val, .. } = val {
-                    style.fg = Some(val.clone());
-                    was_set = true;
-                }
-            }
-            "attr" => {
-                if let Value::String { val, .. } = val {
-                    style.attr = Some(val.clone());
-                    was_set = true;
-                }
-            }
-            _ => (),
         }
-    }
 
-    if was_set {
-        Some(style)
-    } else {
-        None
+        "int" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::basic_right(),
+            }
+        }
+
+        "filesize" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::basic_right(),
+            }
+        }
+
+        "duration" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "date" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "range" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "float" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::basic_right(),
+            }
+        }
+
+        "string" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "nothing" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        // not sure what to do with error
+        // "error" => {}
+        "binary" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "cellpath" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        "row_index" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Right, *s),
+                None => TextStyle::new()
+                    .alignment(Alignment::Right)
+                    .fg(Color::Green)
+                    .bold(Some(true)),
+            }
+        }
+
+        "record" | "list" | "block" => {
+            let style = color_hm.get(primitive);
+            match style {
+                Some(s) => TextStyle::with_style(Alignment::Left, *s),
+                None => TextStyle::basic_left(),
+            }
+        }
+
+        // types in nushell but not in engine-q
+        // "Line" => {
+        //     let style = color_hm.get("Primitive::Line");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "GlobPattern" => {
+        //     let style = color_hm.get("Primitive::GlobPattern");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "FilePath" => {
+        //     let style = color_hm.get("Primitive::FilePath");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "BeginningOfStream" => {
+        //     let style = color_hm.get("Primitive::BeginningOfStream");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        // "EndOfStream" => {
+        //     let style = color_hm.get("Primitive::EndOfStream");
+        //     match style {
+        //         Some(s) => TextStyle::with_style(Alignment::Left, *s),
+        //         None => TextStyle::basic_left(),
+        //     }
+        // }
+        _ => TextStyle::basic_left(),
     }
 }
 
-fn color_string_to_nustyle(color_string: String) -> Style {
-    // eprintln!("color_string: {}", &color_string);
-    if color_string.is_empty() {
-        return Style::default();
-    }
+#[test]
+fn test_hm() {
+    use nu_ansi_term::{Color, Style};
 
-    let nu_style = match nu_json::from_str::<NuStyle>(&color_string) {
-        Ok(s) => s,
-        Err(_) => return Style::default(),
-    };
+    let mut hm: HashMap<String, Style> = HashMap::new();
+    hm.insert("primitive_int".to_string(), Color::White.normal());
+    hm.insert("primitive_decimal".to_string(), Color::White.normal());
+    hm.insert("primitive_filesize".to_string(), Color::White.normal());
+    hm.insert("primitive_string".to_string(), Color::White.normal());
+    hm.insert("primitive_line".to_string(), Color::White.normal());
+    hm.insert("primitive_columnpath".to_string(), Color::White.normal());
+    hm.insert("primitive_pattern".to_string(), Color::White.normal());
+    hm.insert("primitive_boolean".to_string(), Color::White.normal());
+    hm.insert("primitive_date".to_string(), Color::White.normal());
+    hm.insert("primitive_duration".to_string(), Color::White.normal());
+    hm.insert("primitive_range".to_string(), Color::White.normal());
+    hm.insert("primitive_path".to_string(), Color::White.normal());
+    hm.insert("primitive_binary".to_string(), Color::White.normal());
+    hm.insert("separator".to_string(), Color::White.normal());
+    hm.insert("header_align".to_string(), Color::Green.bold());
+    hm.insert("header".to_string(), Color::Green.bold());
+    hm.insert("header_style".to_string(), Style::default());
+    hm.insert("row_index".to_string(), Color::Green.bold());
+    hm.insert(
+        "leading_trailing_space_bg".to_string(),
+        Style::default().on(Color::Rgb(128, 128, 128)),
+    );
 
-    parse_nustyle(nu_style)
+    update_hashmap("primitive_int", "green", &mut hm);
+
+    assert_eq!(hm["primitive_int"], Color::Green.normal());
 }

crates/nu-color-config/src/lib.rs

@@ -1,13 +1,7 @@
 mod color_config;
-mod matching_brackets_style;
 mod nu_style;
 mod shape_color;
-mod style_computer;
-mod text_style;
 
 pub use color_config::*;
-pub use matching_brackets_style::*;
 pub use nu_style::*;
 pub use shape_color::*;
-pub use style_computer::*;
-pub use text_style::*;

crates/nu-color-config/src/matching_brackets_style.rs

@@ -1,30 +0,0 @@
-use crate::color_config::lookup_ansi_color_style;
-use nu_ansi_term::Style;
-use nu_protocol::Config;
-
-pub fn get_matching_brackets_style(default_style: Style, conf: &Config) -> Style {
-    const MATCHING_BRACKETS_CONFIG_KEY: &str = "shape_matching_brackets";
-
-    match conf.color_config.get(MATCHING_BRACKETS_CONFIG_KEY) {
-        Some(int_color) => match int_color.as_string() {
-            Ok(int_color) => merge_styles(default_style, lookup_ansi_color_style(&int_color)),
-            Err(_) => default_style,
-        },
-        None => default_style,
-    }
-}
-
-fn merge_styles(base: Style, extra: Style) -> Style {
-    Style {
-        foreground: extra.foreground.or(base.foreground),
-        background: extra.background.or(base.background),
-        is_bold: extra.is_bold || base.is_bold,
-        is_dimmed: extra.is_dimmed || base.is_dimmed,
-        is_italic: extra.is_italic || base.is_italic,
-        is_underline: extra.is_underline || base.is_underline,
-        is_blink: extra.is_blink || base.is_blink,
-        is_reverse: extra.is_reverse || base.is_reverse,
-        is_hidden: extra.is_hidden || base.is_hidden,
-        is_strikethrough: extra.is_strikethrough || base.is_strikethrough,
-    }
-}

crates/nu-color-config/src/nu_style.rs

@@ -1,113 +1,88 @@
 use nu_ansi_term::{Color, Style};
-use nu_protocol::Value;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 
-#[derive(Deserialize, Serialize, PartialEq, Eq, Debug)]
+#[derive(Deserialize, PartialEq, Eq, Debug)]
 pub struct NuStyle {
     pub fg: Option<String>,
     pub bg: Option<String>,
     pub attr: Option<String>,
 }
 
-impl From<Style> for NuStyle {
-    fn from(s: Style) -> Self {
-        Self {
-            bg: s.background.and_then(color_to_string),
-            fg: s.foreground.and_then(color_to_string),
-            attr: style_get_attr(s),
-        }
-    }
-}
-
-fn style_get_attr(s: Style) -> Option<String> {
-    macro_rules! check {
-        ($attrs:expr, $b:expr, $c:expr) => {
-            if $b {
-                $attrs.push($c);
-            }
-        };
-    }
-
-    let mut attrs = String::new();
-
-    check!(attrs, s.is_blink, 'l');
-    check!(attrs, s.is_bold, 'b');
-    check!(attrs, s.is_dimmed, 'd');
-    check!(attrs, s.is_reverse, 'r');
-    check!(attrs, s.is_strikethrough, 's');
-    check!(attrs, s.is_underline, 'u');
-
-    if attrs.is_empty() {
-        None
-    } else {
-        Some(attrs)
-    }
-}
-
-fn color_to_string(color: Color) -> Option<String> {
-    match color {
-        Color::Black => Some(String::from("black")),
-        Color::DarkGray => Some(String::from("dark_gray")),
-        Color::Red => Some(String::from("red")),
-        Color::LightRed => Some(String::from("light_red")),
-        Color::Green => Some(String::from("green")),
-        Color::LightGreen => Some(String::from("light_green")),
-        Color::Yellow => Some(String::from("yellow")),
-        Color::LightYellow => Some(String::from("light_yellow")),
-        Color::Blue => Some(String::from("blue")),
-        Color::LightBlue => Some(String::from("light_blue")),
-        Color::Purple => Some(String::from("purple")),
-        Color::LightPurple => Some(String::from("light_purple")),
-        Color::Magenta => Some(String::from("magenta")),
-        Color::LightMagenta => Some(String::from("light_magenta")),
-        Color::Cyan => Some(String::from("cyan")),
-        Color::LightCyan => Some(String::from("light_cyan")),
-        Color::White => Some(String::from("white")),
-        Color::LightGray => Some(String::from("light_gray")),
-        Color::Default => Some(String::from("default")),
-        Color::Rgb(r, g, b) => Some(format!("#{:X}{:X}{:X}", r, g, b)),
-        Color::Fixed(_) => None,
-    }
-}
-
 pub fn parse_nustyle(nu_style: NuStyle) -> Style {
-    let mut style = Style {
-        foreground: nu_style.fg.and_then(|fg| lookup_color_str(&fg)),
-        background: nu_style.bg.and_then(|bg| lookup_color_str(&bg)),
-        ..Default::default()
+    // get the nu_ansi_term::Color foreground color
+    let fg_color = match nu_style.fg {
+        Some(fg) => color_from_hex(&fg).expect("error with foreground color"),
+        _ => None,
+    };
+    // get the nu_ansi_term::Color background color
+    let bg_color = match nu_style.bg {
+        Some(bg) => color_from_hex(&bg).expect("error with background color"),
+        _ => None,
+    };
+    // get the attributes
+    let color_attr = match nu_style.attr {
+        Some(attr) => attr,
+        _ => "".to_string(),
     };
 
-    if let Some(attrs) = nu_style.attr {
-        fill_modifiers(&attrs, &mut style)
-    }
+    // setup the attributes available in nu_ansi_term::Style
+    let mut bold = false;
+    let mut dimmed = false;
+    let mut italic = false;
+    let mut underline = false;
+    let mut blink = false;
+    let mut reverse = false;
+    let mut hidden = false;
+    let mut strikethrough = false;
 
-    style
-}
-
-// Converts the color_config records, { fg, bg, attr }, into a Style.
-pub fn color_record_to_nustyle(value: &Value) -> Style {
-    let mut fg = None;
-    let mut bg = None;
-    let mut attr = None;
-    let v = value.as_record();
-    if let Ok((cols, inner_vals)) = v {
-        for (k, v) in cols.iter().zip(inner_vals) {
-            // Because config already type-checked the color_config records, this doesn't bother giving errors
-            // if there are unrecognised keys or bad values.
-            if let Ok(v) = v.as_string() {
-                match k.as_str() {
-                    "fg" => fg = Some(v),
-
-                    "bg" => bg = Some(v),
-
-                    "attr" => attr = Some(v),
-                    _ => (),
-                }
-            }
+    // since we can combine styles like bold-italic, iterate through the chars
+    // and set the bools for later use in the nu_ansi_term::Style application
+    for ch in color_attr.to_lowercase().chars() {
+        match ch {
+            'l' => blink = true,
+            'b' => bold = true,
+            'd' => dimmed = true,
+            'h' => hidden = true,
+            'i' => italic = true,
+            'r' => reverse = true,
+            's' => strikethrough = true,
+            'u' => underline = true,
+            'n' => (),
+            _ => (),
         }
     }
 
-    parse_nustyle(NuStyle { fg, bg, attr })
+    // here's where we build the nu_ansi_term::Style
+    Style {
+        foreground: fg_color,
+        background: bg_color,
+        is_blink: blink,
+        is_bold: bold,
+        is_dimmed: dimmed,
+        is_hidden: hidden,
+        is_italic: italic,
+        is_reverse: reverse,
+        is_strikethrough: strikethrough,
+        is_underline: underline,
+    }
+}
+
+pub fn color_string_to_nustyle(color_string: String) -> Style {
+    // eprintln!("color_string: {}", &color_string);
+    if color_string.chars().count() < 1 {
+        Style::default()
+    } else {
+        let nu_style = match nu_json::from_str::<NuStyle>(&color_string) {
+            Ok(s) => s,
+            Err(_) => NuStyle {
+                fg: None,
+                bg: None,
+                attr: None,
+            },
+        };
+
+        parse_nustyle(nu_style)
+    }
 }
 
 pub fn color_from_hex(
@@ -126,471 +101,3 @@ pub fn color_from_hex(
         )))
     }
 }
-
-pub fn lookup_style(s: &str) -> Style {
-    match s {
-        "g" | "green" => Color::Green.normal(),
-        "gb" | "green_bold" => Color::Green.bold(),
-        "gu" | "green_underline" => Color::Green.underline(),
-        "gi" | "green_italic" => Color::Green.italic(),
-        "gd" | "green_dimmed" => Color::Green.dimmed(),
-        "gr" | "green_reverse" => Color::Green.reverse(),
-        "gbl" | "green_blink" => Color::Green.blink(),
-        "gst" | "green_strike" => Color::Green.strikethrough(),
-
-        "lg" | "light_green" => Color::LightGreen.normal(),
-        "lgb" | "light_green_bold" => Color::LightGreen.bold(),
-        "lgu" | "light_green_underline" => Color::LightGreen.underline(),
-        "lgi" | "light_green_italic" => Color::LightGreen.italic(),
-        "lgd" | "light_green_dimmed" => Color::LightGreen.dimmed(),
-        "lgr" | "light_green_reverse" => Color::LightGreen.reverse(),
-        "lgbl" | "light_green_blink" => Color::LightGreen.blink(),
-        "lgst" | "light_green_strike" => Color::LightGreen.strikethrough(),
-
-        "r" | "red" => Color::Red.normal(),
-        "rb" | "red_bold" => Color::Red.bold(),
-        "ru" | "red_underline" => Color::Red.underline(),
-        "ri" | "red_italic" => Color::Red.italic(),
-        "rd" | "red_dimmed" => Color::Red.dimmed(),
-        "rr" | "red_reverse" => Color::Red.reverse(),
-        "rbl" | "red_blink" => Color::Red.blink(),
-        "rst" | "red_strike" => Color::Red.strikethrough(),
-
-        "lr" | "light_red" => Color::LightRed.normal(),
-        "lrb" | "light_red_bold" => Color::LightRed.bold(),
-        "lru" | "light_red_underline" => Color::LightRed.underline(),
-        "lri" | "light_red_italic" => Color::LightRed.italic(),
-        "lrd" | "light_red_dimmed" => Color::LightRed.dimmed(),
-        "lrr" | "light_red_reverse" => Color::LightRed.reverse(),
-        "lrbl" | "light_red_blink" => Color::LightRed.blink(),
-        "lrst" | "light_red_strike" => Color::LightRed.strikethrough(),
-
-        "u" | "blue" => Color::Blue.normal(),
-        "ub" | "blue_bold" => Color::Blue.bold(),
-        "uu" | "blue_underline" => Color::Blue.underline(),
-        "ui" | "blue_italic" => Color::Blue.italic(),
-        "ud" | "blue_dimmed" => Color::Blue.dimmed(),
-        "ur" | "blue_reverse" => Color::Blue.reverse(),
-        "ubl" | "blue_blink" => Color::Blue.blink(),
-        "ust" | "blue_strike" => Color::Blue.strikethrough(),
-
-        "lu" | "light_blue" => Color::LightBlue.normal(),
-        "lub" | "light_blue_bold" => Color::LightBlue.bold(),
-        "luu" | "light_blue_underline" => Color::LightBlue.underline(),
-        "lui" | "light_blue_italic" => Color::LightBlue.italic(),
-        "lud" | "light_blue_dimmed" => Color::LightBlue.dimmed(),
-        "lur" | "light_blue_reverse" => Color::LightBlue.reverse(),
-        "lubl" | "light_blue_blink" => Color::LightBlue.blink(),
-        "lust" | "light_blue_strike" => Color::LightBlue.strikethrough(),
-
-        "b" | "black" => Color::Black.normal(),
-        "bb" | "black_bold" => Color::Black.bold(),
-        "bu" | "black_underline" => Color::Black.underline(),
-        "bi" | "black_italic" => Color::Black.italic(),
-        "bd" | "black_dimmed" => Color::Black.dimmed(),
-        "br" | "black_reverse" => Color::Black.reverse(),
-        "bbl" | "black_blink" => Color::Black.blink(),
-        "bst" | "black_strike" => Color::Black.strikethrough(),
-
-        "ligr" | "light_gray" => Color::LightGray.normal(),
-        "ligrb" | "light_gray_bold" => Color::LightGray.bold(),
-        "ligru" | "light_gray_underline" => Color::LightGray.underline(),
-        "ligri" | "light_gray_italic" => Color::LightGray.italic(),
-        "ligrd" | "light_gray_dimmed" => Color::LightGray.dimmed(),
-        "ligrr" | "light_gray_reverse" => Color::LightGray.reverse(),
-        "ligrbl" | "light_gray_blink" => Color::LightGray.blink(),
-        "ligrst" | "light_gray_strike" => Color::LightGray.strikethrough(),
-
-        "y" | "yellow" => Color::Yellow.normal(),
-        "yb" | "yellow_bold" => Color::Yellow.bold(),
-        "yu" | "yellow_underline" => Color::Yellow.underline(),
-        "yi" | "yellow_italic" => Color::Yellow.italic(),
-        "yd" | "yellow_dimmed" => Color::Yellow.dimmed(),
-        "yr" | "yellow_reverse" => Color::Yellow.reverse(),
-        "ybl" | "yellow_blink" => Color::Yellow.blink(),
-        "yst" | "yellow_strike" => Color::Yellow.strikethrough(),
-
-        "ly" | "light_yellow" => Color::LightYellow.normal(),
-        "lyb" | "light_yellow_bold" => Color::LightYellow.bold(),
-        "lyu" | "light_yellow_underline" => Color::LightYellow.underline(),
-        "lyi" | "light_yellow_italic" => Color::LightYellow.italic(),
-        "lyd" | "light_yellow_dimmed" => Color::LightYellow.dimmed(),
-        "lyr" | "light_yellow_reverse" => Color::LightYellow.reverse(),
-        "lybl" | "light_yellow_blink" => Color::LightYellow.blink(),
-        "lyst" | "light_yellow_strike" => Color::LightYellow.strikethrough(),
-
-        "p" | "purple" => Color::Purple.normal(),
-        "pb" | "purple_bold" => Color::Purple.bold(),
-        "pu" | "purple_underline" => Color::Purple.underline(),
-        "pi" | "purple_italic" => Color::Purple.italic(),
-        "pd" | "purple_dimmed" => Color::Purple.dimmed(),
-        "pr" | "purple_reverse" => Color::Purple.reverse(),
-        "pbl" | "purple_blink" => Color::Purple.blink(),
-        "pst" | "purple_strike" => Color::Purple.strikethrough(),
-
-        "lp" | "light_purple" => Color::LightPurple.normal(),
-        "lpb" | "light_purple_bold" => Color::LightPurple.bold(),
-        "lpu" | "light_purple_underline" => Color::LightPurple.underline(),
-        "lpi" | "light_purple_italic" => Color::LightPurple.italic(),
-        "lpd" | "light_purple_dimmed" => Color::LightPurple.dimmed(),
-        "lpr" | "light_purple_reverse" => Color::LightPurple.reverse(),
-        "lpbl" | "light_purple_blink" => Color::LightPurple.blink(),
-        "lpst" | "light_purple_strike" => Color::LightPurple.strikethrough(),
-
-        "c" | "cyan" => Color::Cyan.normal(),
-        "cb" | "cyan_bold" => Color::Cyan.bold(),
-        "cu" | "cyan_underline" => Color::Cyan.underline(),
-        "ci" | "cyan_italic" => Color::Cyan.italic(),
-        "cd" | "cyan_dimmed" => Color::Cyan.dimmed(),
-        "cr" | "cyan_reverse" => Color::Cyan.reverse(),
-        "cbl" | "cyan_blink" => Color::Cyan.blink(),
-        "cst" | "cyan_strike" => Color::Cyan.strikethrough(),
-
-        "lc" | "light_cyan" => Color::LightCyan.normal(),
-        "lcb" | "light_cyan_bold" => Color::LightCyan.bold(),
-        "lcu" | "light_cyan_underline" => Color::LightCyan.underline(),
-        "lci" | "light_cyan_italic" => Color::LightCyan.italic(),
-        "lcd" | "light_cyan_dimmed" => Color::LightCyan.dimmed(),
-        "lcr" | "light_cyan_reverse" => Color::LightCyan.reverse(),
-        "lcbl" | "light_cyan_blink" => Color::LightCyan.blink(),
-        "lcst" | "light_cyan_strike" => Color::LightCyan.strikethrough(),
-
-        "w" | "white" => Color::White.normal(),
-        "wb" | "white_bold" => Color::White.bold(),
-        "wu" | "white_underline" => Color::White.underline(),
-        "wi" | "white_italic" => Color::White.italic(),
-        "wd" | "white_dimmed" => Color::White.dimmed(),
-        "wr" | "white_reverse" => Color::White.reverse(),
-        "wbl" | "white_blink" => Color::White.blink(),
-        "wst" | "white_strike" => Color::White.strikethrough(),
-
-        "dgr" | "dark_gray" => Color::DarkGray.normal(),
-        "dgrb" | "dark_gray_bold" => Color::DarkGray.bold(),
-        "dgru" | "dark_gray_underline" => Color::DarkGray.underline(),
-        "dgri" | "dark_gray_italic" => Color::DarkGray.italic(),
-        "dgrd" | "dark_gray_dimmed" => Color::DarkGray.dimmed(),
-        "dgrr" | "dark_gray_reverse" => Color::DarkGray.reverse(),
-        "dgrbl" | "dark_gray_blink" => Color::DarkGray.blink(),
-        "dgrst" | "dark_gray_strike" => Color::DarkGray.strikethrough(),
-
-        "def" | "default" => Color::Default.normal(),
-        "defb" | "default_bold" => Color::Default.bold(),
-        "defu" | "default_underline" => Color::Default.underline(),
-        "defi" | "default_italic" => Color::Default.italic(),
-        "defd" | "default_dimmed" => Color::Default.dimmed(),
-        "defr" | "default_reverse" => Color::Default.reverse(),
-
-        // Add xterm 256 colors adding an x prefix where the name conflicts
-        "xblack" | "xterm_black" => Color::Fixed(0).normal(),
-        "maroon" | "xterm_maroon" => Color::Fixed(1).normal(),
-        "xgreen" | "xterm_green" => Color::Fixed(2).normal(),
-        "olive" | "xterm_olive" => Color::Fixed(3).normal(),
-        "navy" | "xterm_navy" => Color::Fixed(4).normal(),
-        "xpurplea" | "xterm_purplea" => Color::Fixed(5).normal(),
-        "teal" | "xterm_teal" => Color::Fixed(6).normal(),
-        "silver" | "xterm_silver" => Color::Fixed(7).normal(),
-        "grey" | "xterm_grey" => Color::Fixed(8).normal(),
-        "xred" | "xterm_red" => Color::Fixed(9).normal(),
-        "lime" | "xterm_lime" => Color::Fixed(10).normal(),
-        "xyellow" | "xterm_yellow" => Color::Fixed(11).normal(),
-        "xblue" | "xterm_blue" => Color::Fixed(12).normal(),
-        "fuchsia" | "xterm_fuchsia" => Color::Fixed(13).normal(),
-        "aqua" | "xterm_aqua" => Color::Fixed(14).normal(),
-        "xwhite" | "xterm_white" => Color::Fixed(15).normal(),
-        "grey0" | "xterm_grey0" => Color::Fixed(16).normal(),
-        "navyblue" | "xterm_navyblue" => Color::Fixed(17).normal(),
-        "darkblue" | "xterm_darkblue" => Color::Fixed(18).normal(),
-        "blue3a" | "xterm_blue3a" => Color::Fixed(19).normal(),
-        "blue3b" | "xterm_blue3b" => Color::Fixed(20).normal(),
-        "blue1" | "xterm_blue1" => Color::Fixed(21).normal(),
-        "darkgreen" | "xterm_darkgreen" => Color::Fixed(22).normal(),
-        "deepskyblue4a" | "xterm_deepskyblue4a" => Color::Fixed(23).normal(),
-        "deepskyblue4b" | "xterm_deepskyblue4b" => Color::Fixed(24).normal(),
-        "deepskyblue4c" | "xterm_deepskyblue4c" => Color::Fixed(25).normal(),
-        "dodgerblue3" | "xterm_dodgerblue3" => Color::Fixed(26).normal(),
-        "dodgerblue2" | "xterm_dodgerblue2" => Color::Fixed(27).normal(),
-        "green4" | "xterm_green4" => Color::Fixed(28).normal(),
-        "springgreen4" | "xterm_springgreen4" => Color::Fixed(29).normal(),
-        "turquoise4" | "xterm_turquoise4" => Color::Fixed(30).normal(),
-        "deepskyblue3a" | "xterm_deepskyblue3a" => Color::Fixed(31).normal(),
-        "deepskyblue3b" | "xterm_deepskyblue3b" => Color::Fixed(32).normal(),
-        "dodgerblue1" | "xterm_dodgerblue1" => Color::Fixed(33).normal(),
-        "green3a" | "xterm_green3a" => Color::Fixed(34).normal(),
-        "springgreen3a" | "xterm_springgreen3a" => Color::Fixed(35).normal(),
-        "darkcyan" | "xterm_darkcyan" => Color::Fixed(36).normal(),
-        "lightseagreen" | "xterm_lightseagreen" => Color::Fixed(37).normal(),
-        "deepskyblue2" | "xterm_deepskyblue2" => Color::Fixed(38).normal(),
-        "deepskyblue1" | "xterm_deepskyblue1" => Color::Fixed(39).normal(),
-        "green3b" | "xterm_green3b" => Color::Fixed(40).normal(),
-        "springgreen3b" | "xterm_springgreen3b" => Color::Fixed(41).normal(),
-        "springgreen2a" | "xterm_springgreen2a" => Color::Fixed(42).normal(),
-        "cyan3" | "xterm_cyan3" => Color::Fixed(43).normal(),
-        "darkturquoise" | "xterm_darkturquoise" => Color::Fixed(44).normal(),
-        "turquoise2" | "xterm_turquoise2" => Color::Fixed(45).normal(),
-        "green1" | "xterm_green1" => Color::Fixed(46).normal(),
-        "springgreen2b" | "xterm_springgreen2b" => Color::Fixed(47).normal(),
-        "springgreen1" | "xterm_springgreen1" => Color::Fixed(48).normal(),
-        "mediumspringgreen" | "xterm_mediumspringgreen" => Color::Fixed(49).normal(),
-        "cyan2" | "xterm_cyan2" => Color::Fixed(50).normal(),
-        "cyan1" | "xterm_cyan1" => Color::Fixed(51).normal(),
-        "darkreda" | "xterm_darkreda" => Color::Fixed(52).normal(),
-        "deeppink4a" | "xterm_deeppink4a" => Color::Fixed(53).normal(),
-        "purple4a" | "xterm_purple4a" => Color::Fixed(54).normal(),
-        "purple4b" | "xterm_purple4b" => Color::Fixed(55).normal(),
-        "purple3" | "xterm_purple3" => Color::Fixed(56).normal(),
-        "blueviolet" | "xterm_blueviolet" => Color::Fixed(57).normal(),
-        "orange4a" | "xterm_orange4a" => Color::Fixed(58).normal(),
-        "grey37" | "xterm_grey37" => Color::Fixed(59).normal(),
-        "mediumpurple4" | "xterm_mediumpurple4" => Color::Fixed(60).normal(),
-        "slateblue3a" | "xterm_slateblue3a" => Color::Fixed(61).normal(),
-        "slateblue3b" | "xterm_slateblue3b" => Color::Fixed(62).normal(),
-        "royalblue1" | "xterm_royalblue1" => Color::Fixed(63).normal(),
-        "chartreuse4" | "xterm_chartreuse4" => Color::Fixed(64).normal(),
-        "darkseagreen4a" | "xterm_darkseagreen4a" => Color::Fixed(65).normal(),
-        "paleturquoise4" | "xterm_paleturquoise4" => Color::Fixed(66).normal(),
-        "steelblue" | "xterm_steelblue" => Color::Fixed(67).normal(),
-        "steelblue3" | "xterm_steelblue3" => Color::Fixed(68).normal(),
-        "cornflowerblue" | "xterm_cornflowerblue" => Color::Fixed(69).normal(),
-        "chartreuse3a" | "xterm_chartreuse3a" => Color::Fixed(70).normal(),
-        "darkseagreen4b" | "xterm_darkseagreen4b" => Color::Fixed(71).normal(),
-        "cadetbluea" | "xterm_cadetbluea" => Color::Fixed(72).normal(),
-        "cadetblueb" | "xterm_cadetblueb" => Color::Fixed(73).normal(),
-        "skyblue3" | "xterm_skyblue3" => Color::Fixed(74).normal(),
-        "steelblue1a" | "xterm_steelblue1a" => Color::Fixed(75).normal(),
-        "chartreuse3b" | "xterm_chartreuse3b" => Color::Fixed(76).normal(),
-        "palegreen3a" | "xterm_palegreen3a" => Color::Fixed(77).normal(),
-        "seagreen3" | "xterm_seagreen3" => Color::Fixed(78).normal(),
-        "aquamarine3" | "xterm_aquamarine3" => Color::Fixed(79).normal(),
-        "mediumturquoise" | "xterm_mediumturquoise" => Color::Fixed(80).normal(),
-        "steelblue1b" | "xterm_steelblue1b" => Color::Fixed(81).normal(),
-        "chartreuse2a" | "xterm_chartreuse2a" => Color::Fixed(82).normal(),
-        "seagreen2" | "xterm_seagreen2" => Color::Fixed(83).normal(),
-        "seagreen1a" | "xterm_seagreen1a" => Color::Fixed(84).normal(),
-        "seagreen1b" | "xterm_seagreen1b" => Color::Fixed(85).normal(),
-        "aquamarine1a" | "xterm_aquamarine1a" => Color::Fixed(86).normal(),
-        "darkslategray2" | "xterm_darkslategray2" => Color::Fixed(87).normal(),
-        "darkredb" | "xterm_darkredb" => Color::Fixed(88).normal(),
-        "deeppink4b" | "xterm_deeppink4b" => Color::Fixed(89).normal(),
-        "darkmagentaa" | "xterm_darkmagentaa" => Color::Fixed(90).normal(),
-        "darkmagentab" | "xterm_darkmagentab" => Color::Fixed(91).normal(),
-        "darkvioleta" | "xterm_darkvioleta" => Color::Fixed(92).normal(),
-        "xpurpleb" | "xterm_purpleb" => Color::Fixed(93).normal(),
-        "orange4b" | "xterm_orange4b" => Color::Fixed(94).normal(),
-        "lightpink4" | "xterm_lightpink4" => Color::Fixed(95).normal(),
-        "plum4" | "xterm_plum4" => Color::Fixed(96).normal(),
-        "mediumpurple3a" | "xterm_mediumpurple3a" => Color::Fixed(97).normal(),
-        "mediumpurple3b" | "xterm_mediumpurple3b" => Color::Fixed(98).normal(),
-        "slateblue1" | "xterm_slateblue1" => Color::Fixed(99).normal(),
-        "yellow4a" | "xterm_yellow4a" => Color::Fixed(100).normal(),
-        "wheat4" | "xterm_wheat4" => Color::Fixed(101).normal(),
-        "grey53" | "xterm_grey53" => Color::Fixed(102).normal(),
-        "lightslategrey" | "xterm_lightslategrey" => Color::Fixed(103).normal(),
-        "mediumpurple" | "xterm_mediumpurple" => Color::Fixed(104).normal(),
-        "lightslateblue" | "xterm_lightslateblue" => Color::Fixed(105).normal(),
-        "yellow4b" | "xterm_yellow4b" => Color::Fixed(106).normal(),
-        "darkolivegreen3a" | "xterm_darkolivegreen3a" => Color::Fixed(107).normal(),
-        "darkseagreen" | "xterm_darkseagreen" => Color::Fixed(108).normal(),
-        "lightskyblue3a" | "xterm_lightskyblue3a" => Color::Fixed(109).normal(),
-        "lightskyblue3b" | "xterm_lightskyblue3b" => Color::Fixed(110).normal(),
-        "skyblue2" | "xterm_skyblue2" => Color::Fixed(111).normal(),
-        "chartreuse2b" | "xterm_chartreuse2b" => Color::Fixed(112).normal(),
-        "darkolivegreen3b" | "xterm_darkolivegreen3b" => Color::Fixed(113).normal(),
-        "palegreen3b" | "xterm_palegreen3b" => Color::Fixed(114).normal(),
-        "darkseagreen3a" | "xterm_darkseagreen3a" => Color::Fixed(115).normal(),
-        "darkslategray3" | "xterm_darkslategray3" => Color::Fixed(116).normal(),
-        "skyblue1" | "xterm_skyblue1" => Color::Fixed(117).normal(),
-        "chartreuse1" | "xterm_chartreuse1" => Color::Fixed(118).normal(),
-        "lightgreena" | "xterm_lightgreena" => Color::Fixed(119).normal(),
-        "lightgreenb" | "xterm_lightgreenb" => Color::Fixed(120).normal(),
-        "palegreen1a" | "xterm_palegreen1a" => Color::Fixed(121).normal(),
-        "aquamarine1b" | "xterm_aquamarine1b" => Color::Fixed(122).normal(),
-        "darkslategray1" | "xterm_darkslategray1" => Color::Fixed(123).normal(),
-        "red3a" | "xterm_red3a" => Color::Fixed(124).normal(),
-        "deeppink4c" | "xterm_deeppink4c" => Color::Fixed(125).normal(),
-        "mediumvioletred" | "xterm_mediumvioletred" => Color::Fixed(126).normal(),
-        "magenta3" | "xterm_magenta3" => Color::Fixed(127).normal(),
-        "darkvioletb" | "xterm_darkvioletb" => Color::Fixed(128).normal(),
-        "purplec" | "xterm_purplec" => Color::Fixed(129).normal(),
-        "darkorange3a" | "xterm_darkorange3a" => Color::Fixed(130).normal(),
-        "indianreda" | "xterm_indianreda" => Color::Fixed(131).normal(),
-        "hotpink3a" | "xterm_hotpink3a" => Color::Fixed(132).normal(),
-        "mediumorchid3" | "xterm_mediumorchid3" => Color::Fixed(133).normal(),
-        "mediumorchid" | "xterm_mediumorchid" => Color::Fixed(134).normal(),
-        "mediumpurple2a" | "xterm_mediumpurple2a" => Color::Fixed(135).normal(),
-        "darkgoldenrod" | "xterm_darkgoldenrod" => Color::Fixed(136).normal(),
-        "lightsalmon3a" | "xterm_lightsalmon3a" => Color::Fixed(137).normal(),
-        "rosybrown" | "xterm_rosybrown" => Color::Fixed(138).normal(),
-        "grey63" | "xterm_grey63" => Color::Fixed(139).normal(),
-        "mediumpurple2b" | "xterm_mediumpurple2b" => Color::Fixed(140).normal(),
-        "mediumpurple1" | "xterm_mediumpurple1" => Color::Fixed(141).normal(),
-        "gold3a" | "xterm_gold3a" => Color::Fixed(142).normal(),
-        "darkkhaki" | "xterm_darkkhaki" => Color::Fixed(143).normal(),
-        "navajowhite3" | "xterm_navajowhite3" => Color::Fixed(144).normal(),
-        "grey69" | "xterm_grey69" => Color::Fixed(145).normal(),
-        "lightsteelblue3" | "xterm_lightsteelblue3" => Color::Fixed(146).normal(),
-        "lightsteelblue" | "xterm_lightsteelblue" => Color::Fixed(147).normal(),
-        "yellow3a" | "xterm_yellow3a" => Color::Fixed(148).normal(),
-        "darkolivegreen3c" | "xterm_darkolivegreen3c" => Color::Fixed(149).normal(),
-        "darkseagreen3b" | "xterm_darkseagreen3b" => Color::Fixed(150).normal(),
-        "darkseagreen2a" | "xterm_darkseagreen2a" => Color::Fixed(151).normal(),
-        "lightcyan3" | "xterm_lightcyan3" => Color::Fixed(152).normal(),
-        "lightskyblue1" | "xterm_lightskyblue1" => Color::Fixed(153).normal(),
-        "greenyellow" | "xterm_greenyellow" => Color::Fixed(154).normal(),
-        "darkolivegreen2" | "xterm_darkolivegreen2" => Color::Fixed(155).normal(),
-        "palegreen1b" | "xterm_palegreen1b" => Color::Fixed(156).normal(),
-        "darkseagreen2b" | "xterm_darkseagreen2b" => Color::Fixed(157).normal(),
-        "darkseagreen1a" | "xterm_darkseagreen1a" => Color::Fixed(158).normal(),
-        "paleturquoise1" | "xterm_paleturquoise1" => Color::Fixed(159).normal(),
-        "red3b" | "xterm_red3b" => Color::Fixed(160).normal(),
-        "deeppink3a" | "xterm_deeppink3a" => Color::Fixed(161).normal(),
-        "deeppink3b" | "xterm_deeppink3b" => Color::Fixed(162).normal(),
-        "magenta3a" | "xterm_magenta3a" => Color::Fixed(163).normal(),
-        "magenta3b" | "xterm_magenta3b" => Color::Fixed(164).normal(),
-        "magenta2a" | "xterm_magenta2a" => Color::Fixed(165).normal(),
-        "darkorange3b" | "xterm_darkorange3b" => Color::Fixed(166).normal(),
-        "indianredb" | "xterm_indianredb" => Color::Fixed(167).normal(),
-        "hotpink3b" | "xterm_hotpink3b" => Color::Fixed(168).normal(),
-        "hotpink2" | "xterm_hotpink2" => Color::Fixed(169).normal(),
-        "orchid" | "xterm_orchid" => Color::Fixed(170).normal(),
-        "mediumorchid1a" | "xterm_mediumorchid1a" => Color::Fixed(171).normal(),
-        "orange3" | "xterm_orange3" => Color::Fixed(172).normal(),
-        "lightsalmon3b" | "xterm_lightsalmon3b" => Color::Fixed(173).normal(),
-        "lightpink3" | "xterm_lightpink3" => Color::Fixed(174).normal(),
-        "pink3" | "xterm_pink3" => Color::Fixed(175).normal(),
-        "plum3" | "xterm_plum3" => Color::Fixed(176).normal(),
-        "violet" | "xterm_violet" => Color::Fixed(177).normal(),
-        "gold3b" | "xterm_gold3b" => Color::Fixed(178).normal(),
-        "lightgoldenrod3" | "xterm_lightgoldenrod3" => Color::Fixed(179).normal(),
-        "tan" | "xterm_tan" => Color::Fixed(180).normal(),
-        "mistyrose3" | "xterm_mistyrose3" => Color::Fixed(181).normal(),
-        "thistle3" | "xterm_thistle3" => Color::Fixed(182).normal(),
-        "plum2" | "xterm_plum2" => Color::Fixed(183).normal(),
-        "yellow3b" | "xterm_yellow3b" => Color::Fixed(184).normal(),
-        "khaki3" | "xterm_khaki3" => Color::Fixed(185).normal(),
-        "lightgoldenrod2" | "xterm_lightgoldenrod2" => Color::Fixed(186).normal(),
-        "lightyellow3" | "xterm_lightyellow3" => Color::Fixed(187).normal(),
-        "grey84" | "xterm_grey84" => Color::Fixed(188).normal(),
-        "lightsteelblue1" | "xterm_lightsteelblue1" => Color::Fixed(189).normal(),
-        "yellow2" | "xterm_yellow2" => Color::Fixed(190).normal(),
-        "darkolivegreen1a" | "xterm_darkolivegreen1a" => Color::Fixed(191).normal(),
-        "darkolivegreen1b" | "xterm_darkolivegreen1b" => Color::Fixed(192).normal(),
-        "darkseagreen1b" | "xterm_darkseagreen1b" => Color::Fixed(193).normal(),
-        "honeydew2" | "xterm_honeydew2" => Color::Fixed(194).normal(),
-        "lightcyan1" | "xterm_lightcyan1" => Color::Fixed(195).normal(),
-        "red1" | "xterm_red1" => Color::Fixed(196).normal(),
-        "deeppink2" | "xterm_deeppink2" => Color::Fixed(197).normal(),
-        "deeppink1a" | "xterm_deeppink1a" => Color::Fixed(198).normal(),
-        "deeppink1b" | "xterm_deeppink1b" => Color::Fixed(199).normal(),
-        "magenta2b" | "xterm_magenta2b" => Color::Fixed(200).normal(),
-        "magenta1" | "xterm_magenta1" => Color::Fixed(201).normal(),
-        "orangered1" | "xterm_orangered1" => Color::Fixed(202).normal(),
-        "indianred1a" | "xterm_indianred1a" => Color::Fixed(203).normal(),
-        "indianred1b" | "xterm_indianred1b" => Color::Fixed(204).normal(),
-        "hotpinka" | "xterm_hotpinka" => Color::Fixed(205).normal(),
-        "hotpinkb" | "xterm_hotpinkb" => Color::Fixed(206).normal(),
-        "mediumorchid1b" | "xterm_mediumorchid1b" => Color::Fixed(207).normal(),
-        "darkorange" | "xterm_darkorange" => Color::Fixed(208).normal(),
-        "salmon1" | "xterm_salmon1" => Color::Fixed(209).normal(),
-        "lightcoral" | "xterm_lightcoral" => Color::Fixed(210).normal(),
-        "palevioletred1" | "xterm_palevioletred1" => Color::Fixed(211).normal(),
-        "orchid2" | "xterm_orchid2" => Color::Fixed(212).normal(),
-        "orchid1" | "xterm_orchid1" => Color::Fixed(213).normal(),
-        "orange1" | "xterm_orange1" => Color::Fixed(214).normal(),
-        "sandybrown" | "xterm_sandybrown" => Color::Fixed(215).normal(),
-        "lightsalmon1" | "xterm_lightsalmon1" => Color::Fixed(216).normal(),
-        "lightpink1" | "xterm_lightpink1" => Color::Fixed(217).normal(),
-        "pink1" | "xterm_pink1" => Color::Fixed(218).normal(),
-        "plum1" | "xterm_plum1" => Color::Fixed(219).normal(),
-        "gold1" | "xterm_gold1" => Color::Fixed(220).normal(),
-        "lightgoldenrod2a" | "xterm_lightgoldenrod2a" => Color::Fixed(221).normal(),
-        "lightgoldenrod2b" | "xterm_lightgoldenrod2b" => Color::Fixed(222).normal(),
-        "navajowhite1" | "xterm_navajowhite1" => Color::Fixed(223).normal(),
-        "mistyrose1" | "xterm_mistyrose1" => Color::Fixed(224).normal(),
-        "thistle1" | "xterm_thistle1" => Color::Fixed(225).normal(),
-        "yellow1" | "xterm_yellow1" => Color::Fixed(226).normal(),
-        "lightgoldenrod1" | "xterm_lightgoldenrod1" => Color::Fixed(227).normal(),
-        "khaki1" | "xterm_khaki1" => Color::Fixed(228).normal(),
-        "wheat1" | "xterm_wheat1" => Color::Fixed(229).normal(),
-        "cornsilk1" | "xterm_cornsilk1" => Color::Fixed(230).normal(),
-        "grey100" | "xterm_grey100" => Color::Fixed(231).normal(),
-        "grey3" | "xterm_grey3" => Color::Fixed(232).normal(),
-        "grey7" | "xterm_grey7" => Color::Fixed(233).normal(),
-        "grey11" | "xterm_grey11" => Color::Fixed(234).normal(),
-        "grey15" | "xterm_grey15" => Color::Fixed(235).normal(),
-        "grey19" | "xterm_grey19" => Color::Fixed(236).normal(),
-        "grey23" | "xterm_grey23" => Color::Fixed(237).normal(),
-        "grey27" | "xterm_grey27" => Color::Fixed(238).normal(),
-        "grey30" | "xterm_grey30" => Color::Fixed(239).normal(),
-        "grey35" | "xterm_grey35" => Color::Fixed(240).normal(),
-        "grey39" | "xterm_grey39" => Color::Fixed(241).normal(),
-        "grey42" | "xterm_grey42" => Color::Fixed(242).normal(),
-        "grey46" | "xterm_grey46" => Color::Fixed(243).normal(),
-        "grey50" | "xterm_grey50" => Color::Fixed(244).normal(),
-        "grey54" | "xterm_grey54" => Color::Fixed(245).normal(),
-        "grey58" | "xterm_grey58" => Color::Fixed(246).normal(),
-        "grey62" | "xterm_grey62" => Color::Fixed(247).normal(),
-        "grey66" | "xterm_grey66" => Color::Fixed(248).normal(),
-        "grey70" | "xterm_grey70" => Color::Fixed(249).normal(),
-        "grey74" | "xterm_grey74" => Color::Fixed(250).normal(),
-        "grey78" | "xterm_grey78" => Color::Fixed(251).normal(),
-        "grey82" | "xterm_grey82" => Color::Fixed(252).normal(),
-        "grey85" | "xterm_grey85" => Color::Fixed(253).normal(),
-        "grey89" | "xterm_grey89" => Color::Fixed(254).normal(),
-        "grey93" | "xterm_grey93" => Color::Fixed(255).normal(),
-        _ => Color::White.normal(),
-    }
-}
-
-pub fn lookup_color(s: &str) -> Option<Color> {
-    let color = match s {
-        "g" | "green" => Color::Green,
-        "lg" | "light_green" => Color::LightGreen,
-        "r" | "red" => Color::Red,
-        "lr" | "light_red" => Color::LightRed,
-        "u" | "blue" => Color::Blue,
-        "lu" | "light_blue" => Color::LightBlue,
-        "b" | "black" => Color::Black,
-        "ligr" | "light_gray" => Color::LightGray,
-        "y" | "yellow" => Color::Yellow,
-        "ly" | "light_yellow" => Color::LightYellow,
-        "p" | "purple" => Color::Purple,
-        "lp" | "light_purple" => Color::LightPurple,
-        "c" | "cyan" => Color::Cyan,
-        "lc" | "light_cyan" => Color::LightCyan,
-        "w" | "white" => Color::White,
-        "dgr" | "dark_gray" => Color::DarkGray,
-        "def" | "default" => Color::Default,
-        _ => return None,
-    };
-
-    Some(color)
-}
-
-fn fill_modifiers(attrs: &str, style: &mut Style) {
-    // setup the attributes available in nu_ansi_term::Style
-    //
-    // since we can combine styles like bold-italic, iterate through the chars
-    // and set the bools for later use in the nu_ansi_term::Style application
-    for ch in attrs.to_lowercase().chars() {
-        match ch {
-            'l' => style.is_blink = true,
-            'b' => style.is_bold = true,
-            'd' => style.is_dimmed = true,
-            'h' => style.is_hidden = true,
-            'i' => style.is_italic = true,
-            'r' => style.is_reverse = true,
-            's' => style.is_strikethrough = true,
-            'u' => style.is_underline = true,
-            'n' => (),
-            _ => (),
-        }
-    }
-}
-
-fn lookup_color_str(s: &str) -> Option<Color> {
-    if s.starts_with('#') {
-        color_from_hex(s).ok().and_then(|c| c)
-    } else {
-        lookup_color(s)
-    }
-}

crates/nu-color-config/src/shape_color.rs

@@ -9,36 +9,32 @@ pub fn get_shape_color(shape: String, conf: &Config) -> Style {
             Err(_) => Style::default(),
         },
         None => match shape.as_ref() {
-            "shape_and" => Style::new().fg(Color::Purple).bold(),
+            "shape_garbage" => Style::new().fg(Color::White).on(Color::Red).bold(),
             "shape_binary" => Style::new().fg(Color::Purple).bold(),
-            "shape_block" => Style::new().fg(Color::Blue).bold(),
             "shape_bool" => Style::new().fg(Color::LightCyan),
-            "shape_custom" => Style::new().fg(Color::Green),
-            "shape_datetime" => Style::new().fg(Color::Cyan).bold(),
-            "shape_directory" => Style::new().fg(Color::Cyan),
+            "shape_int" => Style::new().fg(Color::Purple).bold(),
+            "shape_float" => Style::new().fg(Color::Purple).bold(),
+            "shape_range" => Style::new().fg(Color::Yellow).bold(),
+            "shape_internalcall" => Style::new().fg(Color::Cyan).bold(),
             "shape_external" => Style::new().fg(Color::Cyan),
             "shape_externalarg" => Style::new().fg(Color::Green).bold(),
-            "shape_filepath" => Style::new().fg(Color::Cyan),
-            "shape_flag" => Style::new().fg(Color::Blue).bold(),
-            "shape_float" => Style::new().fg(Color::Purple).bold(),
-            "shape_garbage" => Style::new().fg(Color::White).on(Color::Red).bold(),
-            "shape_globpattern" => Style::new().fg(Color::Cyan).bold(),
-            "shape_int" => Style::new().fg(Color::Purple).bold(),
-            "shape_internalcall" => Style::new().fg(Color::Cyan).bold(),
-            "shape_list" => Style::new().fg(Color::Cyan).bold(),
             "shape_literal" => Style::new().fg(Color::Blue),
-            "shape_nothing" => Style::new().fg(Color::LightCyan),
             "shape_operator" => Style::new().fg(Color::Yellow),
-            "shape_or" => Style::new().fg(Color::Purple).bold(),
-            "shape_pipe" => Style::new().fg(Color::Purple).bold(),
-            "shape_range" => Style::new().fg(Color::Yellow).bold(),
-            "shape_record" => Style::new().fg(Color::Cyan).bold(),
-            "shape_redirection" => Style::new().fg(Color::Purple).bold(),
             "shape_signature" => Style::new().fg(Color::Green).bold(),
             "shape_string" => Style::new().fg(Color::Green),
             "shape_string_interpolation" => Style::new().fg(Color::Cyan).bold(),
+            "shape_datetime" => Style::new().fg(Color::Cyan).bold(),
+            "shape_list" => Style::new().fg(Color::Cyan).bold(),
             "shape_table" => Style::new().fg(Color::Blue).bold(),
+            "shape_record" => Style::new().fg(Color::Cyan).bold(),
+            "shape_block" => Style::new().fg(Color::Blue).bold(),
+            "shape_filepath" => Style::new().fg(Color::Cyan),
+            "shape_directory" => Style::new().fg(Color::Cyan),
+            "shape_globpattern" => Style::new().fg(Color::Cyan).bold(),
             "shape_variable" => Style::new().fg(Color::Purple),
+            "shape_flag" => Style::new().fg(Color::Blue).bold(),
+            "shape_custom" => Style::new().fg(Color::Green),
+            "shape_nothing" => Style::new().fg(Color::LightCyan),
             _ => Style::default(),
         },
     }

crates/nu-color-config/src/style_computer.rs

@@ -1,285 +0,0 @@
-use crate::{color_record_to_nustyle, lookup_ansi_color_style, TextStyle};
-use nu_ansi_term::{Color, Style};
-use nu_engine::eval_block;
-use nu_protocol::{
-    engine::{EngineState, Stack, StateWorkingSet},
-    CliError, IntoPipelineData, Value,
-};
-use tabled::alignment::AlignmentHorizontal;
-
-use std::{
-    collections::HashMap,
-    fmt::{Debug, Formatter, Result},
-};
-
-// ComputableStyle represents the valid user style types: a single color value, or a closure which
-// takes an input value and produces a color value. The latter represents a value which
-// is computed at use-time.
-#[derive(Debug, Clone)]
-pub enum ComputableStyle {
-    Static(Style),
-    Closure(Value),
-}
-
-// macro used for adding initial values to the style hashmap
-macro_rules! initial {
-    ($a:expr, $b:expr) => {
-        ($a.to_string(), ComputableStyle::Static($b))
-    };
-}
-
-// An alias for the mapping used internally by StyleComputer.
-pub type StyleMapping = HashMap<String, ComputableStyle>;
-//
-// A StyleComputer is an all-in-one way to compute styles. A nu command can
-// simply create it with from_config(), and then use it with compute().
-// It stores the engine state and stack needed to run closures that
-// may be defined as a user style.
-//
-pub struct StyleComputer<'a> {
-    engine_state: &'a EngineState,
-    stack: &'a Stack,
-    map: StyleMapping,
-}
-
-impl<'a> StyleComputer<'a> {
-    // This is NOT meant to be used in most cases - please use from_config() instead.
-    // This only exists for testing purposes.
-    pub fn new(
-        engine_state: &'a EngineState,
-        stack: &'a Stack,
-        map: StyleMapping,
-    ) -> StyleComputer<'a> {
-        StyleComputer {
-            engine_state,
-            stack,
-            map,
-        }
-    }
-    // The main method. Takes a string name which maps to a color_config style name,
-    // and a Nu value to pipe into any closures that may have been defined there.
-    pub fn compute(&self, style_name: &str, value: &Value) -> Style {
-        match self.map.get(style_name) {
-            // Static values require no computation.
-            Some(ComputableStyle::Static(s)) => *s,
-            // Closures are run here.
-            Some(ComputableStyle::Closure(Value::Closure {
-                val: block_id,
-                captures,
-                span,
-            })) => {
-                let block = self.engine_state.get_block(*block_id).clone();
-                // Because captures_to_stack() clones, we don't need to use with_env() here
-                // (contrast with_env() usage in `each` or `do`).
-                let mut stack = self.stack.captures_to_stack(captures);
-
-                // Support 1-argument blocks as well as 0-argument blocks.
-                if let Some(var) = block.signature.get_positional(0) {
-                    if let Some(var_id) = &var.var_id {
-                        stack.add_var(*var_id, value.clone());
-                    }
-                }
-
-                // Run the block.
-                match eval_block(
-                    self.engine_state,
-                    &mut stack,
-                    &block,
-                    value.clone().into_pipeline_data(),
-                    false,
-                    false,
-                ) {
-                    Ok(v) => {
-                        let value = v.into_value(*span);
-                        // These should be the same color data forms supported by color_config.
-                        match value {
-                            Value::Record { .. } => color_record_to_nustyle(&value),
-                            Value::String { val, .. } => lookup_ansi_color_style(&val),
-                            _ => Style::default(),
-                        }
-                    }
-                    // This is basically a copy of nu_cli::report_error(), but that isn't usable due to
-                    // dependencies. While crudely spitting out a bunch of errors like this is not ideal,
-                    // currently hook closure errors behave roughly the same.
-                    Err(e) => {
-                        eprintln!(
-                            "Error: {:?}",
-                            CliError(&e, &StateWorkingSet::new(self.engine_state))
-                        );
-                        Style::default()
-                    }
-                }
-            }
-            // There should be no other kinds of values (due to create_map() in config.rs filtering them out)
-            // so this is just a fallback.
-            _ => Style::default(),
-        }
-    }
-
-    // Used only by the `table` command.
-    pub fn style_primitive(&self, value: &Value) -> TextStyle {
-        let s = self.compute(&value.get_type().to_string(), value);
-        match *value {
-            Value::Bool { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Int { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
-
-            Value::Filesize { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
-
-            Value::Duration { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Date { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Range { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Float { .. } => TextStyle::with_style(AlignmentHorizontal::Right, s),
-
-            Value::String { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Nothing { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Binary { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::CellPath { .. } => TextStyle::with_style(AlignmentHorizontal::Left, s),
-
-            Value::Record { .. } | Value::List { .. } | Value::Block { .. } => {
-                TextStyle::with_style(AlignmentHorizontal::Left, s)
-            }
-            _ => TextStyle::basic_left(),
-        }
-    }
-
-    // The main constructor.
-    pub fn from_config(engine_state: &'a EngineState, stack: &'a Stack) -> StyleComputer<'a> {
-        let config = engine_state.get_config();
-
-        // Create the hashmap
-        let mut map: StyleMapping = HashMap::from([
-            initial!("separator", Color::White.normal()),
-            initial!(
-                "leading_trailing_space_bg",
-                Style::default().on(Color::Rgb(128, 128, 128))
-            ),
-            initial!("header", Color::White.normal()),
-            initial!("empty", Color::White.normal()),
-            initial!("bool", Color::White.normal()),
-            initial!("int", Color::White.normal()),
-            initial!("filesize", Color::White.normal()),
-            initial!("duration", Color::White.normal()),
-            initial!("date", Color::White.normal()),
-            initial!("range", Color::White.normal()),
-            initial!("float", Color::White.normal()),
-            initial!("string", Color::White.normal()),
-            initial!("nothing", Color::White.normal()),
-            initial!("binary", Color::White.normal()),
-            initial!("cellpath", Color::White.normal()),
-            initial!("row_index", Color::Green.bold()),
-            initial!("record", Color::White.normal()),
-            initial!("list", Color::White.normal()),
-            initial!("block", Color::White.normal()),
-            initial!("hints", Color::DarkGray.normal()),
-        ]);
-
-        for (key, value) in &config.color_config {
-            match value {
-                Value::Closure { .. } => {
-                    map.insert(key.to_string(), ComputableStyle::Closure(value.clone()));
-                }
-                Value::Record { .. } => {
-                    map.insert(
-                        key.to_string(),
-                        ComputableStyle::Static(color_record_to_nustyle(value)),
-                    );
-                }
-                Value::String { val, .. } => {
-                    // update the stylemap with the found key
-                    let color = lookup_ansi_color_style(val.as_str());
-                    if let Some(v) = map.get_mut(key) {
-                        *v = ComputableStyle::Static(color);
-                    } else {
-                        map.insert(key.to_string(), ComputableStyle::Static(color));
-                    }
-                }
-                // This should never occur.
-                _ => (),
-            }
-        }
-        StyleComputer::new(engine_state, stack, map)
-    }
-}
-
-// Because EngineState doesn't have Debug (Dec 2022),
-// this incomplete representation must be used.
-impl<'a> Debug for StyleComputer<'a> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        f.debug_struct("StyleComputer")
-            .field("map", &self.map)
-            .finish()
-    }
-}
-
-#[test]
-fn test_computable_style_static() {
-    use nu_protocol::Span;
-
-    let style1 = Style::default().italic();
-    let style2 = Style::default().underline();
-    // Create a "dummy" style_computer for this test.
-    let dummy_engine_state = EngineState::new();
-    let mut dummy_stack = Stack::new();
-    let style_computer = StyleComputer::new(
-        &dummy_engine_state,
-        &mut dummy_stack,
-        HashMap::from([
-            ("string".into(), ComputableStyle::Static(style1)),
-            ("row_index".into(), ComputableStyle::Static(style2)),
-        ]),
-    );
-    assert_eq!(
-        style_computer.compute("string", &Value::nothing(Span::unknown())),
-        style1
-    );
-    assert_eq!(
-        style_computer.compute("row_index", &Value::nothing(Span::unknown())),
-        style2
-    );
-}
-
-// Because each closure currently runs in a separate environment, checks that the closures have run
-// must use the filesystem.
-#[test]
-fn test_computable_style_closure_basic() {
-    use nu_test_support::{nu, nu_repl_code, playground::Playground};
-    Playground::setup("computable_style_closure_basic", |dirs, _| {
-        let inp = [
-            r#"let-env config = {
-                color_config: {
-                    string: {|e| touch ($e + '.obj'); 'red' }
-                }
-            };"#,
-            "[bell book candle] | table | ignore",
-            "ls | get name | to nuon",
-        ];
-        let actual_repl = nu!(cwd: dirs.test(), nu_repl_code(&inp));
-        assert_eq!(actual_repl.err, "");
-        assert_eq!(actual_repl.out, "[bell.obj, book.obj, candle.obj]");
-    });
-}
-
-#[test]
-fn test_computable_style_closure_errors() {
-    use nu_test_support::{nu, nu_repl_code};
-    let inp = [
-        r#"let-env config = {
-            color_config: {
-                string: {|e| $e + 2 }
-            }
-        };"#,
-        "[bell] | table",
-    ];
-    let actual_repl = nu!(cwd: ".", nu_repl_code(&inp));
-    // Check that the error was printed
-    assert!(actual_repl.err.contains("type mismatch for operator"));
-    // Check that the value was printed
-    assert!(actual_repl.out.contains("bell"));
-}

crates/nu-command/Cargo.toml

@@ -1,50 +1,46 @@
 [package]
 authors = ["The Nushell Project Developers"]
 description = "Nushell's built-in commands"
-repository = "https://github.com/nushell/nushell/tree/main/crates/nu-command"
 edition = "2021"
 license = "MIT"
 name = "nu-command"
-version = "0.73.0"
+version = "0.66.3"
 build = "build.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-color-config = { path = "../nu-color-config", version = "0.73.0"  }
-nu-engine = { path = "../nu-engine", version = "0.73.0"  }
-nu-glob = { path = "../nu-glob", version = "0.73.0" }
-nu-json = { path = "../nu-json", version = "0.73.0"  }
-nu-parser = { path = "../nu-parser", version = "0.73.0"  }
-nu-path = { path = "../nu-path", version = "0.73.0"  }
-nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.73.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.73.0"  }
-nu-system = { path = "../nu-system", version = "0.73.0"  }
-nu-table = { path = "../nu-table", version = "0.73.0"  }
-nu-term-grid = { path = "../nu-term-grid", version = "0.73.0"  }
-nu-utils = { path = "../nu-utils", version = "0.73.0" }
-nu-explore = { path = "../nu-explore", version = "0.73.0" }
+nu-color-config = { path = "../nu-color-config", version = "0.66.2"  }
+nu-engine = { path = "../nu-engine", version = "0.66.2"  }
+nu-glob = { path = "../nu-glob", version = "0.66.2" }
+nu-json = { path = "../nu-json", version = "0.66.2"  }
+nu-parser = { path = "../nu-parser", version = "0.66.2"  }
+nu-path = { path = "../nu-path", version = "0.66.2"  }
+nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.66.2"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.2"  }
+nu-system = { path = "../nu-system", version = "0.66.2"  }
+nu-table = { path = "../nu-table", version = "0.66.2"  }
+nu-term-grid = { path = "../nu-term-grid", version = "0.66.2"  }
+nu-test-support = { path = "../nu-test-support", version = "0.66.2"  }
+nu-utils = { path = "../nu-utils", version = "0.66.2" }
 nu-ansi-term = "0.46.0"
-num-format = { version = "0.4.3" }
 
 # Potential dependencies for extras
 alphanumeric-sort = "1.4.4"
-atty = "0.2.14"
 base64 = "0.13.0"
 byteorder = "1.4.3"
 bytesize = "1.1.0"
-calamine = "0.19.1"
-chrono = { version = "0.4.23", features = ["unstable-locales", "std"], default-features = false }
+calamine = "0.18.0"
+chrono = { version = "0.4.19", features = ["serde"] }
 chrono-humanize = "0.2.1"
-chrono-tz = "0.6.3"
-crossterm = "0.24.0"
+chrono-tz = "0.6.1"
+crossterm = "0.23.0"
 csv = "1.1.6"
-dialoguer = { default-features = false, version = "0.9.0" }
-digest = { default-features = false, version = "0.10.0" }
+dialoguer = "0.9.0"
+digest = "0.10.0"
 dtparse = "1.2.0"
 eml-parser = "0.1.0"
 encoding_rs = "0.8.30"
-fancy-regex = "0.10.0"
 filesize = "0.2.0"
 filetime = "0.2.15"
 fs_extra = "1.2.0"
@@ -54,33 +50,32 @@ indexmap = { version="1.7", features=["serde-1"] }
 Inflector = "0.11"
 is-root = "0.1.2"
 itertools = "0.10.0"
+lazy_static = "1.4.0"
 log = "0.4.14"
-lscolors = { version = "0.12.0", features = ["crossterm"], default-features = false }
+lscolors = { version = "0.10.0", features = ["crossterm"]}
 md5 = { package = "md-5", version = "0.10.0" }
 meval = "0.2.0"
 mime = "0.3.16"
 notify = "4.0.17"
 num = { version = "0.4.0", optional = true }
-num-traits = "0.2.14"
-once_cell = "1.0"
 pathdiff = "0.2.1"
 powierza-coefficient = "1.0.1"
-quick-xml = "0.25"
+quick-xml = "0.23.0"
 rand = "0.8"
 rayon = "1.5.1"
-regex = "1.6.0"
+regex = "1.5.4"
 reqwest = {version = "0.11", features = ["blocking", "json"] }
-roxmltree = "0.16.0"
+roxmltree = "0.14.0"
 rust-embed = "6.3.0"
-same-file = "1.0.6"
 serde = { version="1.0.123", features=["derive"] }
 serde_ini = "0.2.0"
 serde_urlencoded = "0.7.0"
-serde_yaml = "0.9.4"
+serde_yaml = "0.8.16"
 sha2 = "0.10.0"
 # Disable default features b/c the default features build Git (very slow to compile)
 shadow-rs = { version = "0.16.1", default-features = false }
-sysinfo = "0.26.2"
+strip-ansi-escapes = "0.1.1"
+sysinfo = "0.24.6"
 terminal_size = "0.2.1"
 thiserror = "1.0.31"
 titlecase = "2.0.0"
@@ -88,58 +83,36 @@ toml = "0.5.8"
 unicode-segmentation = "1.8.0"
 url = "2.2.1"
 uuid = { version = "1.1.2", features = ["v4"] }
-which = { version = "4.3.0", optional = true }
-reedline = { version = "0.14.0", features = ["bashisms", "sqlite"]}
-wax = { version =  "0.5.0" }
+which = { version = "4.2.2", optional = true }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
+wax = { version =  "0.5.0", features = ["diagnostics"] }
 rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }
-sqlparser = { version = "0.23.0", features = ["serde"], optional = true }
-
-[target.'cfg(windows)'.dependencies]
-winreg = "0.10.1"
+sqlparser = { version = "0.16.0", features = ["serde"], optional = true }
 
 [target.'cfg(unix)'.dependencies]
 umask = "2.0.0"
 users = "0.11.0"
-libc = "0.2"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies.trash]
-version = "3.0.0"
+version = "2.1.3"
 optional = true
 
 [dependencies.polars]
-version = "0.25.0"
+version = "0.22.8"
+# path = "../../../../polars/polars"
 optional = true
 features = [
-	"arg_where",
-	"checked_arithmetic",
-	"concat_str",
-	"cross_join",
-	"csv-file",
-	"cum_agg",
-	"default",
-	"dtype-datetime",
-	"dtype-struct",
-	"dtype-categorical",
-	"dynamic_groupby",
-	"ipc",
-	"is_in",
-	"json",
-	"lazy",
-	"object",
-	"parquet",
-	"random",
-	"rolling_window",
-	"rows",
-	"serde",
-	"serde-lazy",
-	"strings",
-	"strings",
-	"to_dummies",
+	"default", "to_dummies", "parquet", "json", "serde", "serde-lazy",
+	"object", "checked_arithmetic", "strings", "cum_agg", "is_in",
+	"rolling_window", "strings", "rows", "random",
+    "dtype-datetime", "dtype-struct", "lazy", "cross_join",
+	"dynamic_groupby", "dtype-categorical", "concat_str"
 ]
 
 [target.'cfg(windows)'.dependencies.windows]
-version = "0.43.0"
+version = "0.37.0"
 features = [
+    "alloc",
     "Win32_Foundation",
     "Win32_Storage_FileSystem",
 	"Win32_System_SystemServices",
@@ -149,18 +122,15 @@ features = [
 trash-support = ["trash"]
 which-support = ["which"]
 plugin = ["nu-parser/plugin"]
-dataframe = ["polars", "num", "sqlparser"]
-sqlite = ["rusqlite"] # TODO: given that rusqlite is included in reedline, should we just always include it?
+dataframe = ["polars", "num"]
+database = ["sqlparser", "rusqlite"]
 
 [build-dependencies]
 shadow-rs = { version = "0.16.1", default-features = false }
 
 [dev-dependencies]
-nu-test-support = { path = "../nu-test-support", version = "0.73.0"  }
-
 hamcrest2 = "0.3.0"
 dirs-next = "2.0.0"
-proptest = "1.0.0"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
-rstest = {version = "0.15.0", default-features = false}
+rstest = "0.15.0"

crates/nu-command/build.rs

@@ -3,18 +3,16 @@ use std::process::Command;
 fn main() -> shadow_rs::SdResult<()> {
     // Look up the current Git commit ourselves instead of relying on shadow_rs,
     // because shadow_rs does it in a really slow-to-compile way (it builds libgit2)
-    let hash = get_git_hash().unwrap_or_default();
+    let hash = get_git_hash().expect("failed to get latest git commit hash");
     println!("cargo:rustc-env=NU_COMMIT_HASH={}", hash);
 
     shadow_rs::new()
 }
 
-fn get_git_hash() -> Option<String> {
-    Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .output()
-        .ok()
-        .filter(|output| output.status.success())
-        .and_then(|output| String::from_utf8(output.stdout).ok())
-        .map(|hash| hash.trim().to_string())
+fn get_git_hash() -> Result<String, std::io::Error> {
+    let out = Command::new("git").args(["rev-parse", "HEAD"]).output()?;
+    Ok(String::from_utf8(out.stdout)
+        .expect("could not convert stdout to string")
+        .trim()
+        .to_string())
 }

crates/nu-command/proptest-regressions/format_conversions/nuon.txt

@@ -1,23 +0,0 @@
-# Seeds for failure cases proptest has generated in the past. It is
-# automatically read and these particular cases re-run before any
-# novel cases are generated.
-#
-# It is recommended to check this file in to source control so that
-# everyone who runs the test benefits from these saved cases.
-cc 96a80ecd19729fb43a7b7bb2766b37d6083ba73b16abb97075875e3cfcdc763f # shrinks to c = '"'
-cc 4146602559ea717a02bcef3c6d73cdf613c30d0c3f92c48e26c79b9a1544e027 # shrinks to c = '\\'
-cc 80532a0ee73df456a719b9e3cce1ae5f3d26009dde819cbaf16f8e0cb6709705 # shrinks to c = ':'
-cc cdb88505686eea3c74c36f282fd29b2b68bc118ded4ebfc36f9838d174bd7653 # shrinks to c = '`'
-cc 0f534d55f9771e8810b9c4252a4168abfaec1a35e1b0cac12dbaf726d295a08c # shrinks to c = '\0'
-cc 5d31bcbab722acd1f4e23ca3a4f95ff309a636b45a73ca8ae9f820d93ff57acc # shrinks to c = '{'
-cc 5afec063bc96160d681d77f90041b67ef5cfdea4dcbd12d984fd828fbeb4b421 # shrinks to c = '#'
-cc f919beb3ee5c70e756a15635d65ded7d44f3ae58b5e86b6c09e814d5d8cdd506 # shrinks to c = ';'
-cc ec00f39b8d45dfd8808947a56af5e50ba5a0ef7c951723b45377815a02e515b1 # shrinks to c = '('
-cc 25b773cdf4c24179151fa86244c7de4136e05df9e94e6ee77a336ebfd8764444 # shrinks to c = '|'
-cc 94dc0d54b97d59e1c0f4cb11bdccb3823a1bb908cbc3fd643ee8f067169fad72 # shrinks to c = '0'
-cc c9d0051fb1e5a8bdc1d4f5a3dceac1b4b465827d1dff4fc3a3755baae6a7bb48 # shrinks to c = '$'
-cc 14ec40d2eb5bd2663e9b11bb49fb2120852f9ea71678c69d732161412b55a3ec # shrinks to s = ""
-cc d4afccc51ed9d421bdb7e1723e273dfb6e77c3a449489671a496db234e87c5ed # shrinks to c = '\r'
-cc 515a56d73eb1b69290ef4c714b629421989879aebd57991bd2c2bf11294353b1 # shrinks to s = "\\\\𐊀{"
-cc 111566990fffa432acd2dbc845141b0e7870f97125c7621e3ddf142204568246 # shrinks to s = "'\":`"
-cc 0424c33000d9188be96b3049046eb052770b2158bf5ebb0c98656d7145e8aca9 # shrinks to s = "0"

crates/nu-command/src/bits/and.rs

@@ -1,99 +0,0 @@
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
-};
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits and"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits and")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required(
-                "target",
-                SyntaxShape::Int,
-                "target integer to perform bit and",
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Performs bitwise and for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["logic and"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let target: i64 = call.req(engine_state, stack, 0)?;
-
-        input.map(
-            move |value| operate(value, target, head),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Apply bits and to two numbers",
-                example: "2 | bits and 2",
-                result: Some(Value::int(2, Span::test_data())),
-            },
-            Example {
-                description: "Apply logical and to a list of numbers",
-                example: "[4 3 2] | bits and 2",
-                result: Some(Value::List {
-                    vals: vec![Value::test_int(0), Value::test_int(2), Value::test_int(2)],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn operate(value: Value, target: i64, head: Span) -> Value {
-    match value {
-        Value::Int { val, span } => Value::Int {
-            val: val & target,
-            span,
-        },
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/bits_.rs

@@ -1,55 +0,0 @@
-use nu_engine::get_full_help;
-use nu_protocol::{
-    ast::Call,
-    engine::{Command, EngineState, Stack},
-    Category, IntoPipelineData, PipelineData, Signature, Value,
-};
-
-#[derive(Clone)]
-pub struct Bits;
-
-impl Command for Bits {
-    fn name(&self) -> &str {
-        "bits"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits").category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Various commands for working with bits"
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(Value::String {
-            val: get_full_help(
-                &Bits.signature(),
-                &Bits.examples(),
-                engine_state,
-                stack,
-                self.is_parser_keyword(),
-            ),
-            span: call.head,
-        }
-        .into_pipeline_data())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::Bits;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(Bits {})
-    }
-}

crates/nu-command/src/bits/mod.rs

@@ -1,99 +0,0 @@
-mod and;
-mod bits_;
-mod not;
-mod or;
-mod rotate_left;
-mod rotate_right;
-mod shift_left;
-mod shift_right;
-mod xor;
-
-use nu_protocol::Spanned;
-
-pub use and::SubCommand as BitsAnd;
-pub use bits_::Bits;
-pub use not::SubCommand as BitsNot;
-pub use or::SubCommand as BitsOr;
-pub use rotate_left::SubCommand as BitsRotateLeft;
-pub use rotate_right::SubCommand as BitsRotateRight;
-pub use shift_left::SubCommand as BitsShiftLeft;
-pub use shift_right::SubCommand as BitsShiftRight;
-pub use xor::SubCommand as BitsXor;
-
-#[derive(Clone, Copy)]
-enum NumberBytes {
-    One,
-    Two,
-    Four,
-    Eight,
-    Auto,
-    Invalid,
-}
-
-#[derive(Clone, Copy)]
-enum InputNumType {
-    One,
-    Two,
-    Four,
-    Eight,
-    SignedOne,
-    SignedTwo,
-    SignedFour,
-    SignedEight,
-}
-
-fn get_number_bytes(number_bytes: &Option<Spanned<String>>) -> NumberBytes {
-    match number_bytes.as_ref() {
-        None => NumberBytes::Eight,
-        Some(size) => match size.item.as_str() {
-            "1" => NumberBytes::One,
-            "2" => NumberBytes::Two,
-            "4" => NumberBytes::Four,
-            "8" => NumberBytes::Eight,
-            "auto" => NumberBytes::Auto,
-            _ => NumberBytes::Invalid,
-        },
-    }
-}
-
-fn get_input_num_type(val: i64, signed: bool, number_size: NumberBytes) -> InputNumType {
-    if signed || val < 0 {
-        match number_size {
-            NumberBytes::One => InputNumType::SignedOne,
-            NumberBytes::Two => InputNumType::SignedTwo,
-            NumberBytes::Four => InputNumType::SignedFour,
-            NumberBytes::Eight => InputNumType::SignedEight,
-            NumberBytes::Auto => {
-                if val <= 0x7F && val >= -(2i64.pow(7)) {
-                    InputNumType::SignedOne
-                } else if val <= 0x7FFF && val >= -(2i64.pow(15)) {
-                    InputNumType::SignedTwo
-                } else if val <= 0x7FFFFFFF && val >= -(2i64.pow(31)) {
-                    InputNumType::SignedFour
-                } else {
-                    InputNumType::SignedEight
-                }
-            }
-            NumberBytes::Invalid => InputNumType::SignedFour,
-        }
-    } else {
-        match number_size {
-            NumberBytes::One => InputNumType::One,
-            NumberBytes::Two => InputNumType::Two,
-            NumberBytes::Four => InputNumType::Four,
-            NumberBytes::Eight => InputNumType::Eight,
-            NumberBytes::Auto => {
-                if val <= 0xFF {
-                    InputNumType::One
-                } else if val <= 0xFFFF {
-                    InputNumType::Two
-                } else if val <= 0xFFFFFFFF {
-                    InputNumType::Four
-                } else {
-                    InputNumType::Eight
-                }
-            }
-            NumberBytes::Invalid => InputNumType::Four,
-        }
-    }
-}

crates/nu-command/src/bits/not.rs

@@ -1,165 +0,0 @@
-use super::{get_number_bytes, NumberBytes};
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
-};
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits not"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits not")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .switch(
-                "signed",
-                "always treat input number as a signed number",
-                Some('s'),
-            )
-            .named(
-                "number-bytes",
-                SyntaxShape::String,
-                "the size of unsigned number in bytes, it can be 1, 2, 4, 8, auto",
-                Some('n'),
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Performs logical negation on each bit"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["negation"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let signed = call.has_flag("signed");
-        let number_bytes: Option<Spanned<String>> =
-            call.get_flag(engine_state, stack, "number-bytes")?;
-        let bytes_len = get_number_bytes(&number_bytes);
-        if let NumberBytes::Invalid = bytes_len {
-            if let Some(val) = number_bytes {
-                return Err(ShellError::UnsupportedInput(
-                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
-                    val.span,
-                ));
-            }
-        }
-
-        input.map(
-            move |value| operate(value, head, signed, bytes_len),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Apply logical negation to a list of numbers",
-                example: "[4 3 2] | bits not",
-                result: Some(Value::List {
-                    vals: vec![
-                        Value::test_int(140737488355323),
-                        Value::test_int(140737488355324),
-                        Value::test_int(140737488355325),
-                    ],
-                    span: Span::test_data(),
-                }),
-            },
-            Example {
-                description:
-                    "Apply logical negation to a list of numbers, treat input as 2 bytes number",
-                example: "[4 3 2] | bits not -n 2",
-                result: Some(Value::List {
-                    vals: vec![
-                        Value::test_int(65531),
-                        Value::test_int(65532),
-                        Value::test_int(65533),
-                    ],
-                    span: Span::test_data(),
-                }),
-            },
-            Example {
-                description:
-                    "Apply logical negation to a list of numbers, treat input as signed number",
-                example: "[4 3 2] | bits not -s",
-                result: Some(Value::List {
-                    vals: vec![
-                        Value::test_int(-5),
-                        Value::test_int(-4),
-                        Value::test_int(-3),
-                    ],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn operate(value: Value, head: Span, signed: bool, number_size: NumberBytes) -> Value {
-    match value {
-        Value::Int { val, span } => {
-            if signed || val < 0 {
-                Value::Int { val: !val, span }
-            } else {
-                use NumberBytes::*;
-                let out_val = match number_size {
-                    One => !val & 0x00_00_00_00_00_FF,
-                    Two => !val & 0x00_00_00_00_FF_FF,
-                    Four => !val & 0x00_00_FF_FF_FF_FF,
-                    Eight => !val & 0x7F_FF_FF_FF_FF_FF,
-                    Auto => {
-                        if val <= 0xFF {
-                            !val & 0x00_00_00_00_00_FF
-                        } else if val <= 0xFF_FF {
-                            !val & 0x00_00_00_00_FF_FF
-                        } else if val <= 0xFF_FF_FF_FF {
-                            !val & 0x00_00_FF_FF_FF_FF
-                        } else {
-                            !val & 0x7F_FF_FF_FF_FF_FF
-                        }
-                    }
-                    // This case shouldn't happen here, as it's handled before
-                    Invalid => 0,
-                };
-                Value::Int { val: out_val, span }
-            }
-        }
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only numerical values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/or.rs

@@ -1,99 +0,0 @@
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
-};
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits or"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits or")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required(
-                "target",
-                SyntaxShape::Int,
-                "target integer to perform bit or",
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Performs bitwise or for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["logic or"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let target: i64 = call.req(engine_state, stack, 0)?;
-
-        input.map(
-            move |value| operate(value, target, head),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Apply bits or to two numbers",
-                example: "2 | bits or 6",
-                result: Some(Value::int(6, Span::test_data())),
-            },
-            Example {
-                description: "Apply logical or to a list of numbers",
-                example: "[8 3 2] | bits or 2",
-                result: Some(Value::List {
-                    vals: vec![Value::test_int(10), Value::test_int(3), Value::test_int(2)],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn operate(value: Value, target: i64, head: Span) -> Value {
-    match value {
-        Value::Int { val, span } => Value::Int {
-            val: val | target,
-            span,
-        },
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/rotate_left.rs

@@ -1,155 +0,0 @@
-use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
-};
-use num_traits::int::PrimInt;
-use std::fmt::Display;
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits rol"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits rol")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required("bits", SyntaxShape::Int, "number of bits to rotate left")
-            .switch(
-                "signed",
-                "always treat input number as a signed number",
-                Some('s'),
-            )
-            .named(
-                "number-bytes",
-                SyntaxShape::String,
-                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
-                Some('n'),
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Bitwise rotate left for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["rotate left"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let bits: usize = call.req(engine_state, stack, 0)?;
-        let signed = call.has_flag("signed");
-        let number_bytes: Option<Spanned<String>> =
-            call.get_flag(engine_state, stack, "number-bytes")?;
-        let bytes_len = get_number_bytes(&number_bytes);
-        if let NumberBytes::Invalid = bytes_len {
-            if let Some(val) = number_bytes {
-                return Err(ShellError::UnsupportedInput(
-                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
-                    val.span,
-                ));
-            }
-        }
-
-        input.map(
-            move |value| operate(value, bits, head, signed, bytes_len),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Rotate left a number with 2 bits",
-                example: "17 | bits rol 2",
-                result: Some(Value::int(68, Span::test_data())),
-            },
-            Example {
-                description: "Rotate left a list of numbers with 2 bits",
-                example: "[5 3 2] | bits rol 2",
-                result: Some(Value::List {
-                    vals: vec![Value::test_int(20), Value::test_int(12), Value::test_int(8)],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn get_rotate_left<T: Display + PrimInt>(val: T, bits: u32, span: Span) -> Value
-where
-    i64: std::convert::TryFrom<T>,
-{
-    let rotate_result = i64::try_from(val.rotate_left(bits));
-    match rotate_result {
-        Ok(val) => Value::Int { val, span },
-        Err(_) => Value::Error {
-            error: ShellError::GenericError(
-                "Rotate left result beyond the range of 64 bit signed number".to_string(),
-                format!(
-                    "{} of the specified number of bytes rotate left {} bits exceed limit",
-                    val, bits
-                ),
-                Some(span),
-                None,
-                Vec::new(),
-            ),
-        },
-    }
-}
-
-fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
-    match value {
-        Value::Int { val, span } => {
-            use InputNumType::*;
-            // let bits = (((bits % 64) + 64) % 64) as u32;
-            let bits = bits as u32;
-            let input_type = get_input_num_type(val, signed, number_size);
-            match input_type {
-                One => get_rotate_left(val as u8, bits, span),
-                Two => get_rotate_left(val as u16, bits, span),
-                Four => get_rotate_left(val as u32, bits, span),
-                Eight => get_rotate_left(val as u64, bits, span),
-                SignedOne => get_rotate_left(val as i8, bits, span),
-                SignedTwo => get_rotate_left(val as i16, bits, span),
-                SignedFour => get_rotate_left(val as i32, bits, span),
-                SignedEight => get_rotate_left(val as i64, bits, span),
-            }
-        }
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/rotate_right.rs

@@ -1,159 +0,0 @@
-use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
-};
-use num_traits::int::PrimInt;
-use std::fmt::Display;
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits ror"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits ror")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required("bits", SyntaxShape::Int, "number of bits to rotate right")
-            .switch(
-                "signed",
-                "always treat input number as a signed number",
-                Some('s'),
-            )
-            .named(
-                "number-bytes",
-                SyntaxShape::String,
-                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
-                Some('n'),
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Bitwise rotate right for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["rotate right"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let bits: usize = call.req(engine_state, stack, 0)?;
-        let signed = call.has_flag("signed");
-        let number_bytes: Option<Spanned<String>> =
-            call.get_flag(engine_state, stack, "number-bytes")?;
-        let bytes_len = get_number_bytes(&number_bytes);
-        if let NumberBytes::Invalid = bytes_len {
-            if let Some(val) = number_bytes {
-                return Err(ShellError::UnsupportedInput(
-                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
-                    val.span,
-                ));
-            }
-        }
-
-        input.map(
-            move |value| operate(value, bits, head, signed, bytes_len),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Rotate right a number with 60 bits",
-                example: "17 | bits ror 60",
-                result: Some(Value::int(272, Span::test_data())),
-            },
-            Example {
-                description: "Rotate right a list of numbers of one byte",
-                example: "[15 33 92] | bits ror 2 -n 1",
-                result: Some(Value::List {
-                    vals: vec![
-                        Value::test_int(195),
-                        Value::test_int(72),
-                        Value::test_int(23),
-                    ],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn get_rotate_right<T: Display + PrimInt>(val: T, bits: u32, span: Span) -> Value
-where
-    i64: std::convert::TryFrom<T>,
-{
-    let rotate_result = i64::try_from(val.rotate_right(bits));
-    match rotate_result {
-        Ok(val) => Value::Int { val, span },
-        Err(_) => Value::Error {
-            error: ShellError::GenericError(
-                "Rotate right result beyond the range of 64 bit signed number".to_string(),
-                format!(
-                    "{} of the specified number of bytes rotate right {} bits exceed limit",
-                    val, bits
-                ),
-                Some(span),
-                None,
-                Vec::new(),
-            ),
-        },
-    }
-}
-
-fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
-    match value {
-        Value::Int { val, span } => {
-            use InputNumType::*;
-            // let bits = (((bits % 64) + 64) % 64) as u32;
-            let bits = bits as u32;
-            let input_type = get_input_num_type(val, signed, number_size);
-            match input_type {
-                One => get_rotate_right(val as u8, bits, span),
-                Two => get_rotate_right(val as u16, bits, span),
-                Four => get_rotate_right(val as u32, bits, span),
-                Eight => get_rotate_right(val as u64, bits, span),
-                SignedOne => get_rotate_right(val as i8, bits, span),
-                SignedTwo => get_rotate_right(val as i16, bits, span),
-                SignedFour => get_rotate_right(val as i32, bits, span),
-                SignedEight => get_rotate_right(val as i64, bits, span),
-            }
-        }
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/shift_left.rs

@@ -1,181 +0,0 @@
-use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
-};
-use num_traits::CheckedShl;
-use std::fmt::Display;
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits shl"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits shl")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required("bits", SyntaxShape::Int, "number of bits to shift left")
-            .switch(
-                "signed",
-                "always treat input number as a signed number",
-                Some('s'),
-            )
-            .named(
-                "number-bytes",
-                SyntaxShape::String,
-                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
-                Some('n'),
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Bitwise shift left for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["shift left"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let bits: usize = call.req(engine_state, stack, 0)?;
-        let signed = call.has_flag("signed");
-        let number_bytes: Option<Spanned<String>> =
-            call.get_flag(engine_state, stack, "number-bytes")?;
-        let bytes_len = get_number_bytes(&number_bytes);
-        if let NumberBytes::Invalid = bytes_len {
-            if let Some(val) = number_bytes {
-                return Err(ShellError::UnsupportedInput(
-                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
-                    val.span,
-                ));
-            }
-        }
-
-        input.map(
-            move |value| operate(value, bits, head, signed, bytes_len),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Shift left a number by 7 bits",
-                example: "2 | bits shl 7",
-                result: Some(Value::int(256, Span::test_data())),
-            },
-            Example {
-                description: "Shift left a number with 1 byte by 7 bits",
-                example: "2 | bits shl 7 -n 1",
-                result: Some(Value::int(0, Span::test_data())),
-            },
-            Example {
-                description: "Shift left a signed number by 1 bit",
-                example: "0x7F | bits shl 1 -s",
-                result: Some(Value::int(254, Span::test_data())),
-            },
-            Example {
-                description: "Shift left a list of numbers",
-                example: "[5 3 2] | bits shl 2",
-                result: Some(Value::List {
-                    vals: vec![Value::test_int(20), Value::test_int(12), Value::test_int(8)],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn get_shift_left<T: CheckedShl + Display + Copy>(val: T, bits: u32, span: Span) -> Value
-where
-    i64: std::convert::TryFrom<T>,
-{
-    match val.checked_shl(bits) {
-        Some(val) => {
-            let shift_result = i64::try_from(val);
-            match shift_result {
-                Ok(val) => Value::Int { val, span },
-                Err(_) => Value::Error {
-                    error: ShellError::GenericError(
-                        "Shift left result beyond the range of 64 bit signed number".to_string(),
-                        format!(
-                            "{} of the specified number of bytes shift left {} bits exceed limit",
-                            val, bits
-                        ),
-                        Some(span),
-                        None,
-                        Vec::new(),
-                    ),
-                },
-            }
-        }
-        None => Value::Error {
-            error: ShellError::GenericError(
-                "Shift left failed".to_string(),
-                format!(
-                    "{} shift left {} bits failed, you may shift too many bits",
-                    val, bits
-                ),
-                Some(span),
-                None,
-                Vec::new(),
-            ),
-        },
-    }
-}
-
-fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
-    match value {
-        Value::Int { val, span } => {
-            use InputNumType::*;
-            // let bits = (((bits % 64) + 64) % 64) as u32;
-            let bits = bits as u32;
-            let input_type = get_input_num_type(val, signed, number_size);
-            match input_type {
-                One => get_shift_left(val as u8, bits, span),
-                Two => get_shift_left(val as u16, bits, span),
-                Four => get_shift_left(val as u32, bits, span),
-                Eight => get_shift_left(val as u64, bits, span),
-                SignedOne => get_shift_left(val as i8, bits, span),
-                SignedTwo => get_shift_left(val as i16, bits, span),
-                SignedFour => get_shift_left(val as i32, bits, span),
-                SignedEight => get_shift_left(val as i64, bits, span),
-            }
-        }
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/shift_right.rs

@@ -1,171 +0,0 @@
-use super::{get_input_num_type, get_number_bytes, InputNumType, NumberBytes};
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
-};
-use num_traits::CheckedShr;
-use std::fmt::Display;
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits shr"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits shr")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required("bits", SyntaxShape::Int, "number of bits to shift right")
-            .switch(
-                "signed",
-                "always treat input number as a signed number",
-                Some('s'),
-            )
-            .named(
-                "number-bytes",
-                SyntaxShape::String,
-                "the word size in number of bytes, it can be 1, 2, 4, 8, auto, default value `8`",
-                Some('n'),
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Bitwise shift right for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["shift right"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let bits: usize = call.req(engine_state, stack, 0)?;
-        let signed = call.has_flag("signed");
-        let number_bytes: Option<Spanned<String>> =
-            call.get_flag(engine_state, stack, "number-bytes")?;
-        let bytes_len = get_number_bytes(&number_bytes);
-        if let NumberBytes::Invalid = bytes_len {
-            if let Some(val) = number_bytes {
-                return Err(ShellError::UnsupportedInput(
-                    "Only 1, 2, 4, 8, or 'auto' bytes are supported as word sizes".to_string(),
-                    val.span,
-                ));
-            }
-        }
-
-        input.map(
-            move |value| operate(value, bits, head, signed, bytes_len),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Shift right a number with 2 bits",
-                example: "8 | bits shr 2",
-                result: Some(Value::int(2, Span::test_data())),
-            },
-            Example {
-                description: "Shift right a list of numbers",
-                example: "[15 35 2] | bits shr 2",
-                result: Some(Value::List {
-                    vals: vec![Value::test_int(3), Value::test_int(8), Value::test_int(0)],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn get_shift_right<T: CheckedShr + Display + Copy>(val: T, bits: u32, span: Span) -> Value
-where
-    i64: std::convert::TryFrom<T>,
-{
-    match val.checked_shr(bits) {
-        Some(val) => {
-            let shift_result = i64::try_from(val);
-            match shift_result {
-                Ok(val) => Value::Int { val, span },
-                Err(_) => Value::Error {
-                    error: ShellError::GenericError(
-                        "Shift right result beyond the range of 64 bit signed number".to_string(),
-                        format!(
-                            "{} of the specified number of bytes shift right {} bits exceed limit",
-                            val, bits
-                        ),
-                        Some(span),
-                        None,
-                        Vec::new(),
-                    ),
-                },
-            }
-        }
-        None => Value::Error {
-            error: ShellError::GenericError(
-                "Shift right failed".to_string(),
-                format!(
-                    "{} shift right {} bits failed, you may shift too many bits",
-                    val, bits
-                ),
-                Some(span),
-                None,
-                Vec::new(),
-            ),
-        },
-    }
-}
-
-fn operate(value: Value, bits: usize, head: Span, signed: bool, number_size: NumberBytes) -> Value {
-    match value {
-        Value::Int { val, span } => {
-            use InputNumType::*;
-            // let bits = (((bits % 64) + 64) % 64) as u32;
-            let bits = bits as u32;
-            let input_type = get_input_num_type(val, signed, number_size);
-            match input_type {
-                One => get_shift_right(val as u8, bits, span),
-                Two => get_shift_right(val as u16, bits, span),
-                Four => get_shift_right(val as u32, bits, span),
-                Eight => get_shift_right(val as u64, bits, span),
-                SignedOne => get_shift_right(val as i8, bits, span),
-                SignedTwo => get_shift_right(val as i16, bits, span),
-                SignedFour => get_shift_right(val as i32, bits, span),
-                SignedEight => get_shift_right(val as i64, bits, span),
-            }
-        }
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bits/xor.rs

@@ -1,99 +0,0 @@
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
-};
-
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "bits xor"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("bits xor")
-            .input_output_types(vec![(Type::Int, Type::Int)])
-            .vectorizes_over_list(true)
-            .required(
-                "target",
-                SyntaxShape::Int,
-                "target integer to perform bit xor",
-            )
-            .category(Category::Bits)
-    }
-
-    fn usage(&self) -> &str {
-        "Performs bitwise xor for integers"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["logic xor"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        let target: i64 = call.req(engine_state, stack, 0)?;
-
-        input.map(
-            move |value| operate(value, target, head),
-            engine_state.ctrlc.clone(),
-        )
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Apply bits xor to two numbers",
-                example: "2 | bits xor 2",
-                result: Some(Value::int(0, Span::test_data())),
-            },
-            Example {
-                description: "Apply logical xor to a list of numbers",
-                example: "[8 3 2] | bits xor 2",
-                result: Some(Value::List {
-                    vals: vec![Value::test_int(10), Value::test_int(1), Value::test_int(0)],
-                    span: Span::test_data(),
-                }),
-            },
-        ]
-    }
-}
-
-fn operate(value: Value, target: i64, head: Span) -> Value {
-    match value {
-        Value::Int { val, span } => Value::Int {
-            val: val ^ target,
-            span,
-        },
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Only integer values are supported, input type: {:?}",
-                    other.get_type()
-                ),
-                other.span().unwrap_or(head),
-            ),
-        },
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

crates/nu-command/src/bytes/add.rs

@@ -1,21 +1,21 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::Category;
-use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
 
 struct Arguments {
     added_data: Vec<u8>,
     index: Option<usize>,
     end: bool,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -30,8 +30,6 @@ impl Command for BytesAdd {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes add")
-            .input_output_types(vec![(Type::Binary, Type::Binary)])
-            .vectorizes_over_list(true)
             .required("data", SyntaxShape::Binary, "the binary to add")
             .named(
                 "index",
@@ -43,13 +41,13 @@ impl Command for BytesAdd {
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, add bytes to the data at the given cell paths",
+                "optionally matches prefix of text by column paths",
             )
             .category(Category::Bytes)
     }
 
     fn usage(&self) -> &str {
-        "Add specified bytes to the input"
+        "add specified bytes to the input"
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -64,8 +62,12 @@ impl Command for BytesAdd {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let added_data: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let index: Option<usize> = call.get_flag(engine_state, stack, "index")?;
         let end = call.has_flag("end");
 
@@ -73,7 +75,7 @@ impl Command for BytesAdd {
             added_data,
             index,
             end,
-            cell_paths,
+            column_paths,
         };
         operate(add, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -116,25 +118,7 @@ impl Command for BytesAdd {
     }
 }
 
-fn add(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => add_impl(val, args, *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
-    }
-}
-
-fn add_impl(input: &[u8], args: &Arguments, span: Span) -> Value {
+fn add(input: &[u8], args: &Arguments, span: Span) -> Value {
     match args.index {
         None => {
             if args.end {

crates/nu-command/src/bytes/at.rs

@@ -1,10 +1,10 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 use std::cmp::Ordering;
 
@@ -15,12 +15,12 @@ struct Arguments {
     start: isize,
     end: isize,
     arg_span: Span,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -115,13 +115,11 @@ impl Command for BytesAt {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes at")
-            .input_output_types(vec![(Type::Binary, Type::Binary)])
-            .vectorizes_over_list(true)
             .required("range", SyntaxShape::Any, "the indexes to get bytes")
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, get bytes from data at the given cell paths",
+                "optionally get bytes by column paths",
             )
             .category(Category::Bytes)
     }
@@ -143,13 +141,17 @@ impl Command for BytesAt {
     ) -> Result<PipelineData, ShellError> {
         let range: Value = call.req(engine_state, stack, 0)?;
         let (start, end, arg_span) = parse_range(range, call.head)?;
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let arg = Arguments {
             start,
             end,
             arg_span,
-            cell_paths,
+            column_paths,
         };
         operate(at, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -226,25 +228,7 @@ impl Command for BytesAt {
     }
 }
 
-fn at(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => at_impl(val, args, *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
-    }
-}
-
-fn at_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn at(input: &[u8], arg: &Arguments, span: Span) -> Value {
     let len: isize = input.len() as isize;
 
     let start: isize = if arg.start < 0 {

crates/nu-command/src/bytes/build_.rs

@@ -3,7 +3,7 @@ use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Type, Value,
+    Value,
 };
 
 #[derive(Clone)]
@@ -24,7 +24,6 @@ impl Command for BytesBuild {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("bytes build")
-            .input_output_types(vec![(Type::Nothing, Type::Binary)])
             .rest("rest", SyntaxShape::Any, "list of bytes")
             .category(Category::Bytes)
     }

crates/nu-command/src/bytes/bytes_.rs

@@ -29,13 +29,7 @@ impl Command for Bytes {
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         Ok(Value::String {
-            val: get_full_help(
-                &Bytes.signature(),
-                &Bytes.examples(),
-                engine_state,
-                stack,
-                self.is_parser_keyword(),
-            ),
+            val: get_full_help(&Bytes.signature(), &Bytes.examples(), engine_state, stack),
             span: call.head,
         }
         .into_pipeline_data())

crates/nu-command/src/bytes/collect.rs

@@ -3,7 +3,7 @@ use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Type, Value,
+    Value,
 };
 
 #[derive(Clone, Copy)]
@@ -16,7 +16,6 @@ impl Command for BytesCollect {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes collect")
-            .input_output_types(vec![(Type::List(Box::new(Type::Binary)), Type::Binary)])
             .optional(
                 "separator",
                 SyntaxShape::Binary,

crates/nu-command/src/bytes/ends_with.rs

@@ -1,19 +1,19 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::Category;
-use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
 
 struct Arguments {
     pattern: Vec<u8>,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -28,12 +28,11 @@ impl Command for BytesEndsWith {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes ends-with")
-            .input_output_types(vec![(Type::Binary, Type::Bool)])
             .required("pattern", SyntaxShape::Binary, "the pattern to match")
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, check if bytes at the given cell paths end with the pattern",
+                "optionally matches prefix of text by column paths",
             )
             .category(Category::Bytes)
     }
@@ -54,11 +53,15 @@ impl Command for BytesEndsWith {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let arg = Arguments {
             pattern,
-            cell_paths,
+            column_paths,
         };
         operate(ends_with, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -68,37 +71,35 @@ impl Command for BytesEndsWith {
             Example {
                 description: "Checks if binary ends with `0x[AA]`",
                 example: "0x[1F FF AA AA] | bytes ends-with 0x[AA]",
-                result: Some(Value::boolean(true, Span::test_data())),
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Checks if binary ends with `0x[FF AA AA]`",
                 example: "0x[1F FF AA AA] | bytes ends-with 0x[FF AA AA]",
-                result: Some(Value::boolean(true, Span::test_data())),
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Checks if binary ends with `0x[11]`",
                 example: "0x[1F FF AA AA] | bytes ends-with 0x[11]",
-                result: Some(Value::boolean(false, Span::test_data())),
+                result: Some(Value::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
             },
         ]
     }
 }
 
-fn ends_with(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => Value::boolean(val.ends_with(&args.pattern), *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
+fn ends_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
+    Value::Bool {
+        val: input.ends_with(pattern),
+        span,
     }
 }
 

crates/nu-command/src/bytes/index_of.rs

@@ -1,21 +1,21 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::{Call, CellPath};
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 
 struct Arguments {
     pattern: Vec<u8>,
     end: bool,
     all: bool,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -29,10 +29,6 @@ impl Command for BytesIndexOf {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes index-of")
-            .input_output_types(vec![
-                (Type::Binary, Type::Int),
-                (Type::Binary, Type::List(Box::new(Type::Int))),
-            ])
             .required(
                 "pattern",
                 SyntaxShape::Binary,
@@ -41,7 +37,7 @@ impl Command for BytesIndexOf {
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, find the indexes at the given cell paths",
+                "optionally returns index of pattern in string by column paths",
             )
             .switch("all", "returns all matched index", Some('a'))
             .switch("end", "search from the end of the binary", Some('e'))
@@ -53,7 +49,7 @@ impl Command for BytesIndexOf {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["pattern", "match", "find", "search"]
+        vec!["pattern", "match", "find", "search", "index"]
     }
 
     fn run(
@@ -64,13 +60,17 @@ impl Command for BytesIndexOf {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let arg = Arguments {
             pattern,
             end: call.has_flag("end"),
             all: call.has_flag("all"),
-            cell_paths,
+            column_paths,
         };
         operate(index_of, arg, input, call.head, engine_state.ctrlc.clone())
     }
@@ -126,25 +126,7 @@ impl Command for BytesIndexOf {
     }
 }
 
-fn index_of(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => index_of_impl(val, args, *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
-    }
-}
-
-fn index_of_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn index_of(input: &[u8], arg: &Arguments, span: Span) -> Value {
     if arg.all {
         search_all_index(input, &arg.pattern, arg.end, span)
     } else {

crates/nu-command/src/bytes/length.rs

@@ -1,14 +1,24 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::Category;
-use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
 
 #[derive(Clone)]
 pub struct BytesLen;
 
+struct Arguments {
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
 impl Command for BytesLen {
     fn name(&self) -> &str {
         "bytes length"
@@ -16,12 +26,10 @@ impl Command for BytesLen {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes length")
-            .input_output_types(vec![(Type::Binary, Type::Int)])
-            .vectorizes_over_list(true)
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, find the length of data at the given cell paths",
+                "optionally find length of binary by column paths",
             )
             .category(Category::Bytes)
     }
@@ -31,7 +39,7 @@ impl Command for BytesLen {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["size", "count"]
+        vec!["len", "size", "count"]
     }
 
     fn run(
@@ -41,8 +49,13 @@ impl Command for BytesLen {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let arg = CellPathOnlyArgs::from(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let arg = Arguments { column_paths };
         operate(length, arg, input, call.head, engine_state.ctrlc.clone())
     }
 
@@ -65,21 +78,10 @@ impl Command for BytesLen {
     }
 }
 
-fn length(val: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => Value::int(val.len() as i64, *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
+fn length(input: &[u8], _arg: &Arguments, span: Span) -> Value {
+    Value::Int {
+        val: input.len() as i64,
+        span,
     }
 }
 

crates/nu-command/src/bytes/mod.rs

@@ -11,6 +11,11 @@ mod replace;
 mod reverse;
 mod starts_with;
 
+use nu_protocol::ast::CellPath;
+use nu_protocol::{PipelineData, ShellError, Span, Value};
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
 pub use add::BytesAdd;
 pub use at::BytesAt;
 pub use build_::BytesBuild;
@@ -23,3 +28,71 @@ pub use remove::BytesRemove;
 pub use replace::BytesReplace;
 pub use reverse::BytesReverse;
 pub use starts_with::BytesStartsWith;
+
+trait BytesArgument {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>>;
+}
+
+/// map input pipeline data, for each elements, if it's Binary, invoke relative `cmd` with `arg`.
+fn operate<C, A>(
+    cmd: C,
+    mut arg: A,
+    input: PipelineData,
+    span: Span,
+    ctrlc: Option<Arc<AtomicBool>>,
+) -> Result<PipelineData, ShellError>
+where
+    A: BytesArgument + Send + Sync + 'static,
+    C: Fn(&[u8], &A, Span) -> Value + Send + Sync + 'static + Clone + Copy,
+{
+    match arg.take_column_paths() {
+        None => input.map(
+            move |v| match v {
+                Value::Binary {
+                    val,
+                    span: val_span,
+                } => cmd(&val, &arg, val_span),
+                other => Value::Error {
+                    error: ShellError::UnsupportedInput(
+                        format!(
+                            "Input's type is {}. This command only works with bytes.",
+                            other.get_type()
+                        ),
+                        span,
+                    ),
+                },
+            },
+            ctrlc,
+        ),
+        Some(column_paths) => {
+            let arg = Arc::new(arg);
+            input.map(
+                move |mut v| {
+                    for path in &column_paths {
+                        let opt = arg.clone();
+                        let r = v.update_cell_path(
+                            &path.members,
+                            Box::new(move |old| {
+                                match old {
+                                    Value::Binary {val, span: val_span} => cmd(val, &opt, *val_span),
+                                    other => Value::Error {
+                                    error: ShellError::UnsupportedInput(
+                                        format!(
+                                            "Input's type is {}. This command only works with bytes.",
+                                            other.get_type()
+                                        ),
+                                        span,
+                                 ),
+                            }}}),
+                        );
+                        if let Err(error) = r {
+                            return Value::Error { error };
+                        }
+                    }
+                    v
+                },
+                ctrlc,
+            )
+        }
+    }
+}

crates/nu-command/src/bytes/remove.rs

@@ -1,22 +1,21 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
-    Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
 
 struct Arguments {
     pattern: Vec<u8>,
     end: bool,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
     all: bool,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -30,12 +29,11 @@ impl Command for BytesRemove {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes remove")
-            .input_output_types(vec![(Type::Binary, Type::Binary)])
             .required("pattern", SyntaxShape::Binary, "the pattern to find")
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, remove bytes from data at the given cell paths",
+                "optionally remove bytes by column paths",
             )
             .switch("end", "remove from end of binary", Some('e'))
             .switch("all", "remove occurrences of finding binary", Some('a'))
@@ -43,7 +41,7 @@ impl Command for BytesRemove {
     }
 
     fn usage(&self) -> &str {
-        "Remove bytes"
+        "remove bytes"
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -57,8 +55,12 @@ impl Command for BytesRemove {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let pattern_to_remove = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
         if pattern_to_remove.item.is_empty() {
             return Err(ShellError::UnsupportedInput(
@@ -71,7 +73,7 @@ impl Command for BytesRemove {
         let arg = Arguments {
             pattern: pattern_to_remove,
             end: call.has_flag("end"),
-            cell_paths,
+            column_paths,
             all: call.has_flag("all"),
         };
 
@@ -133,25 +135,7 @@ impl Command for BytesRemove {
     }
 }
 
-fn remove(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => remove_impl(val, args, *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
-    }
-}
-
-fn remove_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn remove(input: &[u8], arg: &Arguments, span: Span) -> Value {
     let mut result = vec![];
     let remove_all = arg.all;
     let input_len = input.len();

crates/nu-command/src/bytes/replace.rs

@@ -1,22 +1,21 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
-    Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
 
 struct Arguments {
     find: Vec<u8>,
     replace: Vec<u8>,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
     all: bool,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -30,13 +29,12 @@ impl Command for BytesReplace {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes replace")
-            .input_output_types(vec![(Type::Binary, Type::Binary)])
             .required("find", SyntaxShape::Binary, "the pattern to find")
             .required("replace", SyntaxShape::Binary, "the replacement pattern")
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, replace bytes in data at the given cell paths",
+                "optionally find and replace text by column paths",
             )
             .switch("all", "replace all occurrences of find binary", Some('a'))
             .category(Category::Bytes)
@@ -57,8 +55,12 @@ impl Command for BytesReplace {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 2)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 2)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let find = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
         if find.item.is_empty() {
             return Err(ShellError::UnsupportedInput(
@@ -70,7 +72,7 @@ impl Command for BytesReplace {
         let arg = Arguments {
             find: find.item,
             replace: call.req::<Vec<u8>>(engine_state, stack, 1)?,
-            cell_paths,
+            column_paths,
             all: call.has_flag("all"),
         };
 
@@ -124,25 +126,7 @@ impl Command for BytesReplace {
     }
 }
 
-fn replace(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => replace_impl(val, args, *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
-    }
-}
-
-fn replace_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
+fn replace(input: &[u8], arg: &Arguments, span: Span) -> Value {
     let mut replaced = vec![];
     let replace_all = arg.all;
 

crates/nu-command/src/bytes/reverse.rs

@@ -1,10 +1,20 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::Category;
-use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
+
+struct Arguments {
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
 
 #[derive(Clone)]
 
@@ -17,17 +27,16 @@ impl Command for BytesReverse {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes reverse")
-            .input_output_types(vec![(Type::Binary, Type::Binary)])
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, reverse data at the given cell paths",
+                "optionally matches prefix of text by column paths",
             )
             .category(Category::Bytes)
     }
 
     fn usage(&self) -> &str {
-        "Reverse the bytes in the pipeline"
+        "Reverse every bytes in the pipeline"
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -41,8 +50,13 @@ impl Command for BytesReverse {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-        let arg = CellPathOnlyArgs::from(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let arg = Arguments { column_paths };
         operate(reverse, arg, input, call.head, engine_state.ctrlc.clone())
     }
 
@@ -68,28 +82,12 @@ impl Command for BytesReverse {
     }
 }
 
-fn reverse(val: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => {
-            let mut reversed_input = val.to_vec();
-            reversed_input.reverse();
-            Value::Binary {
-                val: reversed_input,
-                span: *val_span,
-            }
-        }
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
+fn reverse(input: &[u8], _args: &Arguments, span: Span) -> Value {
+    let mut reversed_input = input.to_vec();
+    reversed_input.reverse();
+    Value::Binary {
+        val: reversed_input,
+        span,
     }
 }
 

crates/nu-command/src/bytes/starts_with.rs

@@ -1,19 +1,19 @@
-use crate::input_handler::{operate, CmdArgument};
+use super::{operate, BytesArgument};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::Category;
-use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
 
 struct Arguments {
     pattern: Vec<u8>,
-    cell_paths: Option<Vec<CellPath>>,
+    column_paths: Option<Vec<CellPath>>,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
     }
 }
 
@@ -28,12 +28,11 @@ impl Command for BytesStartsWith {
 
     fn signature(&self) -> Signature {
         Signature::build("bytes starts-with")
-            .input_output_types(vec![(Type::Binary, Type::Bool)])
             .required("pattern", SyntaxShape::Binary, "the pattern to match")
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, check if bytes at the given cell paths start with the pattern",
+                "optionally matches prefix of text by column paths",
             )
             .category(Category::Bytes)
     }
@@ -54,11 +53,15 @@ impl Command for BytesStartsWith {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
         let arg = Arguments {
             pattern,
-            cell_paths,
+            column_paths,
         };
         operate(
             starts_with,
@@ -74,37 +77,35 @@ impl Command for BytesStartsWith {
             Example {
                 description: "Checks if binary starts with `0x[1F FF AA]`",
                 example: "0x[1F FF AA AA] | bytes starts-with 0x[1F FF AA]",
-                result: Some(Value::boolean(true, Span::test_data())),
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Checks if binary starts with `0x[1F]`",
                 example: "0x[1F FF AA AA] | bytes starts-with 0x[1F]",
-                result: Some(Value::boolean(true, Span::test_data())),
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Checks if binary starts with `0x[1F]`",
                 example: "0x[1F FF AA AA] | bytes starts-with 0x[11]",
-                result: Some(Value::boolean(false, Span::test_data())),
+                result: Some(Value::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
             },
         ]
     }
 }
 
-fn starts_with(val: &Value, args: &Arguments, span: Span) -> Value {
-    match val {
-        Value::Binary {
-            val,
-            span: val_span,
-        } => Value::boolean(val.starts_with(&args.pattern), *val_span),
-        other => Value::Error {
-            error: ShellError::UnsupportedInput(
-                format!(
-                    "Input's type is {}. This command only works with bytes.",
-                    other.get_type()
-                ),
-                span,
-            ),
-        },
+fn starts_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
+    Value::Bool {
+        val: input.starts_with(pattern),
+        span,
     }
 }
 

crates/nu-command/src/charting/hashable_value.rs

@@ -13,7 +13,7 @@ use std::hash::{Hash, Hasher};
 /// ```text
 /// assert_eq!(HashableValue::Bool {val: true, span: Span{start: 0, end: 1}}, HashableValue::Bool {val: true, span: Span{start: 90, end: 1000}})
 /// ```
-#[derive(Eq, Debug, Ord, PartialOrd)]
+#[derive(Eq, Debug)]
 pub enum HashableValue {
     Bool {
         val: bool,
@@ -53,7 +53,7 @@ impl Default for HashableValue {
     fn default() -> Self {
         HashableValue::Bool {
             val: false,
-            span: Span::unknown(),
+            span: Span { start: 0, end: 0 },
         }
     }
 }
@@ -214,7 +214,7 @@ mod test {
         ];
         for (val, expect_hashable_val) in values.into_iter() {
             assert_eq!(
-                HashableValue::from_value(val, Span::unknown()).unwrap(),
+                HashableValue::from_value(val, Span { start: 0, end: 0 }).unwrap(),
                 expect_hashable_val
             );
         }
@@ -228,7 +228,7 @@ mod test {
                 vals: vec![Value::Bool { val: true, span }],
                 span,
             },
-            Value::Closure {
+            Value::Block {
                 val: 0,
                 captures: HashMap::new(),
                 span,
@@ -245,7 +245,7 @@ mod test {
             },
         ];
         for v in values {
-            assert!(HashableValue::from_value(v, Span::unknown()).is_err())
+            assert!(HashableValue::from_value(v, Span { start: 0, end: 0 }).is_err())
         }
     }
 
@@ -266,7 +266,7 @@ mod test {
         for val in values.into_iter() {
             let expected_val = val.clone();
             assert_eq!(
-                HashableValue::from_value(val, Span::unknown())
+                HashableValue::from_value(val, Span { start: 0, end: 0 })
                     .unwrap()
                     .into_value(),
                 expected_val
@@ -279,11 +279,14 @@ mod test {
         assert_eq!(
             HashableValue::Bool {
                 val: true,
-                span: Span::new(0, 1)
+                span: Span { start: 0, end: 1 }
             },
             HashableValue::Bool {
                 val: true,
-                span: Span::new(90, 1000)
+                span: Span {
+                    start: 90,
+                    end: 1000
+                }
             }
         )
     }
@@ -296,7 +299,7 @@ mod test {
         assert!(set.contains(&HashableValue::Bool { val: true, span }));
 
         // hashable value doesn't care about span.
-        let diff_span = Span::new(1, 2);
+        let diff_span = Span { start: 1, end: 2 };
         set.insert(HashableValue::Bool {
             val: true,
             span: diff_span,

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

@@ -1,11 +1,10 @@
 use super::hashable_value::HashableValue;
-use itertools::Itertools;
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
     Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape,
-    Type, Value,
+    Value,
 };
 use std::collections::HashMap;
 use std::iter;
@@ -25,7 +24,6 @@ impl Command for Histogram {
 
     fn signature(&self) -> Signature {
         Signature::build("histogram")
-            .input_output_types(vec![(Type::List(Box::new(Type::Any)), Type::Table(vec![])),])
             .optional("column-name", SyntaxShape::String, "column name to calc frequency, no need to provide if input is just a list")
             .optional("frequency-column-name", SyntaxShape::String, "histogram's frequency column, default to be frequency column output")
             .named("percentage-type", SyntaxShape::String, "percentage calculate method, can be 'normalize' or 'relative', in 'normalize', defaults to be 'normalize'", Some('t'))
@@ -38,49 +36,24 @@ impl Command for Histogram {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "Compute a histogram of file types",
+                description: "Get a histogram for the types of files",
                 example: "ls | histogram type",
                 result: None,
             },
             Example {
                 description:
-                    "Compute a histogram for the types of files, with frequency column named freq",
+                    "Get a histogram for the types of files, with frequency column named freq",
                 example: "ls | histogram type freq",
                 result: None,
             },
             Example {
-                description: "Compute a histogram for a list of numbers",
-                example: "[1 2 1] | histogram",
-                result: Some(Value::List {
-                        vals: vec![Value::Record {
-                            cols: vec!["value".to_string(), "count".to_string(), "quantile".to_string(), "percentage".to_string(), "frequency".to_string()],
-                            vals: vec![
-                                Value::test_int(1),
-                                Value::test_int(2),
-                                Value::test_float(0.6666666666666666),
-                                Value::test_string("66.67%"),
-                                Value::test_string("******************************************************************"),
-                            ],
-                            span: Span::test_data(),
-                        },
-                        Value::Record {
-                            cols: vec!["value".to_string(), "count".to_string(), "quantile".to_string(), "percentage".to_string(), "frequency".to_string()],
-                            vals: vec![
-                                Value::test_int(2),
-                                Value::test_int(1),
-                                Value::test_float(0.3333333333333333),
-                                Value::test_string("33.33%"),
-                                Value::test_string("*********************************"),
-                            ],
-                            span: Span::test_data(),
-                        }],
-                        span: Span::test_data(),
-                    }
-                 ),
+                description: "Get a histogram for a list of numbers",
+                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram",
+                result: None,
             },
             Example {
-                description: "Compute a histogram for a list of numbers, and percentage is based on the maximum value",
-                example: "[1 2 3 1 1 1 2 2 1 1] | histogram --percentage-type relative",
+                description: "Get a histogram for a list of numbers, and percentage is based on the maximum value",
+                example: "echo [1 2 3 1 1 1 2 2 1 1] | histogram --percentage-type relative",
                 result: None,
             }
         ]
@@ -240,42 +213,34 @@ fn histogram_impl(
         freq_column.to_string(),
     ];
     const MAX_FREQ_COUNT: f64 = 100.0;
-    for (val, count) in counter.into_iter().sorted() {
+    for (val, count) in counter.into_iter() {
         let quantile = match calc_method {
-            PercentageCalcMethod::Normalize => count as f64 / total_cnt as f64,
-            PercentageCalcMethod::Relative => count as f64 / max_cnt as f64,
+            PercentageCalcMethod::Normalize => (count as f64 / total_cnt as f64),
+            PercentageCalcMethod::Relative => (count as f64 / max_cnt as f64),
         };
 
         let percentage = format!("{:.2}%", quantile * 100_f64);
         let freq = "*".repeat((MAX_FREQ_COUNT * quantile).floor() as usize);
 
-        result.push((
-            count, // attach count first for easily sorting.
-            Value::Record {
-                cols: result_cols.clone(),
-                vals: vec![
-                    val.into_value(),
-                    Value::Int { val: count, span },
-                    Value::Float {
-                        val: quantile,
-                        span,
-                    },
-                    Value::String {
-                        val: percentage,
-                        span,
-                    },
-                    Value::String { val: freq, span },
-                ],
-                span,
-            },
-        ));
+        result.push(Value::Record {
+            cols: result_cols.clone(),
+            vals: vec![
+                val.into_value(),
+                Value::Int { val: count, span },
+                Value::Float {
+                    val: quantile,
+                    span,
+                },
+                Value::String {
+                    val: percentage,
+                    span,
+                },
+                Value::String { val: freq, span },
+            ],
+            span,
+        });
     }
-    result.sort_by(|a, b| b.0.cmp(&a.0));
-    Value::List {
-        vals: result.into_iter().map(|x| x.1).collect(),
-        span,
-    }
-    .into_pipeline_data()
+    Value::List { vals: result, span }.into_pipeline_data()
 }
 
 #[cfg(test)]

crates/nu-command/src/conversions/fmt.rs

@@ -1,9 +1,8 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Value,
 };
 
 #[derive(Clone)]
@@ -19,9 +18,7 @@ impl Command for Fmt {
     }
 
     fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("fmt")
-            .input_output_types(vec![(Type::Number, Type::Record(vec![]))])
-            .category(Category::Conversions)
+        Signature::build("fmt").category(Category::Conversions)
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -44,14 +41,38 @@ impl Command for Fmt {
                     "upperhex".into(),
                 ],
                 vals: vec![
-                    Value::string("0b101010", Span::test_data()),
-                    Value::string("42", Span::test_data()),
-                    Value::string("42", Span::test_data()),
-                    Value::string("4.2e1", Span::test_data()),
-                    Value::string("0x2a", Span::test_data()),
-                    Value::string("0o52", Span::test_data()),
-                    Value::string("4.2E1", Span::test_data()),
-                    Value::string("0x2A", Span::test_data()),
+                    Value::String {
+                        val: "0b101010".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "42".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "42".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "4.2e1".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "0x2a".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "0o52".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "4.2E1".to_string(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "0x2A".to_string(),
+                        span: Span::test_data(),
+                    },
                 ],
                 span: Span::test_data(),
             }),
@@ -75,12 +96,31 @@ fn fmt(
     call: &Call,
     input: PipelineData,
 ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-    let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-    let args = CellPathOnlyArgs::from(cell_paths);
-    operate(action, args, input, call.head, engine_state.ctrlc.clone())
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
 }
 
-fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
+pub fn action(input: &Value, span: Span) -> Value {
     match input {
         Value::Int { val, .. } => fmt_it(*val, span),
         Value::Filesize { val, .. } => fmt_it(*val, span),

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

@@ -1,10 +1,9 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Type, Value,
+    Value,
 };
 
 #[derive(Clone)]
@@ -17,20 +16,10 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into binary")
-            .input_output_types(vec![
-                (Type::Binary, Type::Binary),
-                (Type::Int, Type::Binary),
-                (Type::Number, Type::Binary),
-                (Type::String, Type::Binary),
-                (Type::Bool, Type::Binary),
-                (Type::Filesize, Type::Binary),
-                (Type::Date, Type::Binary),
-            ])
-            .allow_variants_without_examples(true) // TODO: supply exhaustive examples
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "column paths to convert to binary (for table input)",
             )
             .category(Category::Conversions)
     }
@@ -40,7 +29,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "bytes"]
+        vec!["convert", "binary", "bytes", "bin"]
     }
 
     fn run(
@@ -111,7 +100,7 @@ fn into_binary(
     input: PipelineData,
 ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
     let head = call.head;
-    let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
 
     match input {
         PipelineData::ExternalStream { stdout: None, .. } => Ok(Value::Binary {
@@ -131,10 +120,27 @@ fn into_binary(
             }
             .into_pipeline_data())
         }
-        _ => {
-            let arg = CellPathOnlyArgs::from(cell_paths);
-            operate(action, arg, input, call.head, engine_state.ctrlc.clone())
-        }
+        _ => input.map(
+            move |v| {
+                if column_paths.is_empty() {
+                    action(&v, head)
+                } else {
+                    let mut ret = v;
+                    for path in &column_paths {
+                        let r = ret.update_cell_path(
+                            &path.members,
+                            Box::new(move |old| action(old, head)),
+                        );
+                        if let Err(error) = r {
+                            return Value::Error { error };
+                        }
+                    }
+
+                    ret
+                }
+            },
+            engine_state.ctrlc.clone(),
+        ),
     }
 }
 
@@ -154,7 +160,7 @@ fn float_to_endian(n: f64) -> Vec<u8> {
     }
 }
 
-pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
+pub fn action(input: &Value, span: Span) -> Value {
     match input {
         Value::Binary { .. } => input.clone(),
         Value::Int { val, .. } => Value::Binary {
@@ -174,7 +180,7 @@ pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
             span,
         },
         Value::Bool { val, .. } => Value::Binary {
-            val: int_to_endian(i64::from(*val)),
+            val: int_to_endian(if *val { 1i64 } else { 0 }),
             span,
         },
         Value::Date { val, .. } => Value::Binary {

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

@@ -1,9 +1,8 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 
 #[derive(Clone)]
@@ -16,17 +15,10 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into bool")
-            .input_output_types(vec![
-                (Type::Int, Type::Bool),
-                (Type::Number, Type::Bool),
-                (Type::String, Type::Bool),
-                (Type::Bool, Type::Bool),
-                (Type::List(Box::new(Type::Any)), Type::Table(vec![])),
-            ])
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "column paths to convert to boolean (for table input)",
             )
             .category(Category::Conversions)
     }
@@ -54,7 +46,7 @@ impl Command for SubCommand {
         vec![
             Example {
                 description: "Convert value to boolean in table",
-                example: "[[value]; ['false'] ['1'] [0] [1.0] [true]] | into bool value",
+                example: "echo [[value]; ['false'] ['1'] [0] [1.0] [true]] | into bool value",
                 result: Some(Value::List {
                     vals: vec![
                         Value::Record {
@@ -96,11 +88,6 @@ impl Command for SubCommand {
                 example: "1 | into bool",
                 result: Some(Value::boolean(true, span)),
             },
-            Example {
-                description: "convert decimal to boolean",
-                example: "0.3 | into bool",
-                result: Some(Value::boolean(true, span)),
-            },
             Example {
                 description: "convert decimal string to boolean",
                 example: "'0.0' | into bool",
@@ -121,9 +108,28 @@ fn into_bool(
     call: &Call,
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
-    let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-    let args = CellPathOnlyArgs::from(cell_paths);
-    operate(action, args, input, call.head, engine_state.ctrlc.clone())
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
 }
 
 fn string_to_boolean(s: &str, span: Span) -> Result<bool, ShellError> {
@@ -148,7 +154,7 @@ fn string_to_boolean(s: &str, span: Span) -> Result<bool, ShellError> {
     }
 }
 
-fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
+fn action(input: &Value, span: Span) -> Value {
     match input {
         Value::Bool { .. } => input.clone(),
         Value::Int { val, .. } => Value::Bool {

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

@@ -29,13 +29,7 @@ impl Command for Into {
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         Ok(Value::String {
-            val: get_full_help(
-                &Into.signature(),
-                &[],
-                engine_state,
-                stack,
-                self.is_parser_keyword(),
-            ),
+            val: get_full_help(&Into.signature(), &[], engine_state, stack),
             span: call.head,
         }
         .into_pipeline_data())

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

@@ -1,25 +1,18 @@
-use crate::input_handler::{operate, CmdArgument};
 use crate::{generate_strftime_list, parse_date_from_string};
-use chrono::{DateTime, FixedOffset, Local, LocalResult, TimeZone, Utc};
+use chrono::{DateTime, FixedOffset, Local, TimeZone, Utc};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::ast::CellPath;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Spanned,
-    SyntaxShape, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
 
 struct Arguments {
-    zone_options: Option<Spanned<Zone>>,
-    format_options: Option<DatetimeFormat>,
-    cell_paths: Option<Vec<CellPath>>,
-}
-
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
-    }
+    timezone: Option<Spanned<String>>,
+    offset: Option<Spanned<i64>>,
+    format: Option<String>,
+    column_paths: Vec<CellPath>,
 }
 
 // In case it may be confused with chrono::TimeZone
@@ -64,11 +57,7 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into datetime")
-        .input_output_types(vec![
-            (Type::Int, Type::Date),
-            (Type::String, Type::Date),
-        ])
-        .named(
+            .named(
                 "timezone",
                 SyntaxShape::String,
                 "Specify timezone if the input is a Unix timestamp. Valid options: 'UTC' ('u') or 'LOCAL' ('l')",
@@ -94,7 +83,7 @@ impl Command for SubCommand {
             .rest(
             "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "optionally convert text into datetime by column paths",
             )
             .category(Category::Conversions)
     }
@@ -106,36 +95,7 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        if call.has_flag("list") {
-            Ok(generate_strftime_list(call.head, true).into_pipeline_data())
-        } else {
-            let cell_paths = call.rest(engine_state, stack, 0)?;
-            let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
-
-            // if zone-offset is specified, then zone will be neglected
-            let timezone = call.get_flag::<Spanned<String>>(engine_state, stack, "timezone")?;
-            let zone_options =
-                match &call.get_flag::<Spanned<i64>>(engine_state, stack, "offset")? {
-                    Some(zone_offset) => Some(Spanned {
-                        item: Zone::new(zone_offset.item),
-                        span: zone_offset.span,
-                    }),
-                    None => timezone.as_ref().map(|zone| Spanned {
-                        item: Zone::from_string(zone.item.clone()),
-                        span: zone.span,
-                    }),
-                };
-            let format_options = call
-                .get_flag::<String>(engine_state, stack, "format")?
-                .as_ref()
-                .map(|fmt| DatetimeFormat(fmt.to_string()));
-            let args = Arguments {
-                format_options,
-                zone_options,
-                cell_paths,
-            };
-            operate(action, args, input, call.head, engine_state.ctrlc.clone())
-        }
+        operate(engine_state, stack, call, input)
     }
 
     fn usage(&self) -> &str {
@@ -143,67 +103,42 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "timezone", "UTC"]
+        vec!["convert", "date", "time", "timezone", "UTC"]
     }
 
     fn examples(&self) -> Vec<Example> {
-        let example_result_1 = |secs: i64, nsecs: u32| {
-            let dt = match Utc.timestamp_opt(secs, nsecs) {
-                LocalResult::Single(dt) => Some(dt),
-                _ => None,
-            };
-            match dt {
-                Some(dt) => Some(Value::Date {
-                    val: dt.into(),
-                    span: Span::test_data(),
-                }),
-                None => Some(Value::Error {
-                    error: ShellError::UnsupportedInput(
-                        "The given datetime representation is unsupported.".to_string(),
-                        Span::test_data(),
-                    ),
-                }),
-            }
-        };
-        let example_result_2 = |millis: i64| {
-            let dt = match Utc.timestamp_millis_opt(millis) {
-                LocalResult::Single(dt) => Some(dt),
-                _ => None,
-            };
-            match dt {
-                Some(dt) => Some(Value::Date {
-                    val: dt.into(),
-                    span: Span::test_data(),
-                }),
-                None => Some(Value::Error {
-                    error: ShellError::UnsupportedInput(
-                        "The given datetime representation is unsupported.".to_string(),
-                        Span::test_data(),
-                    ),
-                }),
-            }
-        };
         vec![
             Example {
                 description: "Convert to datetime",
                 example: "'27.02.2021 1:55 pm +0000' | into datetime",
-                result: example_result_1(1614434100,0)
+                result: Some(Value::Date {
+                    val: Utc.timestamp(1614434100, 0).into(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Convert to datetime",
                 example: "'2021-02-27T13:55:40+00:00' | into datetime",
-                result: example_result_1(1614434140, 0)
+                result: Some(Value::Date {
+                    val: Utc.timestamp(1614434140, 0).into(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Convert to datetime using a custom format",
                 example: "'20210227_135540+0000' | into datetime -f '%Y%m%d_%H%M%S%z'",
-                result: example_result_1(1614434140, 0)
-
+                result: Some(Value::Date {
+                    val: Utc.timestamp(1614434140, 0).into(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Convert timestamp (no larger than 8e+12) to a UTC datetime",
                 example: "1614434140 | into datetime",
-                result: example_result_1(1614434140, 0)
+                result: Some(Value::Date {
+                    val: Utc.timestamp(1614434140, 0).into(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description:
@@ -215,7 +150,10 @@ impl Command for SubCommand {
                 description:
                     "Convert timestamps like the sqlite history t",
                 example: "1656165681720 | into datetime",
-                result: example_result_2(1656165681720)
+                result: Some(Value::Date {
+                    val: Utc.timestamp_millis(1656165681720).into(),
+                    span: Span::test_data(),
+                }),
             },
         ]
     }
@@ -224,9 +162,72 @@ impl Command for SubCommand {
 #[derive(Clone)]
 struct DatetimeFormat(String);
 
-fn action(input: &Value, args: &Arguments, head: Span) -> Value {
-    let timezone = &args.zone_options;
-    let dateformat = &args.format_options;
+fn operate(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+
+    let options = Arguments {
+        timezone: call.get_flag(engine_state, stack, "timezone")?,
+        offset: call.get_flag(engine_state, stack, "offset")?,
+        format: call.get_flag(engine_state, stack, "format")?,
+        column_paths: call.rest(engine_state, stack, 0)?,
+    };
+
+    // if zone-offset is specified, then zone will be neglected
+    let zone_options = match &options.offset {
+        Some(zone_offset) => Some(Spanned {
+            item: Zone::new(zone_offset.item),
+            span: zone_offset.span,
+        }),
+        None => options.timezone.as_ref().map(|zone| Spanned {
+            item: Zone::from_string(zone.item.clone()),
+            span: zone.span,
+        }),
+    };
+
+    let list_flag = call.has_flag("list");
+
+    let format_options = options
+        .format
+        .as_ref()
+        .map(|fmt| DatetimeFormat(fmt.to_string()));
+
+    input.map(
+        move |v| {
+            if options.column_paths.is_empty() && !list_flag {
+                action(&v, &zone_options, &format_options, head)
+            } else if list_flag {
+                generate_strftime_list(head, true)
+            } else {
+                let mut ret = v;
+                for path in &options.column_paths {
+                    let zone_options = zone_options.clone();
+                    let format_options = format_options.clone();
+                    let r = ret.update_cell_path(
+                        &path.members,
+                        Box::new(move |old| action(old, &zone_options, &format_options, head)),
+                    );
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+fn action(
+    input: &Value,
+    timezone: &Option<Spanned<Zone>>,
+    dateformat: &Option<DatetimeFormat>,
+    head: Span,
+) -> Value {
     // Check to see if input looks like a Unix timestamp (i.e. can it be parsed to an int?)
     let timestamp = match input {
         Value::Int { val, .. } => Ok(*val),
@@ -261,31 +262,8 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                 // be able to convert chrono::Utc::now()
                 let dt = match ts.to_string().len() {
                     x if x > 13 => Utc.timestamp_nanos(ts).into(),
-                    x if x > 10 => match Utc.timestamp_millis_opt(ts) {
-                        LocalResult::Single(dt) => dt.into(),
-                        _ => {
-                            return Value::Error {
-                                // This error message is from chrono
-                                error: ShellError::UnsupportedInput(
-                                    "The given local datetime representation is invalid."
-                                        .to_string(),
-                                    head,
-                                ),
-                            };
-                        }
-                    },
-                    _ => match Utc.timestamp_opt(ts, 0) {
-                        LocalResult::Single(dt) => dt.into(),
-                        _ => {
-                            return Value::Error {
-                                error: ShellError::UnsupportedInput(
-                                    "The given local datetime representation is invalid."
-                                        .to_string(),
-                                    head,
-                                ),
-                            }
-                        }
-                    },
+                    x if x > 10 => Utc.timestamp_millis(ts).into(),
+                    _ => Utc.timestamp(ts, 0).into(),
                 };
 
                 Value::Date {
@@ -294,64 +272,28 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                 }
             }
             Some(Spanned { item, span }) => match item {
-                Zone::Utc => match Utc.timestamp_opt(ts, 0) {
-                    LocalResult::Single(val) => Value::Date {
-                        val: val.into(),
+                Zone::Utc => Value::Date {
+                    val: Utc.timestamp(ts, 0).into(),
+                    span: head,
+                },
+                Zone::Local => Value::Date {
+                    val: Local.timestamp(ts, 0).into(),
+                    span: head,
+                },
+                Zone::East(i) => {
+                    let eastoffset = FixedOffset::east((*i as i32) * HOUR);
+                    Value::Date {
+                        val: eastoffset.timestamp(ts, 0),
                         span: head,
-                    },
-                    _ => Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
-                    },
-                },
-                Zone::Local => match Local.timestamp_opt(ts, 0) {
-                    LocalResult::Single(val) => Value::Date {
-                        val: val.into(),
+                    }
+                }
+                Zone::West(i) => {
+                    let westoffset = FixedOffset::west((*i as i32) * HOUR);
+                    Value::Date {
+                        val: westoffset.timestamp(ts, 0),
                         span: head,
-                    },
-                    _ => Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
-                    },
-                },
-                Zone::East(i) => match FixedOffset::east_opt((*i as i32) * HOUR) {
-                    Some(eastoffset) => match eastoffset.timestamp_opt(ts, 0) {
-                        LocalResult::Single(val) => Value::Date { val, span: head },
-                        _ => Value::Error {
-                            error: ShellError::UnsupportedInput(
-                                "The given local datetime representation is invalid.".to_string(),
-                                *span,
-                            ),
-                        },
-                    },
-                    None => Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
-                    },
-                },
-                Zone::West(i) => match FixedOffset::west_opt((*i as i32) * HOUR) {
-                    Some(westoffset) => match westoffset.timestamp_opt(ts, 0) {
-                        LocalResult::Single(val) => Value::Date { val, span: head },
-                        _ => Value::Error {
-                            error: ShellError::UnsupportedInput(
-                                "The given local datetime representation is invalid.".to_string(),
-                                *span,
-                            ),
-                        },
-                    },
-                    None => Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "The given local datetime representation is invalid.".to_string(),
-                            *span,
-                        ),
-                    },
-                },
+                    }
+                }
                 Zone::Error => Value::Error {
                     error: ShellError::UnsupportedInput(
                         "Cannot convert given timezone or offset to timestamp".to_string(),
@@ -369,7 +311,7 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                 Some(dt) => match DateTime::parse_from_str(val, &dt.0) {
                     Ok(d) => Value::Date { val: d, span: head },
                     Err(reason) => {
-                        Value::Error {
+                        return Value::Error {
                             error: ShellError::CantConvert(
                                 format!("could not parse as datetime using format '{}'", dt.0),
                                 reason.to_string(),
@@ -417,12 +359,7 @@ mod tests {
     fn takes_a_date_format() {
         let date_str = Value::test_string("16.11.1984 8:00 am +0000");
         let fmt_options = Some(DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string()));
-        let args = Arguments {
-            zone_options: None,
-            format_options: fmt_options,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let actual = action(&date_str, &None, &fmt_options, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("16.11.1984 8:00 am +0000", "%d.%m.%Y %H:%M %P %z")
                 .unwrap(),
@@ -434,12 +371,7 @@ mod tests {
     #[test]
     fn takes_iso8601_date_format() {
         let date_str = Value::test_string("2020-08-04T16:39:18+00:00");
-        let args = Arguments {
-            zone_options: None,
-            format_options: None,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let actual = action(&date_str, &None, &None, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("2020-08-04T16:39:18+00:00", "%Y-%m-%dT%H:%M:%S%z")
                 .unwrap(),
@@ -455,12 +387,7 @@ mod tests {
             item: Zone::East(8),
             span: Span::test_data(),
         });
-        let args = Arguments {
-            zone_options: timezone_option,
-            format_options: None,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("2021-02-27 21:55:40 +08:00", "%Y-%m-%d %H:%M:%S %z")
                 .unwrap(),
@@ -477,12 +404,7 @@ mod tests {
             item: Zone::East(8),
             span: Span::test_data(),
         });
-        let args = Arguments {
-            zone_options: timezone_option,
-            format_options: None,
-            cell_paths: None,
-        };
-        let actual = action(&date_int, &args, Span::test_data());
+        let actual = action(&date_int, &timezone_option, &None, Span::test_data());
         let expected = Value::Date {
             val: DateTime::parse_from_str("2021-02-27 21:55:40 +08:00", "%Y-%m-%d %H:%M:%S %z")
                 .unwrap(),
@@ -499,14 +421,9 @@ mod tests {
             item: Zone::Local,
             span: Span::test_data(),
         });
-        let args = Arguments {
-            zone_options: timezone_option,
-            format_options: None,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
         let expected = Value::Date {
-            val: Local.timestamp_opt(1614434140, 0).unwrap().into(),
+            val: Local.timestamp(1614434140, 0).into(),
             span: Span::test_data(),
         };
 
@@ -516,15 +433,11 @@ mod tests {
     #[test]
     fn takes_timestamp_without_timezone() {
         let date_str = Value::test_string("1614434140");
-        let args = Arguments {
-            zone_options: None,
-            format_options: None,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let timezone_option = None;
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
 
         let expected = Value::Date {
-            val: Utc.timestamp_opt(1614434140, 0).unwrap().into(),
+            val: Utc.timestamp(1614434140, 0).into(),
             span: Span::test_data(),
         };
 
@@ -538,12 +451,7 @@ mod tests {
             item: Zone::Utc,
             span: Span::test_data(),
         });
-        let args = Arguments {
-            zone_options: timezone_option,
-            format_options: None,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let actual = action(&date_str, &timezone_option, &None, Span::test_data());
 
         assert_eq!(actual.get_type(), Error);
     }
@@ -552,12 +460,7 @@ mod tests {
     fn communicates_parsing_error_given_an_invalid_datetimelike_string() {
         let date_str = Value::test_string("16.11.1984 8:00 am Oops0000");
         let fmt_options = Some(DatetimeFormat("%d.%m.%Y %H:%M %P %z".to_string()));
-        let args = Arguments {
-            zone_options: None,
-            format_options: fmt_options,
-            cell_paths: None,
-        };
-        let actual = action(&date_str, &args, Span::test_data());
+        let actual = action(&date_str, &None, &fmt_options, Span::test_data());
 
         assert_eq!(actual.get_type(), Error);
     }

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

@@ -1,9 +1,8 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 
 #[derive(Clone)]
@@ -15,16 +14,11 @@ impl Command for SubCommand {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("into decimal")
-            .input_output_types(vec![
-                (Type::String, Type::Number),
-                (Type::Bool, Type::Number),
-            ])
-            .rest(
-                "rest",
-                SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
-            )
+        Signature::build("into decimal").rest(
+            "rest",
+            SyntaxShape::CellPath,
+            "optionally convert text into decimal by column paths",
+        )
     }
 
     fn usage(&self) -> &str {
@@ -42,15 +36,13 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-        let args = CellPathOnlyArgs::from(cell_paths);
-        operate(action, args, input, call.head, engine_state.ctrlc.clone())
+        operate(engine_state, stack, call, input)
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "Convert string to decimal in table",
+                description: "Convert string to integer in table",
                 example: "[[num]; ['5.01']] | into decimal num",
                 result: Some(Value::List {
                     vals: vec![Value::Record {
@@ -62,31 +54,56 @@ impl Command for SubCommand {
                 }),
             },
             Example {
-                description: "Convert string to decimal",
+                description: "Convert string to integer",
                 example: "'1.345' | into decimal",
                 result: Some(Value::test_float(1.345)),
             },
             Example {
-                description: "Convert decimal to decimal",
+                description: "Convert decimal to integer",
                 example: "'-5.9' | into decimal",
                 result: Some(Value::test_float(-5.9)),
             },
-            Example {
-                description: "Convert boolean to decimal",
-                example: "true | into decimal",
-                result: Some(Value::test_float(1.0)),
-            },
         ]
     }
 }
 
-fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
+fn operate(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+fn action(input: &Value, head: Span) -> Value {
     match input {
         Value::String { val: s, span } => {
             let other = s.trim();
 
             match other.parse::<f64>() {
-                Ok(x) => Value::float(x, head),
+                Ok(x) => Value::Float { val: x, span: head },
                 Err(reason) => Value::Error {
                     error: ShellError::CantConvert(
                         "float".to_string(),
@@ -97,12 +114,8 @@ fn action(input: &Value, _args: &CellPathOnlyArgs, head: Span) -> Value {
                 },
             }
         }
-        Value::Int { val: v, span } => Value::float(*v as f64, *span),
-        Value::Bool { val: b, span } => Value::Float {
-            val: match b {
-                true => 1.0,
-                false => 0.0,
-            },
+        Value::Int { val: v, span } => Value::Float {
+            val: *v as f64,
             span: *span,
         },
         other => {
@@ -138,7 +151,7 @@ mod tests {
         let word = Value::test_string("3.1415");
         let expected = Value::test_float(3.1415);
 
-        let actual = action(&word, &CellPathOnlyArgs::from(vec![]), Span::test_data());
+        let actual = action(&word, Span::test_data());
         assert_eq!(actual, expected);
     }
 
@@ -146,11 +159,7 @@ mod tests {
     fn communicates_parsing_error_given_an_invalid_decimallike_string() {
         let decimal_str = Value::test_string("11.6anra");
 
-        let actual = action(
-            &decimal_str,
-            &CellPathOnlyArgs::from(vec![]),
-            Span::test_data(),
-        );
+        let actual = action(&decimal_str, Span::test_data());
 
         assert_eq!(actual.get_type(), Error);
     }
@@ -159,11 +168,7 @@ mod tests {
     fn int_to_decimal() {
         let decimal_str = Value::test_int(10);
         let expected = Value::test_float(10.0);
-        let actual = action(
-            &decimal_str,
-            &CellPathOnlyArgs::from(vec![]),
-            Span::test_data(),
-        );
+        let actual = action(&decimal_str, Span::test_data());
 
         assert_eq!(actual, expected);
     }

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

@@ -3,8 +3,7 @@ use nu_parser::parse_duration_bytes;
 use nu_protocol::{
     ast::{Call, CellPath, Expr},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Unit,
-    Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Unit, Value,
 };
 
 #[derive(Clone)]
@@ -17,23 +16,10 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into duration")
-            .input_output_types(vec![
-                (Type::String, Type::Duration),
-                (Type::Duration, Type::Duration),
-                // TODO: --convert option should be implemented as `format duration`
-                (Type::String, Type::String),
-                (Type::Duration, Type::String),
-            ])
-            .named(
-                "convert",
-                SyntaxShape::String,
-                "convert duration into another duration",
-                Some('c'),
-            )
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "column paths to convert to duration (for table input)",
             )
             .category(Category::Conversions)
     }
@@ -43,7 +29,7 @@ impl Command for SubCommand {
     }
 
     fn extra_usage(&self) -> &str {
-        "This command does not take leap years into account, and every month is assumed to have 30 days."
+        "into duration does not take leap years into account and every month is calculated with 30 days"
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -65,8 +51,7 @@ impl Command for SubCommand {
         vec![
             Example {
                 description: "Convert string to duration in table",
-                example:
-                    "[[value]; ['1sec'] ['2min'] ['3hr'] ['4day'] ['5wk']] | into duration value",
+                example: "echo [[value]; ['1sec'] ['2min'] ['3hr'] ['4day'] ['5wk']] | into duration value",
                 result: Some(Value::List {
                     vals: vec![
                         Value::Record {
@@ -121,30 +106,6 @@ impl Command for SubCommand {
                     span,
                 }),
             },
-            Example {
-                description: "Convert string to the requested duration as a string",
-                example: "'7min' | into duration --convert sec",
-                result: Some(Value::String {
-                    val: "420 sec".to_string(),
-                    span,
-                }),
-            },
-            Example {
-                description: "Convert duration to duration",
-                example: "420sec | into duration",
-                result: Some(Value::Duration {
-                    val: 7 * 60 * 1000 * 1000 * 1000,
-                    span,
-                }),
-            },
-            Example {
-                description: "Convert duration to the requested duration as a string",
-                example: "420sec | into duration --convert ms",
-                result: Some(Value::String {
-                    val: "420000 ms".to_string(),
-                    span,
-                }),
-            },
         ]
     }
 }
@@ -156,23 +117,17 @@ fn into_duration(
     input: PipelineData,
 ) -> Result<PipelineData, ShellError> {
     let head = call.head;
-    let convert_to_unit: Option<Spanned<String>> = call.get_flag(engine_state, stack, "convert")?;
     let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-    let config = engine_state.get_config();
-    let float_precision = config.float_precision as usize;
 
     input.map(
         move |v| {
             if column_paths.is_empty() {
-                action(&v, &convert_to_unit, float_precision, head)
+                action(&v, head)
             } else {
                 let mut ret = v;
                 for path in &column_paths {
-                    let d = convert_to_unit.clone();
-                    let r = ret.update_cell_path(
-                        &path.members,
-                        Box::new(move |old| action(old, &d, float_precision, head)),
-                    );
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
                     if let Err(error) = r {
                         return Value::Error { error };
                     }
@@ -185,150 +140,6 @@ fn into_duration(
     )
 }
 
-fn convert_str_from_unit_to_unit(
-    val: i64,
-    from_unit: &str,
-    to_unit: &str,
-    span: Span,
-    value_span: Span,
-) -> Result<f64, ShellError> {
-    match (from_unit, to_unit) {
-        ("ns", "ns") => Ok(val as f64),
-        ("ns", "us") => Ok(val as f64 / 1000.0),
-        ("ns", "ms") => Ok(val as f64 / 1000.0 / 1000.0),
-        ("ns", "sec") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0),
-        ("ns", "min") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0),
-        ("ns", "hr") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0),
-        ("ns", "day") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0),
-        ("ns", "wk") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 7.0),
-        ("ns", "month") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 30.0),
-        ("ns", "yr") => Ok(val as f64 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
-        ("ns", "dec") => {
-            Ok(val as f64 / 10.0 / 1000.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0)
-        }
-
-        ("us", "ns") => Ok(val as f64 * 1000.0),
-        ("us", "us") => Ok(val as f64),
-        ("us", "ms") => Ok(val as f64 / 1000.0),
-        ("us", "sec") => Ok(val as f64 / 1000.0 / 1000.0),
-        ("us", "min") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0),
-        ("us", "hr") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0),
-        ("us", "day") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0),
-        ("us", "wk") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 7.0),
-        ("us", "month") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 30.0),
-        ("us", "yr") => Ok(val as f64 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
-        ("us", "dec") => Ok(val as f64 / 10.0 / 1000.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
-
-        ("ms", "ns") => Ok(val as f64 * 1000.0 * 1000.0),
-        ("ms", "us") => Ok(val as f64 * 1000.0),
-        ("ms", "ms") => Ok(val as f64),
-        ("ms", "sec") => Ok(val as f64 / 1000.0),
-        ("ms", "min") => Ok(val as f64 / 1000.0 / 60.0),
-        ("ms", "hr") => Ok(val as f64 / 1000.0 / 60.0 / 60.0),
-        ("ms", "day") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0),
-        ("ms", "wk") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0 / 7.0),
-        ("ms", "month") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0 / 30.0),
-        ("ms", "yr") => Ok(val as f64 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
-        ("ms", "dec") => Ok(val as f64 / 10.0 / 1000.0 / 60.0 / 60.0 / 24.0 / 365.0),
-
-        ("sec", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0),
-        ("sec", "us") => Ok(val as f64 * 1000.0 * 1000.0),
-        ("sec", "ms") => Ok(val as f64 * 1000.0),
-        ("sec", "sec") => Ok(val as f64),
-        ("sec", "min") => Ok(val as f64 / 60.0),
-        ("sec", "hr") => Ok(val as f64 / 60.0 / 60.0),
-        ("sec", "day") => Ok(val as f64 / 60.0 / 60.0 / 24.0),
-        ("sec", "wk") => Ok(val as f64 / 60.0 / 60.0 / 24.0 / 7.0),
-        ("sec", "month") => Ok(val as f64 / 60.0 / 60.0 / 24.0 / 30.0),
-        ("sec", "yr") => Ok(val as f64 / 60.0 / 60.0 / 24.0 / 365.0),
-        ("sec", "dec") => Ok(val as f64 / 10.0 / 60.0 / 60.0 / 24.0 / 365.0),
-
-        ("min", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0),
-        ("min", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0),
-        ("min", "ms") => Ok(val as f64 * 1000.0 * 60.0),
-        ("min", "sec") => Ok(val as f64 * 60.0),
-        ("min", "min") => Ok(val as f64),
-        ("min", "hr") => Ok(val as f64 / 60.0),
-        ("min", "day") => Ok(val as f64 / 60.0 / 24.0),
-        ("min", "wk") => Ok(val as f64 / 60.0 / 24.0 / 7.0),
-        ("min", "month") => Ok(val as f64 / 60.0 / 24.0 / 30.0),
-        ("min", "yr") => Ok(val as f64 / 60.0 / 24.0 / 365.0),
-        ("min", "dec") => Ok(val as f64 / 10.0 / 60.0 / 24.0 / 365.0),
-
-        ("hr", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0),
-        ("hr", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0),
-        ("hr", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0),
-        ("hr", "sec") => Ok(val as f64 * 60.0 * 60.0),
-        ("hr", "min") => Ok(val as f64 * 60.0),
-        ("hr", "hr") => Ok(val as f64),
-        ("hr", "day") => Ok(val as f64 / 24.0),
-        ("hr", "wk") => Ok(val as f64 / 24.0 / 7.0),
-        ("hr", "month") => Ok(val as f64 / 24.0 / 30.0),
-        ("hr", "yr") => Ok(val as f64 / 24.0 / 365.0),
-        ("hr", "dec") => Ok(val as f64 / 10.0 / 24.0 / 365.0),
-
-        ("day", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0),
-        ("day", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0),
-        ("day", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0),
-        ("day", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0),
-        ("day", "min") => Ok(val as f64 * 60.0 * 24.0),
-        ("day", "hr") => Ok(val as f64 * 24.0),
-        ("day", "day") => Ok(val as f64),
-        ("day", "wk") => Ok(val as f64 / 7.0),
-        ("day", "month") => Ok(val as f64 / 30.0),
-        ("day", "yr") => Ok(val as f64 / 365.0),
-        ("day", "dec") => Ok(val as f64 / 10.0 / 365.0),
-
-        ("wk", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 7.0),
-        ("wk", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 7.0),
-        ("wk", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0 * 7.0),
-        ("wk", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0 * 7.0),
-        ("wk", "min") => Ok(val as f64 * 60.0 * 24.0 * 7.0),
-        ("wk", "hr") => Ok(val as f64 * 24.0 * 7.0),
-        ("wk", "day") => Ok(val as f64 * 7.0),
-        ("wk", "wk") => Ok(val as f64),
-        ("wk", "month") => Ok(val as f64 / 4.0),
-        ("wk", "yr") => Ok(val as f64 / 52.0),
-        ("wk", "dec") => Ok(val as f64 / 10.0 / 52.0),
-
-        ("month", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 30.0),
-        ("month", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 30.0),
-        ("month", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0 * 30.0),
-        ("month", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0 * 30.0),
-        ("month", "min") => Ok(val as f64 * 60.0 * 24.0 * 30.0),
-        ("month", "hr") => Ok(val as f64 * 24.0 * 30.0),
-        ("month", "day") => Ok(val as f64 * 30.0),
-        ("month", "wk") => Ok(val as f64 * 4.0),
-        ("month", "month") => Ok(val as f64),
-        ("month", "yr") => Ok(val as f64 / 12.0),
-        ("month", "dec") => Ok(val as f64 / 10.0 / 12.0),
-
-        ("yr", "ns") => Ok(val as f64 * 1000.0 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 365.0),
-        ("yr", "us") => Ok(val as f64 * 1000.0 * 1000.0 * 60.0 * 60.0 * 24.0 * 365.0),
-        ("yr", "ms") => Ok(val as f64 * 1000.0 * 60.0 * 60.0 * 24.0 * 365.0),
-        ("yr", "sec") => Ok(val as f64 * 60.0 * 60.0 * 24.0 * 365.0),
-        ("yr", "min") => Ok(val as f64 * 60.0 * 24.0 * 365.0),
-        ("yr", "hr") => Ok(val as f64 * 24.0 * 365.0),
-        ("yr", "day") => Ok(val as f64 * 365.0),
-        ("yr", "wk") => Ok(val as f64 * 52.0),
-        ("yr", "month") => Ok(val as f64 * 12.0),
-        ("yr", "yr") => Ok(val as f64),
-        ("yr", "dec") => Ok(val as f64 / 10.0),
-
-        _ => Err(ShellError::CantConvertWithValue(
-            "string duration".to_string(),
-            "string duration".to_string(),
-            to_unit.to_string(),
-            span,
-            value_span,
-            Some(
-                "supported units are ns, us, ms, sec, min, hr, day, wk, month, yr and dec"
-                    .to_string(),
-            ),
-        )),
-    }
-}
-
 fn string_to_duration(s: &str, span: Span, value_span: Span) -> Result<i64, ShellError> {
     if let Some(expression) = parse_duration_bytes(s.as_bytes(), span) {
         if let Expr::ValueWithUnit(value, unit) = expression.expr {
@@ -342,6 +153,9 @@ fn string_to_duration(s: &str, span: Span, value_span: Span) -> Result<i64, Shel
                     Unit::Hour => return Ok(x * 60 * 60 * 1000 * 1000 * 1000),
                     Unit::Day => return Ok(x * 24 * 60 * 60 * 1000 * 1000 * 1000),
                     Unit::Week => return Ok(x * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000),
+                    Unit::Month => return Ok(x * 30 * 24 * 60 * 60 * 1000 * 1000 * 1000), //30 days to a month
+                    Unit::Year => return Ok(x * 365 * 24 * 60 * 60 * 1000 * 1000 * 1000), //365 days to a year
+                    Unit::Decade => return Ok(x * 10 * 365 * 24 * 60 * 60 * 1000 * 1000 * 1000), //365 days to a year
                     _ => {}
                 }
             }
@@ -354,133 +168,20 @@ fn string_to_duration(s: &str, span: Span, value_span: Span) -> Result<i64, Shel
         s.to_string(),
         span,
         value_span,
-        Some(
-            "supported units are ns, us, ms, sec, min, hr, day, wk, month, yr and dec".to_string(),
-        ),
+        Some("supported units are ns, us, ms, sec, min, hr, day, and wk".to_string()),
     ))
 }
 
-fn string_to_unit_duration(
-    s: &str,
-    span: Span,
-    value_span: Span,
-) -> Result<(&str, i64), ShellError> {
-    if let Some(expression) = parse_duration_bytes(s.as_bytes(), span) {
-        if let Expr::ValueWithUnit(value, unit) = expression.expr {
-            if let Expr::Int(x) = value.expr {
-                match unit.item {
-                    Unit::Nanosecond => return Ok(("ns", x)),
-                    Unit::Microsecond => return Ok(("us", x)),
-                    Unit::Millisecond => return Ok(("ms", x)),
-                    Unit::Second => return Ok(("sec", x)),
-                    Unit::Minute => return Ok(("min", x)),
-                    Unit::Hour => return Ok(("hr", x)),
-                    Unit::Day => return Ok(("day", x)),
-                    Unit::Week => return Ok(("wk", x)),
-
-                    _ => return Ok(("ns", 0)),
-                }
-            }
-        }
-    }
-
-    Err(ShellError::CantConvertWithValue(
-        "duration".to_string(),
-        "string".to_string(),
-        s.to_string(),
-        span,
-        value_span,
-        Some(
-            "supported units are ns, us, ms, sec, min, hr, day, wk, month, yr and dec".to_string(),
-        ),
-    ))
-}
-
-fn action(
-    input: &Value,
-    convert_to_unit: &Option<Spanned<String>>,
-    float_precision: usize,
-    span: Span,
-) -> Value {
+fn action(input: &Value, span: Span) -> Value {
     match input {
-        Value::Duration {
-            val: val_num,
-            span: value_span,
-        } => {
-            if let Some(to_unit) = convert_to_unit {
-                let from_unit = "ns";
-                let duration = *val_num;
-                match convert_str_from_unit_to_unit(
-                    duration,
-                    from_unit,
-                    &to_unit.item,
-                    span,
-                    *value_span,
-                ) {
-                    Ok(d) => {
-                        if d.fract() == 0.0 {
-                            Value::String {
-                                val: format!("{} {}", d, &to_unit.item),
-                                span: *value_span,
-                            }
-                        } else {
-                            Value::String {
-                                val: format!("{:.float_precision$} {}", d, &to_unit.item),
-                                span: *value_span,
-                            }
-                        }
-                    }
-                    Err(e) => Value::Error { error: e },
-                }
-            } else {
-                input.clone()
-            }
-        }
+        Value::Duration { .. } => input.clone(),
         Value::String {
             val,
             span: value_span,
-        } => {
-            if let Some(to_unit) = convert_to_unit {
-                if let Ok(dur) = string_to_unit_duration(val, span, *value_span) {
-                    let from_unit = dur.0;
-                    let duration = dur.1;
-                    match convert_str_from_unit_to_unit(
-                        duration,
-                        from_unit,
-                        &to_unit.item,
-                        span,
-                        *value_span,
-                    ) {
-                        Ok(d) => {
-                            if d.fract() == 0.0 {
-                                Value::String {
-                                    val: format!("{} {}", d, &to_unit.item),
-                                    span: *value_span,
-                                }
-                            } else {
-                                Value::String {
-                                    val: format!("{:.float_precision$} {}", d, &to_unit.item),
-                                    span: *value_span,
-                                }
-                            }
-                        }
-                        Err(e) => Value::Error { error: e },
-                    }
-                } else {
-                    Value::Error {
-                        error: ShellError::UnsupportedInput(
-                            "'into duration' does not support this string input".into(),
-                            span,
-                        ),
-                    }
-                }
-            } else {
-                match string_to_duration(val, span, *value_span) {
-                    Ok(val) => Value::Duration { val, span },
-                    Err(error) => Value::Error { error },
-                }
-            }
-        }
+        } => match string_to_duration(val, span, *value_span) {
+            Ok(val) => Value::Duration { val, span },
+            Err(error) => Value::Error { error },
+        },
         _ => Value::Error {
             error: ShellError::UnsupportedInput(
                 "'into duration' does not support this input".into(),
@@ -503,110 +204,102 @@ mod test {
 
     #[test]
     fn turns_ns_to_duration() {
-        let span = Span::new(0, 2);
+        let span = Span::test_data();
         let word = Value::test_string("3ns");
         let expected = Value::Duration { val: 3, span };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_us_to_duration() {
-        let span = Span::new(0, 2);
+        let span = Span::test_data();
         let word = Value::test_string("4us");
         let expected = Value::Duration {
             val: 4 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_ms_to_duration() {
-        let span = Span::new(0, 2);
+        let span = Span::test_data();
         let word = Value::test_string("5ms");
         let expected = Value::Duration {
             val: 5 * 1000 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_sec_to_duration() {
-        let span = Span::new(0, 3);
+        let span = Span::test_data();
         let word = Value::test_string("1sec");
         let expected = Value::Duration {
             val: 1000 * 1000 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_min_to_duration() {
-        let span = Span::new(0, 3);
+        let span = Span::test_data();
         let word = Value::test_string("7min");
         let expected = Value::Duration {
             val: 7 * 60 * 1000 * 1000 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_hr_to_duration() {
-        let span = Span::new(0, 3);
+        let span = Span::test_data();
         let word = Value::test_string("42hr");
         let expected = Value::Duration {
             val: 42 * 60 * 60 * 1000 * 1000 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_day_to_duration() {
-        let span = Span::new(0, 5);
+        let span = Span::test_data();
         let word = Value::test_string("123day");
         let expected = Value::Duration {
             val: 123 * 24 * 60 * 60 * 1000 * 1000 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_wk_to_duration() {
-        let span = Span::new(0, 2);
+        let span = Span::test_data();
         let word = Value::test_string("3wk");
         let expected = Value::Duration {
             val: 3 * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000,
             span,
         };
-        let convert_duration = None;
 
-        let actual = action(&word, &convert_duration, 2, span);
+        let actual = action(&word, span);
         assert_eq!(actual, expected);
     }
 }

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

@@ -1,9 +1,8 @@
-use crate::input_handler::{operate, CellPathOnlyArgs};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 
 #[derive(Clone)]
@@ -16,16 +15,10 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into filesize")
-            .input_output_types(vec![
-                (Type::Int, Type::Filesize),
-                (Type::Number, Type::Filesize),
-                (Type::String, Type::Filesize),
-                (Type::Filesize, Type::Filesize),
-            ])
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "column paths to convert to filesize (for table input)",
             )
             .category(Category::Conversions)
     }
@@ -35,7 +28,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "number", "bytes"]
+        vec!["convert", "number", "size", "bytes"]
     }
 
     fn run(
@@ -45,9 +38,7 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-        let args = CellPathOnlyArgs::from(cell_paths);
-        operate(action, args, input, call.head, engine_state.ctrlc.clone())
+        into_filesize(engine_state, stack, call, input)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -93,7 +84,37 @@ impl Command for SubCommand {
     }
 }
 
-pub fn action(input: &Value, _args: &CellPathOnlyArgs, span: Span) -> Value {
+fn into_filesize(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+
+    input.map(
+        move |v| {
+            if column_paths.is_empty() {
+                action(&v, head)
+            } else {
+                let mut ret = v;
+                for path in &column_paths {
+                    let r =
+                        ret.update_cell_path(&path.members, Box::new(move |old| action(old, head)));
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+pub fn action(input: &Value, span: Span) -> Value {
     if let Ok(value_span) = input.span() {
         match input {
             Value::Filesize { .. } => input.clone(),

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

@@ -1,23 +1,16 @@
-use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
 };
 
 struct Arguments {
-    radix: u32,
-    cell_paths: Option<Vec<CellPath>>,
+    radix: Option<Value>,
+    column_paths: Vec<CellPath>,
     little_endian: bool,
 }
 
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
-    }
-}
-
 #[derive(Clone)]
 pub struct SubCommand;
 
@@ -28,22 +21,12 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into int")
-            .input_output_types(vec![
-                (Type::String, Type::Int),
-                (Type::Number, Type::Int),
-                (Type::Bool, Type::Int),
-                // Unix timestamp in seconds
-                (Type::Date, Type::Int),
-                // TODO: Users should do this by dividing a Filesize by a Filesize explicitly
-                (Type::Filesize, Type::Int),
-            ])
-            .vectorizes_over_list(true)
             .named("radix", SyntaxShape::Number, "radix of integer", Some('r'))
             .switch("little-endian", "use little-endian byte decoding", None)
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "column paths to convert to int (for table input)",
             )
             .category(Category::Conversions)
     }
@@ -63,36 +46,14 @@ impl Command for SubCommand {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let cell_paths = call.rest(engine_state, stack, 0)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
-
-        let radix = call.get_flag::<Value>(engine_state, stack, "radix")?;
-        let radix: u32 = match radix {
-            Some(Value::Int { val, span }) => {
-                if !(2..=36).contains(&val) {
-                    return Err(ShellError::UnsupportedInput(
-                        "Radix must lie in the range [2, 36]".to_string(),
-                        span,
-                    ));
-                }
-                val as u32
-            }
-            Some(_) => 10,
-            None => 10,
-        };
-        let args = Arguments {
-            radix,
-            little_endian: call.has_flag("little-endian"),
-            cell_paths,
-        };
-        operate(action, args, input, call.head, engine_state.ctrlc.clone())
+        into_int(engine_state, stack, call, input)
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
                 description: "Convert string to integer in table",
-                example: "[[num]; ['-5'] [4] [1.5]] | into int num",
+                example: "echo [[num]; ['-5'] [4] [1.5]] | into int num",
                 result: None,
             },
             Example {
@@ -113,7 +74,10 @@ impl Command for SubCommand {
             Example {
                 description: "Convert file size to integer",
                 example: "4KB | into int",
-                result: Some(Value::int(4000, Span::test_data())),
+                result: Some(Value::Int {
+                    val: 4000,
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "Convert bool to integer",
@@ -157,9 +121,59 @@ impl Command for SubCommand {
     }
 }
 
-fn action(input: &Value, args: &Arguments, span: Span) -> Value {
-    let radix = args.radix;
-    let little_endian = args.little_endian;
+fn into_int(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let head = call.head;
+
+    let options = Arguments {
+        radix: call.get_flag(engine_state, stack, "radix")?,
+        little_endian: call.has_flag("little-endian"),
+        column_paths: call.rest(engine_state, stack, 0)?,
+    };
+
+    let radix: u32 = match options.radix {
+        Some(Value::Int { val, .. }) => val as u32,
+        Some(_) => 10,
+        None => 10,
+    };
+
+    if let Some(val) = &options.radix {
+        if !(2..=36).contains(&radix) {
+            return Err(ShellError::UnsupportedInput(
+                "Radix must lie in the range [2, 36]".to_string(),
+                val.span()?,
+            ));
+        }
+    }
+
+    input.map(
+        move |v| {
+            if options.column_paths.is_empty() {
+                action(&v, head, radix, options.little_endian)
+            } else {
+                let mut ret = v;
+                for path in &options.column_paths {
+                    let r = ret.update_cell_path(
+                        &path.members,
+                        Box::new(move |old| action(old, head, radix, options.little_endian)),
+                    );
+                    if let Err(error) = r {
+                        return Value::Error { error };
+                    }
+                }
+
+                ret
+            }
+        },
+        engine_state.ctrlc.clone(),
+    )
+}
+
+pub fn action(input: &Value, span: Span, radix: u32, little_endian: bool) -> Value {
     match input {
         Value::Int { val: _, .. } => {
             if radix == 10 {
@@ -230,14 +244,20 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
                 }
                 val.resize(8, 0);
 
-                Value::int(LittleEndian::read_i64(&val), *span)
+                Value::Int {
+                    val: LittleEndian::read_i64(&val),
+                    span: *span,
+                }
             } else {
                 while val.len() < 8 {
                     val.insert(0, 0);
                 }
                 val.resize(8, 0);
 
-                Value::int(BigEndian::read_i64(&val), *span)
+                Value::Int {
+                    val: BigEndian::read_i64(&val),
+                    span: *span,
+                }
             }
         }
         _ => Value::Error {
@@ -260,13 +280,13 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             // octal
             {
                 match int_from_string(val, head) {
-                    Ok(x) => return Value::int(x, head),
+                    Ok(x) => return Value::Int { val: x, span: head },
                     Err(e) => return Value::Error { error: e },
                 }
             } else if val.starts_with("00") {
                 // It's a padded string
                 match i64::from_str_radix(val, radix) {
-                    Ok(n) => return Value::int(n, head),
+                    Ok(n) => return Value::Int { val: n, span: head },
                     Err(e) => {
                         return Value::Error {
                             error: ShellError::CantConvert(
@@ -291,7 +311,7 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
         }
     };
     match i64::from_str_radix(i.trim(), radix) {
-        Ok(n) => Value::int(n, head),
+        Ok(n) => Value::Int { val: n, span: head },
         Err(_reason) => Value::Error {
             error: ShellError::CantConvert("string".to_string(), "int".to_string(), head, None),
         },
@@ -381,45 +401,21 @@ mod test {
         let word = Value::test_string("10");
         let expected = Value::test_int(10);
 
-        let actual = action(
-            &word,
-            &Arguments {
-                radix: 10,
-                cell_paths: None,
-                little_endian: false,
-            },
-            Span::test_data(),
-        );
+        let actual = action(&word, Span::test_data(), 10, false);
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn turns_binary_to_integer() {
         let s = Value::test_string("0b101");
-        let actual = action(
-            &s,
-            &Arguments {
-                radix: 10,
-                cell_paths: None,
-                little_endian: false,
-            },
-            Span::test_data(),
-        );
+        let actual = action(&s, Span::test_data(), 10, false);
         assert_eq!(actual, Value::test_int(5));
     }
 
     #[test]
     fn turns_hex_to_integer() {
         let s = Value::test_string("0xFF");
-        let actual = action(
-            &s,
-            &Arguments {
-                radix: 16,
-                cell_paths: None,
-                little_endian: false,
-            },
-            Span::test_data(),
-        );
+        let actual = action(&s, Span::test_data(), 16, false);
         assert_eq!(actual, Value::test_int(255));
     }
 
@@ -427,15 +423,7 @@ mod test {
     fn communicates_parsing_error_given_an_invalid_integerlike_string() {
         let integer_str = Value::test_string("36anra");
 
-        let actual = action(
-            &integer_str,
-            &Arguments {
-                radix: 10,
-                cell_paths: None,
-                little_endian: false,
-            },
-            Span::test_data(),
-        );
+        let actual = action(&integer_str, Span::test_data(), 10, false);
 
         assert_eq!(actual.get_type(), Error)
     }

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

@@ -6,7 +6,6 @@ mod decimal;
 mod duration;
 mod filesize;
 mod int;
-mod record;
 mod string;
 
 pub use self::bool::SubCommand as IntoBool;
@@ -17,5 +16,4 @@ pub use datetime::SubCommand as IntoDatetime;
 pub use decimal::SubCommand as IntoDecimal;
 pub use duration::SubCommand as IntoDuration;
 pub use int::SubCommand as IntoInt;
-pub use record::SubCommand as IntoRecord;
 pub use string::SubCommand as IntoString;

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

@@ -1,291 +0,0 @@
-use chrono::{DateTime, Datelike, FixedOffset, Timelike};
-use nu_protocol::format_duration_as_timeperiod;
-use nu_protocol::{
-    ast::Call,
-    engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type, Value,
-};
-#[derive(Clone)]
-pub struct SubCommand;
-
-impl Command for SubCommand {
-    fn name(&self) -> &str {
-        "into record"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("into record")
-            .input_output_types(vec![
-                (Type::Date, Type::Record(vec![])),
-                (Type::Duration, Type::Record(vec![])),
-                (Type::List(Box::new(Type::Any)), Type::Record(vec![])),
-                (Type::Range, Type::Record(vec![])),
-                (Type::Record(vec![]), Type::Record(vec![])),
-                (Type::Table(vec![]), Type::Record(vec![])),
-            ])
-            .category(Category::Conversions)
-    }
-
-    fn usage(&self) -> &str {
-        "Convert value to record"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["convert"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        _stack: &mut Stack,
-        call: &Call,
-        input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        into_record(engine_state, call, input)
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        let span = Span::test_data();
-        vec![
-            Example {
-                description: "Convert from one row table to record",
-                example: "[[value]; [false]] | into record",
-                result: Some(Value::Record {
-                    cols: vec!["value".to_string()],
-                    vals: vec![Value::boolean(false, span)],
-                    span,
-                }),
-            },
-            Example {
-                description: "Convert from list to record",
-                example: "[1 2 3] | into record",
-                result: Some(Value::Record {
-                    cols: vec!["0".to_string(), "1".to_string(), "2".to_string()],
-                    vals: vec![
-                        Value::Int { val: 1, span },
-                        Value::Int { val: 2, span },
-                        Value::Int { val: 3, span },
-                    ],
-                    span,
-                }),
-            },
-            Example {
-                description: "Convert from range to record",
-                example: "0..2 | into record",
-                result: Some(Value::Record {
-                    cols: vec!["0".to_string(), "1".to_string(), "2".to_string()],
-                    vals: vec![
-                        Value::Int { val: 0, span },
-                        Value::Int { val: 1, span },
-                        Value::Int { val: 2, span },
-                    ],
-                    span,
-                }),
-            },
-            Example {
-                description: "convert duration to record",
-                example: "-500day | into record",
-                result: Some(Value::Record {
-                    cols: vec![
-                        "year".into(),
-                        "month".into(),
-                        "week".into(),
-                        "day".into(),
-                        "sign".into(),
-                    ],
-                    vals: vec![
-                        Value::Int { val: 1, span },
-                        Value::Int { val: 4, span },
-                        Value::Int { val: 2, span },
-                        Value::Int { val: 1, span },
-                        Value::String {
-                            val: "-".into(),
-                            span,
-                        },
-                    ],
-                    span,
-                }),
-            },
-            Example {
-                description: "convert record to record",
-                example: "{a: 1, b: 2} | into record",
-                result: Some(Value::Record {
-                    cols: vec!["a".to_string(), "b".to_string()],
-                    vals: vec![Value::Int { val: 1, span }, Value::Int { val: 2, span }],
-                    span,
-                }),
-            },
-            Example {
-                description: "convert date to record",
-                example: "2020-04-12T22:10:57+02:00 | into record",
-                result: Some(Value::Record {
-                    cols: vec![
-                        "year".into(),
-                        "month".into(),
-                        "day".into(),
-                        "hour".into(),
-                        "minute".into(),
-                        "second".into(),
-                        "timezone".into(),
-                    ],
-                    vals: vec![
-                        Value::Int { val: 2020, span },
-                        Value::Int { val: 4, span },
-                        Value::Int { val: 12, span },
-                        Value::Int { val: 22, span },
-                        Value::Int { val: 10, span },
-                        Value::Int { val: 57, span },
-                        Value::String {
-                            val: "+02:00".to_string(),
-                            span,
-                        },
-                    ],
-                    span,
-                }),
-            },
-        ]
-    }
-}
-
-fn into_record(
-    engine_state: &EngineState,
-    call: &Call,
-    input: PipelineData,
-) -> Result<PipelineData, ShellError> {
-    let input = input.into_value(call.head);
-    let input_type = input.get_type();
-    let res = match input {
-        Value::Date { val, span } => parse_date_into_record(Ok(val), span),
-        Value::Duration { val, span } => parse_duration_into_record(val, span),
-        Value::List { mut vals, span } => match input_type {
-            Type::Table(..) if vals.len() == 1 => vals.pop().expect("already checked 1 item"),
-            _ => {
-                let mut cols = vec![];
-                let mut values = vec![];
-                for (idx, val) in vals.into_iter().enumerate() {
-                    cols.push(format!("{idx}"));
-                    values.push(val);
-                }
-                Value::Record {
-                    cols,
-                    vals: values,
-                    span,
-                }
-            }
-        },
-        Value::Range { val, span } => {
-            let mut cols = vec![];
-            let mut vals = vec![];
-            for (idx, val) in val.into_range_iter(engine_state.ctrlc.clone())?.enumerate() {
-                cols.push(format!("{idx}"));
-                vals.push(val);
-            }
-            Value::Record { cols, vals, span }
-        }
-        Value::Record { cols, vals, span } => Value::Record { cols, vals, span },
-        other => {
-            return Err(ShellError::UnsupportedInput(
-                "'into record' does not support this input".into(),
-                other.span().unwrap_or(call.head),
-            ))
-        }
-    };
-    Ok(res.into_pipeline_data())
-}
-
-fn parse_date_into_record(date: Result<DateTime<FixedOffset>, Value>, span: Span) -> Value {
-    let cols = vec![
-        "year".into(),
-        "month".into(),
-        "day".into(),
-        "hour".into(),
-        "minute".into(),
-        "second".into(),
-        "timezone".into(),
-    ];
-    match date {
-        Ok(x) => {
-            let vals = vec![
-                Value::Int {
-                    val: x.year() as i64,
-                    span,
-                },
-                Value::Int {
-                    val: x.month() as i64,
-                    span,
-                },
-                Value::Int {
-                    val: x.day() as i64,
-                    span,
-                },
-                Value::Int {
-                    val: x.hour() as i64,
-                    span,
-                },
-                Value::Int {
-                    val: x.minute() as i64,
-                    span,
-                },
-                Value::Int {
-                    val: x.second() as i64,
-                    span,
-                },
-                Value::String {
-                    val: x.offset().to_string(),
-                    span,
-                },
-            ];
-            Value::Record { cols, vals, span }
-        }
-        Err(e) => e,
-    }
-}
-
-fn parse_duration_into_record(duration: i64, span: Span) -> Value {
-    let (sign, periods) = format_duration_as_timeperiod(duration);
-
-    let mut cols = vec![];
-    let mut vals = vec![];
-    for p in periods {
-        let num_with_unit = p.to_text().to_string();
-        let split = num_with_unit.split(' ').collect::<Vec<&str>>();
-        cols.push(match split[1] {
-            "ns" => "nanosecond".into(),
-            "µs" => "microsecond".into(),
-            "ms" => "millisecond".into(),
-            "sec" => "second".into(),
-            "min" => "minute".into(),
-            "hr" => "hour".into(),
-            "day" => "day".into(),
-            "wk" => "week".into(),
-            "month" => "month".into(),
-            "yr" => "year".into(),
-            _ => "unknown".into(),
-        });
-
-        vals.push(Value::Int {
-            val: split[0].parse::<i64>().unwrap_or(0),
-            span,
-        });
-    }
-
-    cols.push("sign".into());
-    vals.push(Value::String {
-        val: if sign == -1 { "-".into() } else { "+".into() },
-        span,
-    });
-
-    Value::Record { cols, vals, span }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_examples() {
-        use crate::test_examples;
-
-        test_examples(SubCommand {})
-    }
-}

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

@@ -1,26 +1,12 @@
-use crate::input_handler::{operate, CmdArgument};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
     into_code, Category, Config, Example, IntoPipelineData, PipelineData, ShellError, Signature,
-    Span, SyntaxShape, Type, Value,
+    Span, SyntaxShape, Value,
 };
-use nu_utils::get_system_locale;
-use num_format::ToFormattedString;
 
-struct Arguments {
-    decimals_value: Option<i64>,
-    decimals: bool,
-    cell_paths: Option<Vec<CellPath>>,
-    config: Config,
-}
-
-impl CmdArgument for Arguments {
-    fn take_cell_paths(&mut self) -> Option<Vec<CellPath>> {
-        self.cell_paths.take()
-    }
-}
+// TODO num_format::SystemLocale once platform-specific dependencies are stable (see Cargo.toml)
 
 #[derive(Clone)]
 pub struct SubCommand;
@@ -32,20 +18,11 @@ impl Command for SubCommand {
 
     fn signature(&self) -> Signature {
         Signature::build("into string")
-            .input_output_types(vec![
-                (Type::Binary, Type::String),
-                (Type::Int, Type::String),
-                (Type::Number, Type::String),
-                (Type::String, Type::String),
-                (Type::Bool, Type::String),
-                (Type::Filesize, Type::String),
-                (Type::Date, Type::String),
-            ])
-            .allow_variants_without_examples(true) // https://github.com/nushell/nushell/issues/7032
+            // FIXME - need to support column paths
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
-                "for a data structure input, convert data at the given cell paths",
+                "column paths to convert to string (for table input)",
             )
             .named(
                 "decimals",
@@ -61,7 +38,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "text"]
+        vec!["convert", "str", "text"]
     }
 
     fn run(
@@ -79,22 +56,34 @@ impl Command for SubCommand {
             Example {
                 description: "convert integer to string and append three decimal places",
                 example: "5 | into string -d 3",
-                result: Some(Value::string("5.000", Span::test_data())),
+                result: Some(Value::String {
+                    val: "5.000".to_string(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "convert decimal to string and round to nearest integer",
                 example: "1.7 | into string -d 0",
-                result: Some(Value::string("2", Span::test_data())),
+                result: Some(Value::String {
+                    val: "2".to_string(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "convert decimal to string",
                 example: "1.7 | into string -d 1",
-                result: Some(Value::string("1.7", Span::test_data())),
+                result: Some(Value::String {
+                    val: "1.7".to_string(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "convert decimal to string and limit to 2 decimals",
                 example: "1.734 | into string -d 2",
-                result: Some(Value::string("1.73", Span::test_data())),
+                result: Some(Value::String {
+                    val: "1.73".to_string(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "try to convert decimal to string and provide negative decimal points",
@@ -111,24 +100,32 @@ impl Command for SubCommand {
             Example {
                 description: "convert decimal to string",
                 example: "4.3 | into string",
-                result: Some(Value::string("4.3", Span::test_data())),
+                result: Some(Value::String {
+                    val: "4.3".to_string(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "convert string to string",
                 example: "'1234' | into string",
-                result: Some(Value::string("1234", Span::test_data())),
+                result: Some(Value::String {
+                    val: "1234".to_string(),
+                    span: Span::test_data(),
+                }),
             },
             Example {
                 description: "convert boolean to string",
                 example: "true | into string",
-                result: Some(Value::string("true", Span::test_data())),
+                result: Some(Value::String {
+                    val: "true".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "convert date to string",
+                example: "date now | into string",
+                result: None,
             },
-            // TODO: This should work but does not; see https://github.com/nushell/nushell/issues/7032
-            // Example {
-            //     description: "convert date to string",
-            //     example: "'2020-10-10 10:00:00 +02:00' | into datetime | into string",
-            //     result: Some(Value::test_string("Sat Oct 10 10:00:00 2020")),
-            // },
             Example {
                 description: "convert filepath to string",
                 example: "ls Cargo.toml | get name | into string",
@@ -136,8 +133,8 @@ impl Command for SubCommand {
             },
             Example {
                 description: "convert filesize to string",
-                example: "1KiB | into string",
-                result: Some(Value::test_string("1,024 B")),
+                example: "ls Cargo.toml | get size | into string",
+                result: None,
             },
         ]
     }
@@ -152,6 +149,9 @@ fn string_helper(
     let decimals = call.has_flag("decimals");
     let head = call.head;
     let decimals_value: Option<i64> = call.get_flag(engine_state, stack, "decimals")?;
+    let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+    let config = engine_state.get_config().clone();
+
     if let Some(decimal_val) = decimals_value {
         if decimals && decimal_val.is_negative() {
             return Err(ShellError::UnsupportedInput(
@@ -160,15 +160,6 @@ fn string_helper(
             ));
         }
     }
-    let cell_paths = call.rest(engine_state, stack, 0)?;
-    let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
-    let config = engine_state.get_config().clone();
-    let args = Arguments {
-        decimals_value,
-        decimals,
-        cell_paths,
-        config,
-    };
 
     match input {
         PipelineData::ExternalStream { stdout: None, .. } => Ok(Value::String {
@@ -188,18 +179,58 @@ fn string_helper(
             }
             .into_pipeline_data())
         }
-        _ => operate(action, args, input, head, engine_state.ctrlc.clone()),
+        _ => input.map(
+            move |v| {
+                if column_paths.is_empty() {
+                    action(&v, head, decimals, decimals_value, false, &config)
+                } else {
+                    let mut ret = v;
+                    for path in &column_paths {
+                        let config = config.clone();
+                        let r = ret.update_cell_path(
+                            &path.members,
+                            Box::new(move |old| {
+                                action(old, head, decimals, decimals_value, false, &config)
+                            }),
+                        );
+                        if let Err(error) = r {
+                            return Value::Error { error };
+                        }
+                    }
+
+                    ret
+                }
+            },
+            engine_state.ctrlc.clone(),
+        ),
     }
 }
 
-fn action(input: &Value, args: &Arguments, span: Span) -> Value {
-    let decimals = args.decimals;
-    let digits = args.decimals_value;
-    let config = &args.config;
+pub fn action(
+    input: &Value,
+    span: Span,
+    decimals: bool,
+    digits: Option<i64>,
+    group_digits: bool,
+    config: &Config,
+) -> Value {
     match input {
         Value::Int { val, .. } => {
-            let decimal_value = digits.unwrap_or(0) as usize;
-            let res = format_int(*val, false, decimal_value);
+            let res = if group_digits {
+                format_int(*val) // int.to_formatted_string(*locale)
+            } else if let Some(dig) = digits {
+                let mut val_with_trailing_zeroes = val.to_string();
+                if dig != 0 {
+                    val_with_trailing_zeroes.push('.');
+                }
+                for _ in 0..dig {
+                    val_with_trailing_zeroes.push('0');
+                }
+                val_with_trailing_zeroes
+            } else {
+                val.to_string()
+            };
+
             Value::String { val: res, span }
         }
         Value::Float { val, .. } => {
@@ -274,29 +305,21 @@ fn action(input: &Value, args: &Arguments, span: Span) -> Value {
         },
     }
 }
+fn format_int(int: i64) -> String {
+    int.to_string()
 
-fn format_int(int: i64, group_digits: bool, decimals: usize) -> String {
-    let locale = get_system_locale();
-
-    let str = if group_digits {
-        int.to_formatted_string(&locale)
-    } else {
-        int.to_string()
-    };
-
-    if decimals > 0 {
-        let decimal_point = locale.decimal();
-
-        format!(
-            "{}{decimal_point}{dummy:0<decimals$}",
-            str,
-            decimal_point = decimal_point,
-            dummy = "",
-            decimals = decimals
-        )
-    } else {
-        str
-    }
+    // TODO once platform-specific dependencies are stable (see Cargo.toml)
+    // #[cfg(windows)]
+    // {
+    //     int.to_formatted_string(&Locale::en)
+    // }
+    // #[cfg(not(windows))]
+    // {
+    //     match SystemLocale::default() {
+    //         Ok(locale) => int.to_formatted_string(&locale),
+    //         Err(_) => int.to_formatted_string(&Locale::en),
+    //     }
+    // }
 }
 
 #[cfg(test)]

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

@@ -1,6 +1,6 @@
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, Span, SyntaxShape, Type, Value};
+use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape};
 
 #[derive(Clone)]
 pub struct Alias;
@@ -16,7 +16,6 @@ impl Command for Alias {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("alias")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
             .required("name", SyntaxShape::String, "name of the alias")
             .required(
                 "initial_value",
@@ -28,7 +27,7 @@ impl Command for Alias {
 
     fn extra_usage(&self) -> &str {
         r#"This command is a parser keyword. For details, check:
-  https://www.nushell.sh/book/thinking_in_nu.html"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
@@ -43,24 +42,17 @@ impl Command for Alias {
         &self,
         _engine_state: &EngineState,
         _stack: &mut Stack,
-        _call: &Call,
+        call: &Call,
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Ok(PipelineData::empty())
+        Ok(PipelineData::new(call.head))
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Alias ll to ls -l",
-                example: "alias ll = ls -l",
-                result: Some(Value::nothing(Span::test_data())),
-            },
-            Example {
-                description: "Make an alias that makes a list of all custom commands",
-                example: "alias customs = ($nu.scope.commands | where is_custom | get command)",
-                result: Some(Value::nothing(Span::test_data())),
-            },
-        ]
+        vec![Example {
+            description: "Alias ll to ls -l",
+            example: "alias ll = ls -l",
+            result: None,
+        }]
     }
 }

crates/nu-command/src/core_commands/ast.rs

@@ -1,78 +0,0 @@
-use nu_engine::CallExt;
-use nu_parser::parse;
-use nu_protocol::{
-    ast::Call,
-    engine::{Command, EngineState, Stack, StateWorkingSet},
-    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Type,
-    Value,
-};
-
-#[derive(Clone)]
-pub struct Ast;
-
-impl Command for Ast {
-    fn name(&self) -> &str {
-        "ast"
-    }
-
-    fn usage(&self) -> &str {
-        "Print the abstract syntax tree (ast) for a pipeline."
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("ast")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
-            .required(
-                "pipeline",
-                SyntaxShape::String,
-                "the pipeline to print the ast for",
-            )
-            .category(Category::Core)
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        let pipeline: Spanned<String> = call.req(engine_state, stack, 0)?;
-        let mut working_set = StateWorkingSet::new(engine_state);
-
-        let (output, err) = parse(&mut working_set, None, pipeline.item.as_bytes(), false, &[]);
-        eprintln!("output: {:#?}\nerror: {:#?}", output, err);
-
-        Ok(PipelineData::empty())
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                description: "Print the ast of a string",
-                example: "ast 'hello'",
-                result: Some(Value::nothing(Span::test_data())),
-            },
-            Example {
-                description: "Print the ast of a pipeline",
-                example: "ast 'ls | where name =~ README'",
-                result: Some(Value::nothing(Span::test_data())),
-            },
-            Example {
-                description: "Print the ast of a pipeline with an error",
-                example: "ast 'for x in 1..10 { echo $x '",
-                result: Some(Value::nothing(Span::test_data())),
-            },
-        ]
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn test_examples() {
-        use super::Ast;
-        use crate::test_examples;
-        test_examples(Ast {})
-    }
-}

crates/nu-command/src/core_commands/break_.rs

@@ -1,49 +0,0 @@
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Type};
-
-#[derive(Clone)]
-pub struct Break;
-
-impl Command for Break {
-    fn name(&self) -> &str {
-        "break"
-    }
-
-    fn usage(&self) -> &str {
-        "Break a loop"
-    }
-
-    fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("break")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
-            .category(Category::Core)
-    }
-
-    fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check:
-  https://www.nushell.sh/book/thinking_in_nu.html"#
-    }
-
-    fn is_parser_keyword(&self) -> bool {
-        true
-    }
-
-    fn run(
-        &self,
-        _engine_state: &EngineState,
-        _stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Err(ShellError::Break(call.head))
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Break out of a loop",
-            example: r#"loop { break }"#,
-            result: None,
-        }]
-    }
-}

crates/nu-command/src/core_commands/commandline.rs

@@ -1,85 +0,0 @@
-use nu_engine::CallExt;
-use nu_protocol::ast::Call;
-use nu_protocol::engine::ReplOperation;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::Category;
-use nu_protocol::IntoPipelineData;
-use nu_protocol::{PipelineData, ShellError, Signature, SyntaxShape, Type, Value};
-
-#[derive(Clone)]
-pub struct Commandline;
-
-impl Command for Commandline {
-    fn name(&self) -> &str {
-        "commandline"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build("commandline")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
-            .switch(
-                "append",
-                "appends the string to the end of the buffer",
-                Some('a'),
-            )
-            .switch(
-                "insert",
-                "inserts the string into the buffer at the cursor position",
-                Some('i'),
-            )
-            .switch(
-                "replace",
-                "replaces the current contents of the buffer (default)",
-                Some('r'),
-            )
-            .optional(
-                "cmd",
-                SyntaxShape::String,
-                "the string to perform the operation with",
-            )
-            .category(Category::Core)
-    }
-
-    fn usage(&self) -> &str {
-        "View or modify the current command line input buffer"
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["repl", "interactive"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        if let Some(cmd) = call.opt::<Value>(engine_state, stack, 0)? {
-            let mut ops = engine_state
-                .repl_operation_queue
-                .lock()
-                .expect("repl op queue mutex");
-            ops.push_back(if call.has_flag("append") {
-                ReplOperation::Append(cmd.as_string()?)
-            } else if call.has_flag("insert") {
-                ReplOperation::Insert(cmd.as_string()?)
-            } else {
-                ReplOperation::Replace(cmd.as_string()?)
-            });
-            Ok(Value::Nothing { span: call.head }.into_pipeline_data())
-        } else if let Some(ref cmd) = *engine_state
-            .repl_buffer_state
-            .lock()
-            .expect("repl buffer state mutex")
-        {
-            Ok(Value::String {
-                val: cmd.clone(),
-                span: call.head,
-            }
-            .into_pipeline_data())
-        } else {
-            Ok(Value::Nothing { span: call.head }.into_pipeline_data())
-        }
-    }
-}

crates/nu-command/src/core_commands/continue_.rs

@@ -1,49 +0,0 @@
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Type};
-
-#[derive(Clone)]
-pub struct Continue;
-
-impl Command for Continue {
-    fn name(&self) -> &str {
-        "continue"
-    }
-
-    fn usage(&self) -> &str {
-        "Continue a loop from the next iteration"
-    }
-
-    fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("continue")
-            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
-            .category(Category::Core)
-    }
-
-    fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check:
-  https://www.nushell.sh/book/thinking_in_nu.html"#
-    }
-
-    fn is_parser_keyword(&self) -> bool {
-        true
-    }
-
-    fn run(
-        &self,
-        _engine_state: &EngineState,
-        _stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        Err(ShellError::Continue(call.head))
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Continue a loop from the next iteration",
-            example: r#"for i in 1..10 { if $i == 5 { continue }; print $i }"#,
-            result: None,
-        }]
-    }
-}