bump to 0.66 (#6137)

* Allow multiple patterns in ls command

* Run formatter

* Comply with style

* Fix format error

.cargo/config.toml

@@ -1,6 +1,7 @@
-# increase the default windows stack size
 [target.x86_64-pc-windows-msvc]
-rustflags = ["-C", "link-args=-stack:10000000"]
+# increase the default windows stack size
+# statically link the CRT so users don't have to install it
+rustflags = ["-C", "link-args=-stack:10000000", "-C", "target-feature=+crt-static"]
 
 # keeping this but commentting out in case we need them in the future
 

.github/pull_request_template.md

@@ -4,6 +4,12 @@
 
 # Tests
 
+Make sure you've done the following:
+
+- [ ] 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)

.github/workflows/ci.yml

@@ -80,9 +80,11 @@ jobs:
           toolchain: ${{ matrix.rust }}
           override: true
 
-      - uses: Swatinem/rust-cache@v1
+      # Temporarily disabled; the cache was getting huge (2.6GB compressed) on Windows and causing issues.
-        with:
+      # TODO: investigate why the cache was so big
-          key: ${{ matrix.style }}v3 # increment this to bust the cache if needed
+      # - uses: Swatinem/rust-cache@v1
+      #   with:
+      #     key: ${{ matrix.style }}v3 # increment this to bust the cache if needed
 
       - name: Tests
         uses: actions-rs/cargo@v1
@@ -133,10 +135,7 @@ jobs:
       - run: python -m pip install tox
 
       - name: Install virtualenv
-        run: |
+        run: git clone https://github.com/pypa/virtualenv.git          
-          git clone https://github.com/kubouch/virtualenv.git && \
-          cd virtualenv && \
-          git checkout engine-q-update
         shell: bash
 
       - name: Test Nushell in virtualenv

.github/workflows/release-pkg.nu

@@ -0,0 +1,155 @@
+#!/usr/bin/env nu
+
+# Created: 2022/05/26 19:05:20
+# Description:
+#   A script to do the github release task, need nushell to be installed.
+# REF:
+#   1. https://github.com/volks73/cargo-wix
+
+# The main binary file to be released
+let bin = 'nu'
+let os = $env.OS
+let target = $env.TARGET
+# Repo source dir like `/home/runner/work/nushell/nushell`
+let src = $env.GITHUB_WORKSPACE
+let flags = $env.TARGET_RUSTFLAGS
+let dist = $'($env.GITHUB_WORKSPACE)/output'
+let version = (open Cargo.toml | get package.version)
+
+# $env
+
+$'(char nl)Packaging ($bin) v($version) for ($target) in ($src)...'; hr-line -b
+if not ('Cargo.lock' | path exists) { cargo generate-lockfile }
+
+$'Start building ($bin)...'; hr-line
+
+# ----------------------------------------------------------------------------
+# Build for Ubuntu and macOS
+# ----------------------------------------------------------------------------
+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' {
+        sudo apt-get install gcc-aarch64-linux-gnu -y
+        let-env CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 'aarch64-linux-gnu-gcc'
+        cargo-build-nu $flags
+    } else if $target == 'armv7-unknown-linux-gnueabihf' {
+        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 {
+        # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
+        # Actually just for x86_64-unknown-linux-musl target
+        sudo apt install musl-tools -y
+        cargo-build-nu $flags
+    }
+}
+
+# ----------------------------------------------------------------------------
+# Build for Windows without static-link-openssl feature
+# ----------------------------------------------------------------------------
+if $os in ['windows-latest'] {
+    if ($flags | str trim | empty?) {
+        cargo build --release --all --target $target --features=extra
+    } else {
+        cargo build --release --all --target $target --features=extra $flags
+    }
+}
+
+# ----------------------------------------------------------------------------
+# Prepare for the release archive
+# ----------------------------------------------------------------------------
+let suffix = if $os == 'windows-latest' { '.exe' }
+# nu, nu_plugin_* were all included
+let executable = $'target/($target)/release/($bin)*($suffix)'
+$'Current executable file: ($executable)'
+
+cd $src; mkdir $dist;
+rm -rf $'target/($target)/release/*.d' $'target/($target)/release/nu_pretty_hex*'
+$'(char nl)All executable files:'; hr-line
+ls -f $executable
+
+$'(char nl)Copying release files...'; hr-line
+cp -v README.release.txt $'($dist)/README.txt'
+[LICENSE $executable] | each {|it| cp -rv $it $dist } | flatten
+
+$'(char nl)Check binary release version detail:'; hr-line
+let ver = if $os == 'windows-latest' {
+    (do -i { ./output/nu.exe -c 'version' }) | str collect
+} else {
+    (do -i { ./output/nu -c 'version' }) | str collect
+}
+if ($ver | str trim | empty?) {
+    $'(ansi r)Incompatible nu binary...(ansi reset)'
+} else { $ver }
+
+# ----------------------------------------------------------------------------
+# 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 ['ubuntu-latest', 'macos-latest'] {
+
+    $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
+
+    let archive = $'($dist)/($bin)-($version)-($target).tar.gz'
+    tar czf $archive *
+    print $'archive: ---> ($archive)'; ls $archive
+    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-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
+    if (get-env _EXTRA_) == 'msi' {
+
+        let wixRelease = $'($src)/target/wix/($releaseStem).msi'
+        $'(char nl)Start creating Windows msi package...'
+        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.2
+        cargo wix --no-build --nocapture --package nu --output $wixRelease
+        echo $'::set-output name=archive::($wixRelease)'
+
+    } else {
+
+        $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
+        let archive = $'($dist)/($releaseStem).zip'
+        7z a $archive *
+        print $'archive: ---> ($archive)';
+        let pkg = (ls -f $archive | get name)
+        if not ($pkg | empty?) {
+            echo $'::set-output name=archive::($pkg | get 0)'
+        }
+    }
+}
+
+def 'cargo-build-nu' [ options: string ] {
+    if ($options | str trim | empty?) {
+        cargo build --release --all --target $target --features=extra,static-link-openssl
+    } else {
+        cargo build --release --all --target $target --features=extra,static-link-openssl $options
+    }
+}
+
+# Print a horizontal line marker
+def 'hr-line' [
+    --blank-line(-b): bool
+] {
+    print $'(ansi g)---------------------------------------------------------------------------->(ansi reset)'
+    if $blank-line { char nl }
+}
+
+# Get the specified env key's value or ''
+def 'get-env' [
+    key: string           # The key to get it's env value
+    default: string = ''  # The default value for an empty env
+] {
+    $env | get -i $key | default $default
+}

.github/workflows/release.yml

@@ -1,3 +1,7 @@
+#
+# REF:
+#   1. https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrixinclude
+#
 name: Create Release Draft
 
 on:
@@ -5,434 +9,89 @@ on:
   push:
     tags: ["[0-9]+.[0-9]+.[0-9]+*"]
 
+defaults:
+  run:
+    shell: bash
+
 jobs:
-  linux:
+  all:
-    name: Build Linux
+    name: All
-    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        - armv7-unknown-linux-gnueabihf
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-latest
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-latest
+          target_rustflags: ''
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-latest
+          target_rustflags: ''
+        - target: armv7-unknown-linux-gnueabihf
+          os: ubuntu-latest
+          target_rustflags: ''
+
+    runs-on: ${{matrix.os}}
+
     steps:
-      - name: Check out code
+    - uses: actions/checkout@v3.0.2
-        uses: actions/checkout@v2
+
-
+    - name: Install Rust Toolchain Components
-      - name: Install libxcb
+      uses: actions-rs/toolchain@v1.0.6
-        run: sudo apt-get install libxcb-composite0-dev
+      with:
-
+        override: true
-      - name: Set up cargo
+        profile: minimal
-        uses: actions-rs/toolchain@v1
+        toolchain: stable
-        with:
+        target: ${{ matrix.target }}
-          profile: minimal
+
-          toolchain: stable
+    - name: Setup Nushell
-          override: true
+      uses: hustcer/setup-nu@v1
-
+      with:
-      - name: Build
+        version: 0.63.0
-        uses: actions-rs/cargo@v1
+      env:
-        with:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          command: build
+
-          args: --release --all --features=extra,static-link-openssl
+    - name: Release Nu Binary
-
+      id: nu
-      # - name: Strip binaries (nu)
+      run: nu .github/workflows/release-pkg.nu
-      #   run: strip target/release/nu
+      env:
-
+        OS: ${{ matrix.os }}
-      # - name: Strip binaries (nu_plugin_inc)
+        REF: ${{ github.ref }}
-      #   run: strip target/release/nu_plugin_inc
+        TARGET: ${{ matrix.target }}
-
+        _EXTRA_: ${{ matrix.extra }}
-      # - name: Strip binaries (nu_plugin_match)
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
-      #   run: strip target/release/nu_plugin_match
+
-
+    # REF: https://github.com/marketplace/actions/gh-release
-      # - name: Strip binaries (nu_plugin_textview)
+    - name: Publish Archive
-      #   run: strip target/release/nu_plugin_textview
+      uses: softprops/action-gh-release@v1
-
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      # - name: Strip binaries (nu_plugin_binaryview)
+      with:
-      #   run: strip target/release/nu_plugin_binaryview
+        draft: true
-
+        files: ${{ steps.nu.outputs.archive }}
-      # - name: Strip binaries (nu_plugin_chart_bar)
+      env:
-      #   run: strip target/release/nu_plugin_chart_bar
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      # - name: Strip binaries (nu_plugin_chart_line)
-      #   run: strip target/release/nu_plugin_chart_line
-
-      # - name: Strip binaries (nu_plugin_from_bson)
-      #   run: strip target/release/nu_plugin_from_bson
-
-      # - name: Strip binaries (nu_plugin_from_sqlite)
-      #   run: strip target/release/nu_plugin_from_sqlite
-
-      # - name: Strip binaries (nu_plugin_from_mp4)
-      #   run: strip target/release/nu_plugin_from_mp4
-
-      # - name: Strip binaries (nu_plugin_query_json)
-      #   run: strip target/release/nu_plugin_query_json
-
-      # - name: Strip binaries (nu_plugin_s3)
-      #   run: strip target/release/nu_plugin_s3
-
-      # - name: Strip binaries (nu_plugin_selector)
-      #   run: strip target/release/nu_plugin_selector
-
-      # - name: Strip binaries (nu_plugin_start)
-      #   run: strip target/release/nu_plugin_start
-
-      # - name: Strip binaries (nu_plugin_to_bson)
-      #   run: strip target/release/nu_plugin_to_bson
-
-      # - name: Strip binaries (nu_plugin_to_sqlite)
-      #   run: strip target/release/nu_plugin_to_sqlite
-
-      # - name: Strip binaries (nu_plugin_tree)
-      #   run: strip target/release/nu_plugin_tree
-
-      # - name: Strip binaries (nu_plugin_xpath)
-      #   run: strip target/release/nu_plugin_xpath
-
-      - name: Create output directory
-        run: mkdir output
-
-      - name: Copy files to output
-        run: |
-          cp target/release/nu target/release/nu_plugin_* output/
-          cp README.release.txt output/README.txt
-          cp LICENSE output/LICENSE
-          rm output/*.d
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux
-          path: output/*
-
-  macos:
-    name: Build macOS
-    runs-on: macos-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: Set up cargo
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release --all --features=extra,static-link-openssl
-
-      # - name: Strip binaries (nu)
-      #   run: strip target/release/nu
-
-      # - name: Strip binaries (nu_plugin_inc)
-      #   run: strip target/release/nu_plugin_inc
-
-      # - name: Strip binaries (nu_plugin_match)
-      #   run: strip target/release/nu_plugin_match
-
-      # - name: Strip binaries (nu_plugin_textview)
-      #   run: strip target/release/nu_plugin_textview
-
-      # - name: Strip binaries (nu_plugin_binaryview)
-      #   run: strip target/release/nu_plugin_binaryview
-
-      # - name: Strip binaries (nu_plugin_chart_bar)
-      #   run: strip target/release/nu_plugin_chart_bar
-
-      # - name: Strip binaries (nu_plugin_chart_line)
-      #   run: strip target/release/nu_plugin_chart_line
-
-      # - name: Strip binaries (nu_plugin_from_bson)
-      #   run: strip target/release/nu_plugin_from_bson
-
-      # - name: Strip binaries (nu_plugin_from_sqlite)
-      #   run: strip target/release/nu_plugin_from_sqlite
-
-      # - name: Strip binaries (nu_plugin_from_mp4)
-      #   run: strip target/release/nu_plugin_from_mp4
-
-      # - name: Strip binaries (nu_plugin_query_json)
-      #   run: strip target/release/nu_plugin_query_json
-
-      # - name: Strip binaries (nu_plugin_s3)
-      #   run: strip target/release/nu_plugin_s3
-
-      # - name: Strip binaries (nu_plugin_selector)
-      #   run: strip target/release/nu_plugin_selector
-
-      # - name: Strip binaries (nu_plugin_start)
-      #   run: strip target/release/nu_plugin_start
-
-      # - name: Strip binaries (nu_plugin_to_bson)
-      #   run: strip target/release/nu_plugin_to_bson
-
-      # - name: Strip binaries (nu_plugin_to_sqlite)
-      #   run: strip target/release/nu_plugin_to_sqlite
-
-      # - name: Strip binaries (nu_plugin_tree)
-      #   run: strip target/release/nu_plugin_tree
-
-      # - name: Strip binaries (nu_plugin_xpath)
-      #   run: strip target/release/nu_plugin_xpath
-
-      - name: Create output directory
-        run: mkdir output
-
-      - name: Copy files to output
-        run: |
-          cp target/release/nu target/release/nu_plugin_* output/
-          cp README.release.txt output/README.txt
-          cp LICENSE output/LICENSE
-          rm output/*.d
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: macos
-          path: output/*
-
-  windows:
-    name: Build Windows
-    runs-on: windows-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: Set up cargo
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-
-      - name: Add cargo-wix subcommand
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-wix --version 0.3.1
-
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release --all --features=extra,static-link-openssl
-
-      # - name: Strip binaries (nu.exe)
-      #   run: strip target/release/nu.exe
-
-      # - name: Strip binaries (nu_plugin_inc.exe)
-      #   run: strip target/release/nu_plugin_inc.exe
-
-      # - name: Strip binaries (nu_plugin_match.exe)
-      #   run: strip target/release/nu_plugin_match.exe
-
-      # - name: Strip binaries (nu_plugin_textview.exe)
-      #   run: strip target/release/nu_plugin_textview.exe
-
-      # - name: Strip binaries (nu_plugin_binaryview.exe)
-      #   run: strip target/release/nu_plugin_binaryview.exe
-
-      # - name: Strip binaries (nu_plugin_chart_bar.exe)
-      #   run: strip target/release/nu_plugin_chart_bar.exe
-
-      # - name: Strip binaries (nu_plugin_chart_line.exe)
-      #   run: strip target/release/nu_plugin_chart_line.exe
-
-      # - name: Strip binaries (nu_plugin_from_bson.exe)
-      #   run: strip target/release/nu_plugin_from_bson.exe
-
-      # - name: Strip binaries (nu_plugin_from_sqlite.exe)
-      #   run: strip target/release/nu_plugin_from_sqlite.exe
-
-      # - name: Strip binaries (nu_plugin_from_mp4.exe)
-      #   run: strip target/release/nu_plugin_from_mp4.exe
-
-      # - name: Strip binaries (nu_plugin_query_json.exe)
-      #   run: strip target/release/nu_plugin_query_json.exe
-
-      # - name: Strip binaries (nu_plugin_s3.exe)
-      #   run: strip target/release/nu_plugin_s3.exe
-
-      # - name: Strip binaries (nu_plugin_selector.exe)
-      #   run: strip target/release/nu_plugin_selector.exe
-
-      # - name: Strip binaries (nu_plugin_start.exe)
-      #   run: strip target/release/nu_plugin_start.exe
-
-      # - name: Strip binaries (nu_plugin_to_bson.exe)
-      #   run: strip target/release/nu_plugin_to_bson.exe
-
-      # - name: Strip binaries (nu_plugin_to_sqlite.exe)
-      #   run: strip target/release/nu_plugin_to_sqlite.exe
-
-      # - name: Strip binaries (nu_plugin_tree.exe)
-      #   run: strip target/release/nu_plugin_tree.exe
-
-      # - name: Strip binaries (nu_plugin_xpath.exe)
-      #   run: strip target/release/nu_plugin_xpath.exe
-
-      - name: Create output directory
-        run: mkdir output
-
-      - name: Download Less Binary
-        run: Invoke-WebRequest -Uri "https://github.com/jftuga/less-Windows/releases/download/less-v562.0/less.exe" -OutFile "target\release\less.exe"
-
-      - name: Download Less License
-        run: Invoke-WebRequest -Uri "https://raw.githubusercontent.com/jftuga/less-Windows/master/LICENSE" -OutFile "target\release\LICENSE-for-less.txt"
-
-      - name: Copy files to output
-        run: |
-          cp target\release\nu.exe output\
-          cp LICENSE output\
-          cp target\release\LICENSE-for-less.txt output\
-          cp target\release\nu_plugin_*.exe output\
-          cp README.release.txt output\README.txt
-          cp target\release\less.exe output\
-      # Note: If the version of `less.exe` needs to be changed, update this URL
-      # Similarly, if `less.exe` is checked into the repo, copy from the local path here
-      # moved this stuff down to create wix after we download less
-
-      - name: Create msi with wix
-        uses: actions-rs/cargo@v1
-        with:
-          command: wix
-          args: --no-build --nocapture --output target\wix\nushell-windows.msi
-
-      - name: Upload installer
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-installer
-          path: target\wix\nushell-windows.msi
-
-      - name: Upload zip
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-zip
-          path: output\*
-
-  release:
-    name: Publish Release
-    runs-on: ubuntu-latest
-    needs:
-      - linux
-      - macos
-      - windows
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: Determine Release Info
-        id: info
-        env:
-          GITHUB_REF: ${{ github.ref }}
-        run: |
-          VERSION=${GITHUB_REF##*/}
-          MAJOR=${VERSION%%.*}
-          MINOR=${VERSION%.*}
-          MINOR=${MINOR#*.}
-          PATCH=${VERSION##*.}
-          echo "::set-output name=version::${VERSION}"
-          echo "::set-output name=linuxdir::nu_${MAJOR}_${MINOR}_${PATCH}_linux"
-          echo "::set-output name=macosdir::nu_${MAJOR}_${MINOR}_${PATCH}_macOS"
-          echo "::set-output name=windowsdir::nu_${MAJOR}_${MINOR}_${PATCH}_windows"
-          echo "::set-output name=innerdir::nushell-${VERSION}"
-
-      - name: Create Release Draft
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ steps.info.outputs.version }} Release
-          draft: true
-
-      - name: Create Linux Directory
-        run: mkdir -p ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Download Linux Artifacts
-        uses: actions/download-artifact@v2
-        with:
-          name: linux
-          path: ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Restore Linux File Modes
-        run: |
-          chmod 755 ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}/nu*
-
-      - name: Create Linux tarball
-        run: tar -zcvf ${{ steps.info.outputs.linuxdir }}.tar.gz ${{ steps.info.outputs.linuxdir }}
-
-      - name: Upload Linux Artifact
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./${{ steps.info.outputs.linuxdir }}.tar.gz
-          asset_name: ${{ steps.info.outputs.linuxdir }}.tar.gz
-          asset_content_type: application/gzip
-
-      - name: Create macOS Directory
-        run: mkdir -p ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Download macOS Artifacts
-        uses: actions/download-artifact@v2
-        with:
-          name: macos
-          path: ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Restore macOS File Modes
-        run: chmod 755 ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}/nu*
-
-      - name: Create macOS Archive
-        run: zip -r ${{ steps.info.outputs.macosdir }}.zip ${{ steps.info.outputs.macosdir }}
-
-      - name: Upload macOS Artifact
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./${{ steps.info.outputs.macosdir }}.zip
-          asset_name: ${{ steps.info.outputs.macosdir }}.zip
-          asset_content_type: application/zip
-
-      - name: Create Windows Directory
-        run: mkdir -p ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Download Windows zip
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-zip
-          path: ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Show Windows Artifacts
-        run: ls -la ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Create macOS Archive
-        run: zip -r ${{ steps.info.outputs.windowsdir }}.zip ${{ steps.info.outputs.windowsdir }}
-
-      - name: Upload Windows zip
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./${{ steps.info.outputs.windowsdir }}.zip
-          asset_name: ${{ steps.info.outputs.windowsdir }}.zip
-          asset_content_type: application/zip
-
-      - name: Download Windows installer
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-installer
-          path: ./
-
-      - name: Upload Windows installer
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./nushell-windows.msi
-          asset_name: ${{ steps.info.outputs.windowsdir }}.msi
-          asset_content_type: application/x-msi

.github/workflows/winget-submission.yml

@@ -1,4 +1,4 @@
-name: Submit Nushell package to Windows Package Manager Community Repository 
+name: Submit Nushell package to Windows Package Manager Community Repository
 
 on:
   workflow_dispatch:
@@ -15,5 +15,5 @@ jobs:
         run: |
           iwr https://aka.ms/wingetcreate/latest -OutFile wingetcreate.exe
           $github = Get-Content '${{ github.event_path }}' | ConvertFrom-Json
-          $installerUrl = $github.release.assets | Where-Object -Property name -match 'windows.msi' | Select -ExpandProperty browser_download_url -First 1
+          $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

@@ -25,3 +25,7 @@ debian/nu/
 # Helix configuration folder
 .helix/*
 .helix
+
+# Coverage tools
+lcov.info
+tarpaulin-report.html

CONTRIBUTING.md

@@ -1,21 +1,14 @@
 # Contributing
 
-Welcome to nushell!
+Welcome to Nushell!
-
-*Note: for a more complete guide see [The nu contributor book](https://www.nushell.sh/contributor-book/)*
-
-For speedy contributions open it in Gitpod, nu will be pre-installed with the latest build in a VSCode like editor all from your browser.
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)
 
 To get live support from the community see our [Discord](https://discordapp.com/invite/NtAbbGn), [Twitter](https://twitter.com/nu_shell) or file an issue or feature request here on [GitHub](https://github.com/nushell/nushell/issues/new/choose)!
-<!--WIP-->
 
 ## Developing
 
-### Set up
+### Setup
 
-This is no different than other Rust projects.
+Nushell requires a recent Rust toolchain and some dependencies; [refer to the Nu Book for up-to-date requirements](https://www.nushell.sh/book/installation.html#build-from-source). After installing dependencies, you should be able to clone+build Nu like any other Rust project:
 
 ```bash
 git clone https://github.com/nushell/nushell
@@ -28,24 +21,24 @@ cargo build
 - Build and run Nushell:
 
   ```shell
-  cargo build --release && cargo run --release
+  cargo run
   ```
 
-- Build and run with extra features:
+- Build and run with extra features. Currently extra features include dataframes and sqlite database support.
   ```shell
-  cargo build --release --features=extra && cargo run --release --features=extra
+  cargo run --features=extra
   ```
 
 - Run Clippy on Nushell:
 
   ```shell
-  cargo clippy --all --features=stable
+  cargo clippy --workspace --features=extra -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
   ```
 
 - Run all tests:
 
   ```shell
-  cargo test --all --features=stable
+  cargo test --workspace --features=extra
   ```
 
 - Run all tests for a specific command
@@ -71,5 +64,5 @@ cargo build
 - To view verbose logs when developing, enable the `trace` log level.
 
   ```shell
-  cargo build --release --features=extra && cargo run --release --features=extra -- --log-level trace
+  cargo run --release --features=extra -- --log-level trace
   ```

Cargo.toml

@@ -11,7 +11,7 @@ name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
 rust-version = "1.60"
-version = "0.63.0"
+version = "0.66.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -28,48 +28,53 @@ members = [
 	"crates/nu_plugin_gstat",
 	"crates/nu_plugin_example",
 	"crates/nu_plugin_query",
+	"crates/nu_plugin_custom_values",
 	"crates/nu-utils",
 ]
 
 [dependencies]
-chrono = "0.4.19"
+chrono = { version = "0.4.19", features = ["serde"] }
 crossterm = "0.23.0"
 ctrlc = "3.2.1"
 log = "0.4"
-miette = "4.5.0"
+miette = "5.1.0"
-nu-ansi-term = "0.45.1"
+nu-ansi-term = "0.46.0"
-nu-cli = { path="./crates/nu-cli", version = "0.63.0"  }
+nu-cli = { path="./crates/nu-cli", version = "0.66.0"  }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.63.0"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.66.0"  }
-nu-command = { path="./crates/nu-command", version = "0.63.0"  }
+nu-command = { path="./crates/nu-command", version = "0.66.0"  }
-nu-engine = { path="./crates/nu-engine", version = "0.63.0"  }
+nu-engine = { path="./crates/nu-engine", version = "0.66.0"  }
-nu-json = { path="./crates/nu-json", version = "0.63.0"  }
+nu-json = { path="./crates/nu-json", version = "0.66.0"  }
-nu-parser = { path="./crates/nu-parser", version = "0.63.0"  }
+nu-parser = { path="./crates/nu-parser", version = "0.66.0"  }
-nu-path = { path="./crates/nu-path", version = "0.63.0"  }
+nu-path = { path="./crates/nu-path", version = "0.66.0"  }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.63.0"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.66.0"  }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.63.0"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.66.0"  }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.63.0"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.66.0"  }
-nu-system = { path = "./crates/nu-system", version = "0.63.0" }
+nu-system = { path = "./crates/nu-system", version = "0.66.0" }
-nu-table = { path = "./crates/nu-table", version = "0.63.0"  }
+nu-table = { path = "./crates/nu-table", version = "0.66.0"  }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.63.0"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.66.0"  }
-nu-utils = { path = "./crates/nu-utils", version = "0.63.0"  }
+nu-utils = { path = "./crates/nu-utils", version = "0.66.0"  }
-openssl = { version = "0.10.38", features = ["vendored"], optional = true }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
 pretty_env_logger = "0.4.0"
 rayon = "1.5.1"
-reedline = { version = "0.6.0", features = ["bashisms"]}
 is_executable = "1.0.1"
 
+[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 }
+
 [dev-dependencies]
-nu-test-support = { path="./crates/nu-test-support", version = "0.63.0"  }
+nu-test-support = { path="./crates/nu-test-support", version = "0.66.0"  }
 tempfile = "3.2.0"
 assert_cmd = "2.0.2"
 pretty_assertions = "1.0.0"
-serial_test = "0.5.1"
+serial_test = "0.8.0"
 hamcrest2 = "0.3.0"
-rstest = "0.12.0"
+rstest = "0.15.0"
 itertools = "0.10.3"
 
 [target.'cfg(windows)'.build-dependencies]
-embed-resource = "1"
+winres = "0.1"
 
 [features]
 plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]

README.md

@@ -1,5 +1,4 @@
-# README
+# 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/workflow/status/nushell/nushell/continuous-integration)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
@@ -8,128 +7,100 @@
 ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/nushell/nushell)
 ![GitHub contributors](https://img.shields.io/github/contributors/nushell/nushell)
 
-## Nushell
-
 A new type of shell.
 
 ![Example of nushell](images/nushell-autocomplete6.gif "Example of nushell")
 
+## Table of Contents <!-- omit in toc -->
+
+- [Status](#status)
+- [Learning About Nu](#learning-about-nu)
+- [Installation](#installation)
+- [Philosophy](#philosophy)
+  - [Pipelines](#pipelines)
+  - [Opening files](#opening-files)
+  - [Plugins](#plugins)
+- [Goals](#goals)
+- [Progress](#progress)
+- [Officially Supported By](#officially-supported-by)
+- [Contributing](#contributing)
+- [License](#license)
+
 ## Status
 
-This project has reached a minimum-viable product level of quality.
+This project has reached a minimum-viable-product level of quality. Many people use it as their daily driver, but it may be unstable for some commands. Nu's design is subject to change as it matures.
-While contributors dogfood it as their daily driver, it may be unstable for some commands.
-Future releases will work to fill out missing features and improve stability.
-Its design is also subject to change as it matures.
 
-Nu comes with a set of built-in commands (listed below).
+## Learning About Nu
-If a command is unknown, the command will shell-out and execute it (using cmd on Windows or bash on Linux and macOS), correctly passing through stdin, stdout, and stderr, so things like your daily git workflows and even `vim` will work just fine.
 
-## Learning more
+The [Nushell book](https://www.nushell.sh/book/) is the primary source of Nushell documentation. You can find [a full list of Nu commands in the book](https://www.nushell.sh/book/command_reference.html), and we have many examples of using Nu in our [cookbook](https://www.nushell.sh/cookbook/).
 
-There are a few good resources to learn about Nu.
+We're also active on [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell); come and chat with us!
-There is a [book](https://www.nushell.sh/book/) about Nu that is currently in progress.
-The book focuses on using Nu and its core concepts.
-
-If you're a developer who would like to contribute to Nu, we're also working on a [book for developers](https://www.nushell.sh/contributor-book/) to help you get started.
-There are also [good first issues](https://github.com/nushell/nushell/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to help you dive in.
-
-We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https://twitter.com/nu_shell) if you'd like to come and chat with us.
-
-You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).
 
 ## Installation
 
-### Local
+To quickly install Nu:
 
-Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
+```bash
-
+# Linux and macOS
-To build Nu, you will need to use the **latest stable (1.60 or later)** version of the compiler.
+brew install nushell
-
+# Windows
-Required dependencies:
-
--   pkg-config and libssl (only needed on Linux)
-    -   On Debian/Ubuntu: `apt install pkg-config libssl-dev`
-
-Optional dependencies:
-
--   To use Nu with all possible optional features enabled, you'll also need the following:
-    -   On Linux (on Debian/Ubuntu): `apt install libxcb-composite0-dev libx11-dev`
-
-To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs/) and the latest stable compiler via `rustup install stable`):
-
-For Windows users, you may also need to install the [Microsoft Visual C++ 2015 Redistributables](https://docs.microsoft.com/cpp/windows/latest-supported-vc-redist).
-
-```shell
-cargo install nu
-```
-
-To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
-
-```shell
 winget install nushell
 ```
 
-To install Nu via the [Chocolatey](https://chocolatey.org) package manager:
+To use `Nu` in Github Action, check [setup-nu](https://github.com/marketplace/actions/setup-nu) for more detail.
 
-```shell
+Detailed installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). Nu is available via many package managers:
-choco install nushell
-```
-
-You can also build Nu yourself with all the bells and whistles (be sure to have installed the [dependencies](https://www.nushell.sh/book/installation.html#dependencies) for your platform), once you have checked out this repo with git:
-
-```shell
-cargo build --workspace --features=extra
-```
-### Packaging status
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)
 
-#### Fedora
 
-[COPR repo](https://copr.fedorainfracloud.org/coprs/atim/nushell/): `sudo dnf copr enable atim/nushell -y && sudo dnf install nushell -y`
 
 ## Philosophy
 
 Nu draws inspiration from projects like PowerShell, functional programming languages, and modern CLI tools.
-Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure.
+Rather than thinking of files and data as raw streams of text, Nu looks at each input as something with structure.
-For example, when you list the contents of a directory, what you get back is a table of rows, where each row represents an item in that directory.
+For example, when you list the contents of a directory what you get back is a table of rows, where each row represents an item in that directory.
 These values can be piped through a series of steps, in a series of commands called a 'pipeline'.
 
 ### Pipelines
 
 In Unix, it's common to pipe between commands to split up a sophisticated command over multiple steps.
 Nu takes this a step further and builds heavily on the idea of _pipelines_.
-Just as the Unix philosophy, Nu allows commands to output to stdout and read from stdin.
+As in the Unix philosophy, Nu allows commands to output to stdout and read from stdin.
 Additionally, commands can output structured data (you can think of this as a third kind of stream).
 Commands that work in the pipeline fit into one of three categories:
 
 -   Commands that produce a stream (e.g., `ls`)
--   Commands that filter a stream (eg, `where type == "Dir"`)
+-   Commands that filter a stream (eg, `where type == "dir"`)
--   Commands that consume the output of the pipeline (e.g., `autoview`)
+-   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.
 
 ```shell
-> ls | where type == "Dir" | autoview
+> ls | where type == "dir" | table
-───┬────────┬──────┬───────┬──────────────
+╭────┬──────────┬──────┬─────────┬───────────────╮
- # │ name   │ type │ size  │ modified
+│ #  │   name   │ type │  size   │   modified    │
-───┼────────┼──────┼───────┼──────────────
+├────┼──────────┼──────┼─────────┼───────────────┤
- 0 │ assets │ Dir  │ 128 B │ 5 months ago
+│  0 │ .cargo   │ dir  │     0 B │ 9 minutes ago │
- 1 │ crates │ Dir  │ 704 B │ 50 mins ago
+│  1 │ assets   │ dir  │     0 B │ 2 weeks ago   │
- 2 │ debian │ Dir  │ 352 B │ 5 months ago
+│  2 │ crates   │ dir  │ 4.0 KiB │ 2 weeks ago   │
- 3 │ docs   │ Dir  │ 192 B │ 50 mins ago
+│  3 │ docker   │ dir  │     0 B │ 2 weeks ago   │
- 4 │ images │ Dir  │ 160 B │ 5 months ago
+│  4 │ docs     │ dir  │     0 B │ 2 weeks ago   │
- 5 │ src    │ Dir  │ 128 B │ 1 day ago
+│  5 │ images   │ dir  │     0 B │ 2 weeks ago   │
- 6 │ target │ Dir  │ 160 B │ 5 days ago
+│  6 │ pkg_mgrs │ dir  │     0 B │ 2 weeks ago   │
- 7 │ tests  │ Dir  │ 192 B │ 3 months ago
+│  7 │ samples  │ dir  │     0 B │ 2 weeks ago   │
-───┴────────┴──────┴───────┴──────────────
+│  8 │ src      │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│  9 │ target   │ dir  │     0 B │ a day ago     │
+│ 10 │ tests    │ dir  │ 4.0 KiB │ 2 weeks ago   │
+│ 11 │ wix      │ dir  │     0 B │ 2 weeks ago   │
+╰────┴──────────┴──────┴─────────┴───────────────╯
 ```
 
-Because most of the time you'll want to see the output of a pipeline, `autoview` is assumed.
+Because most of the time you'll want to see the output of a pipeline, `table` is assumed.
 We could have also written the above:
 
 ```shell
-> ls | where type == Dir
+> ls | where type == "dir"
 ```
 
 Being able to use the same commands and compose them differently is an important philosophy in Nu.
@@ -137,15 +108,13 @@ For example, we could use the built-in `ps` command to get a list of the running
 
 ```shell
 > ps | where cpu > 0
-───┬────────┬───────────────────┬──────────┬─────────┬──────────┬──────────
+╭───┬───────┬───────────┬───────┬───────────┬───────────╮
- # │ pid    │ name              │ status   │ cpu     │ mem      │ virtual
+│ # │  pid  │   name    │  cpu  │    mem    │  virtual  │
-───┼────────┼───────────────────┼──────────┼─────────┼──────────┼──────────
+├───┼───────┼───────────┼───────┼───────────┼───────────┤
- 0 │    435 │ irq/142-SYNA327   │ Sleeping │  7.5699 │      0 B │      0 B
+│ 0 │  2240 │ Slack.exe │ 16.40 │ 178.3 MiB │ 232.6 MiB │
- 1 │   1609 │ pulseaudio        │ Sleeping │  6.5605 │  10.6 MB │   2.3 GB
+│ 1 │ 16948 │ Slack.exe │ 16.32 │ 205.0 MiB │ 197.9 MiB │
- 2 │   1625 │ gnome-shell       │ Sleeping │  6.5684 │ 639.6 MB │   7.3 GB
+│ 2 │ 17700 │ nu.exe    │  3.77 │  26.1 MiB │   8.8 MiB │
- 3 │   2202 │ Web Content       │ Sleeping │  6.8157 │ 320.8 MB │   3.0 GB
+╰───┴───────┴───────────┴───────┴───────────┴───────────╯
- 4 │ 328788 │ nu_plugin_core_ps │ Sleeping │ 92.5750 │   5.9 MB │ 633.2 MB
-───┴────────┴───────────────────┴──────────┴─────────┴──────────┴──────────
 ```
 
 ### Opening files
@@ -155,72 +124,49 @@ For example, you can load a .toml file as structured data and explore it:
 
 ```shell
 > open Cargo.toml
-────────────────────┬───────────────────────────
+╭──────────────────┬────────────────────╮
- bin                │ [table 18 rows]
+│ bin              │ [table 1 row]      │
- build-dependencies │ [row serde toml]
+│ dependencies     │ {record 24 fields} │
- dependencies       │ [row 29 columns]
+│ dev-dependencies │ {record 8 fields}  │
- dev-dependencies   │ [row nu-test-support]
+│ features         │ {record 10 fields} │
- features           │ [row 19 columns]
+│ package          │ {record 13 fields} │
- package            │ [row 12 columns]
+│ profile          │ {record 3 fields}  │
- workspace          │ [row members]
+│ target           │ {record 2 fields}  │
-────────────────────┴───────────────────────────
+│ workspace        │ {record 1 field}   │
+╰──────────────────┴────────────────────╯
 ```
 
-We can pipeline this into a command that gets the contents of one of the columns:
+We can pipe this into a command that gets the contents of one of the columns:
 
 ```shell
 > open Cargo.toml | get package
-───────────────┬────────────────────────────────────
+╭───────────────┬────────────────────────────────────╮
- authors       │ [table 1 rows]
+│ authors       │ [list 1 item]                      │
- default-run   │ nu
+│ default-run   │ nu                                 │
- description   │ A new type of shell
+│ description   │ A new type of shell                │
- documentation │ https://www.nushell.sh/book/
+│ documentation │ https://www.nushell.sh/book/       │
- edition       │ 2018
+│ edition       │ 2018                               │
- exclude       │ [table 1 rows]
+│ exclude       │ [list 1 item]                      │
- homepage      │ https://www.nushell.sh
+│ homepage      │ https://www.nushell.sh             │
- license       │ MIT
+│ license       │ MIT                                │
- name          │ nu
+│ name          │ nu                                 │
- readme        │ README.md
+│ readme        │ README.md                          │
- repository    │ https://github.com/nushell/nushell
+│ repository    │ https://github.com/nushell/nushell │
- version       │ 0.32.0
+│ rust-version  │ 1.60                               │
-───────────────┴────────────────────────────────────
+│ version       │ 0.63.1                             │
+╰───────────────┴────────────────────────────────────╯
 ```
 
-Finally, we can use commands outside of Nu once we have the data we want:
+And if needed we can drill down further:
 
 ```shell
 > open Cargo.toml | get package.version
-0.32.0
+0.63.1
 ```
 
-### Configuration
-
-Nu has early support for configuring the shell. You can refer to the book for a list of [all supported variables](https://www.nushell.sh/book/configuration.html).
-
-To set one of these variables, you can use `config set`. For example:
-
-```shell
-> config set line_editor.edit_mode "vi"
-> config set path $nu.path
-```
-
-### Shells
-
-Nu will work inside of a single directory and allow you to navigate around your filesystem by default.
-Nu also offers a way of adding additional working directories that you can jump between, allowing you to work in multiple directories simultaneously.
-
-To do so, use the `enter` command, which will allow you to create a new "shell" and enter it at the specified path.
-You can toggle between this new shell and the original shell with the `p` (for previous) and `n` (for next), allowing you to navigate around a ring buffer of shells.
-Once you're done with a shell, you can `exit` it and remove it from the ring buffer.
-
-Finally, to get a list of all the current shells, you can use the `shells` command.
-
 ### Plugins
 
-Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use.
+Nu supports plugins that offer additional functionality to the shell and follow the same structured data model that built-in commands use. There are a few examples in the `crates/nu_plugins_*` directories.
-This allows you to extend nu for your needs.
-
-There are a few examples in the `plugins` directory.
 
 Plugins are binaries that are available in your path and follow a `nu_plugin_*` naming convention.
 These binaries interact with nu via a simple JSON-RPC protocol where the command identifies itself and passes along its configuration, making it available for use.
@@ -231,23 +177,19 @@ If the plugin is a sink, it is given the full vector of final data and is given
 
 Nu adheres closely to a set of goals that make up its design philosophy. As features are added, they are checked against these goals.
 
--   First and foremost, Nu is cross-platform. Commands and techniques should carry between platforms and offer consistent first-class support for Windows, macOS, and Linux.
+-   First and foremost, Nu is cross-platform. Commands and techniques should work across platforms and Nu has first-class support for Windows, macOS, and Linux.
 
--   Nu ensures direct compatibility with existing platform-specific executables that make up people's workflows.
+-   Nu ensures compatibility with existing platform-specific executables.
 
--   Nu's workflow and tools should have the usability in day-to-day experience of using a shell in 2019 (and beyond).
+-   Nu's workflow and tools should have the usability expected of modern software in 2022 (and beyond).
 
--   Nu views data as both structured and unstructured. It is a structured shell like PowerShell.
+-   Nu views data as either structured or unstructured. It is a structured shell like PowerShell.
 
 -   Finally, Nu views data functionally. Rather than using mutation, pipelines act as a means to load, change, and save data without mutable state.
 
-## Commands
-
-You can find a list of Nu commands, complete with documentation, in [quick command references](https://www.nushell.sh/book/command_reference.html).
-
 ## Progress
 
-Nu is in heavy development and will naturally change as it matures and people use it. The chart below isn't meant to be exhaustive, but rather helps give an idea for some of the areas of development and their relative completion:
+Nu is under heavy development and will naturally change as it matures. The chart below isn't meant to be exhaustive, but it helps give an idea for some of the areas of development and their relative maturity:
 
 | Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
 | ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
@@ -270,20 +212,15 @@ Nu is in heavy development and will naturally change as it matures and people us
 
 Please submit an issue or PR to be added to this list.
 
-###   Integrations
 -   [zoxide](https://github.com/ajeetdsouza/zoxide)
 -   [starship](https://github.com/starship/starship)
 -   [oh-my-posh](https://ohmyposh.dev)
 -   [Couchbase Shell](https://couchbase.sh)
 -   [virtualenv](https://github.com/pypa/virtualenv)
-###   Mentions
--   [The Python Launcher for Unix](https://github.com/brettcannon/python-launcher#how-do-i-get-a-table-of-python-executables-in-nushell)
 
 ## Contributing
 
-See [Contributing](CONTRIBUTING.md) for details.
+See [Contributing](CONTRIBUTING.md) for details. Thanks to all the people who already contributed!
-
-Thanks to all the people who already contributed!
 
 <a href="https://github.com/nushell/nushell/graphs/contributors">
   <img src="https://contributors-img.web.app/image?repo=nushell/nushell&max=500" />

assets/nushell.rc

@@ -1,49 +0,0 @@
-#include <winver.h>
-
-#define VER_FILEVERSION 0,62,1,0
-#define VER_FILEVERSION_STR "0.62.1"
-
-#define VER_PRODUCTVERSION 0,62,1,0
-#define VER_PRODUCTVERSION_STR "0.62.1"
-
-#ifdef RC_INVOKED
-
-#ifdef DEBUG // TODO: Actually define DEBUG
-#define VER_DEBUG VS_FF_DEBUG
-#else
-#define VER_DEBUG 0
-#endif
-
-VS_VERSION_INFO VERSIONINFO
-FILEVERSION VER_FILEVERSION
-PRODUCTVERSION VER_PRODUCTVERSION
-FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
-FILEFLAGS VER_DEBUG
-FILEOS VOS__WINDOWS32
-FILETYPE VFT_APP
-FILESUBTYPE VFT2_UNKNOWN
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "CompanyName", "nushell"
-            VALUE "FileDescription", "Nushell"
-            VALUE "FileVersion", VER_FILEVERSION_STR
-            VALUE "InternalName", "nu.exe"
-            VALUE "LegalCopyright", "Copyright (C) 2022"
-            VALUE "OriginalFilename", "nu.exe"
-            VALUE "ProductName", "Nushell"
-            VALUE "ProductVersion", VER_PRODUCTVERSION_STR
-        END
-    END
-
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
-#define IDI_ICON 0x101
-IDI_ICON ICON "assets/nu_logo.ico"
-#endif

build.rs

@@ -1,6 +1,12 @@
 #[cfg(windows)]
 fn main() {
-    embed_resource::compile_for("assets/nushell.rc", &["nu"])
+    let mut res = winres::WindowsResource::new();
+    res.set("ProductName", "Nushell");
+    res.set("FileDescription", "Nushell");
+    res.set("LegalCopyright", "Copyright (C) 2022");
+    res.set_icon("assets/nu_logo.ico");
+    res.compile()
+        .expect("Failed to run the Windows resource compiler (rc.exe)");
 }
 
 #[cfg(not(windows))]

crates/nu-cli/Cargo.toml

@@ -4,28 +4,33 @@ description = "CLI-related functionality for Nushell"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.63.0"
+version = "0.66.0"
 
 [dev-dependencies]
-nu-test-support = { path="../nu-test-support", version = "0.63.0"  }
+nu-test-support = { path="../nu-test-support", version = "0.66.0"  }
-nu-command = { path = "../nu-command", version = "0.63.0" }
+nu-command = { path = "../nu-command", version = "0.66.0" }
+rstest = "0.15.0"
 
 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.63.0"  }
+nu-engine = { path = "../nu-engine", version = "0.66.0"  }
-nu-path = { path = "../nu-path", version = "0.63.0"  }
+nu-path = { path = "../nu-path", version = "0.66.0"  }
-nu-parser = { path = "../nu-parser", version = "0.63.0"  }
+nu-parser = { path = "../nu-parser", version = "0.66.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.63.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.0"  }
-nu-utils = { path = "../nu-utils", version = "0.63.0"  }
+nu-utils = { path = "../nu-utils", version = "0.66.0"  }
-nu-ansi-term = "0.45.1"
+nu-ansi-term = "0.46.0"
-nu-color-config = { path = "../nu-color-config", version = "0.63.0"  }
+nu-color-config = { path = "../nu-color-config", version = "0.66.0"  }
-reedline = { version = "0.6.0", features = ["bashisms"]}
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
 crossterm = "0.23.0"
-miette = { version = "4.5.0", features = ["fancy"] }
+miette = { version = "5.1.0", features = ["fancy"] }
-thiserror = "1.0.29"
+thiserror = "1.0.31"
 fuzzy-matcher = "0.3.7"
 
-log = "0.4"
+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

@@ -5,21 +5,27 @@ use nu_engine::{convert_env_values, eval_block};
 use nu_parser::parse;
 use nu_protocol::engine::Stack;
 use nu_protocol::{
-    engine::{EngineState, StateDelta, StateWorkingSet},
+    engine::{EngineState, StateWorkingSet},
     PipelineData, Spanned, Value,
 };
-use std::path::Path;
 
+/// Run a command (or commands) given to us by the user
 pub fn evaluate_commands(
     commands: &Spanned<String>,
-    init_cwd: &Path,
     engine_state: &mut EngineState,
     stack: &mut Stack,
     input: PipelineData,
     is_perf_true: bool,
     table_mode: Option<Value>,
-) -> Result<()> {
+) -> Result<Option<i64>> {
-    // Run a command (or commands) given to us by the user
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    // Parse the source code
     let (block, delta) = {
         if let Some(ref t_mode) = table_mode {
             let mut config = engine_state.get_config().clone();
@@ -39,43 +45,19 @@ pub fn evaluate_commands(
         (output, working_set.render())
     };
 
-    if let Err(err) = engine_state.merge_delta(delta, None, init_cwd) {
+    // Update permanent state
+    if let Err(err) = engine_state.merge_delta(delta) {
         let working_set = StateWorkingSet::new(engine_state);
         report_error(&working_set, &err);
     }
 
-    let mut config = engine_state.get_config().clone();
+    // Run the block
-    if let Some(t_mode) = table_mode {
+    let exit_code = match eval_block(engine_state, stack, &block, input, false, false) {
-        config.table_mode = t_mode.as_string()?;
-    }
-
-    // Merge the delta in case env vars changed in the config
-    match nu_engine::env::current_dir(engine_state, stack) {
-        Ok(cwd) => {
-            if let Err(e) =
-                engine_state.merge_delta(StateDelta::new(engine_state), Some(stack), cwd)
-            {
-                let working_set = StateWorkingSet::new(engine_state);
-                report_error(&working_set, &e);
-                std::process::exit(1);
-            }
-        }
-        Err(e) => {
-            let working_set = StateWorkingSet::new(engine_state);
-            report_error(&working_set, &e);
-            std::process::exit(1);
-        }
-    }
-
-    // Translate environment variables from Strings to Values
-    if let Some(e) = convert_env_values(engine_state, stack) {
-        let working_set = StateWorkingSet::new(engine_state);
-        report_error(&working_set, &e);
-        std::process::exit(1);
-    }
-
-    match eval_block(engine_state, stack, &block, input, false, false) {
         Ok(pipeline_data) => {
+            let mut config = engine_state.get_config().clone();
+            if let Some(t_mode) = table_mode {
+                config.table_mode = t_mode.as_string()?;
+            }
             crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &mut config)
         }
         Err(err) => {
@@ -84,11 +66,11 @@ pub fn evaluate_commands(
             report_error(&working_set, &err);
             std::process::exit(1);
         }
-    }
+    };
 
     if is_perf_true {
         info!("evaluate {}:{}:{}", file!(), line!(), column!());
     }
 
-    Ok(())
+    Ok(exit_code)
 }

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

@@ -43,19 +43,21 @@ impl CommandCompletion {
 
                     if let Ok(mut contents) = std::fs::read_dir(path) {
                         while let Some(Ok(item)) = contents.next() {
-                            if !executables.contains(
+                            if self.engine_state.config.max_external_completion_results
-                                &item
+                                > executables.len() as i64
-                                    .path()
+                                && !executables.contains(
-                                    .file_name()
+                                    &item
-                                    .map(|x| x.to_string_lossy().to_string())
+                                        .path()
-                                    .unwrap_or_default(),
+                                        .file_name()
-                            ) && matches!(
+                                        .map(|x| x.to_string_lossy().to_string())
-                                item.path()
+                                        .unwrap_or_default(),
-                                    .file_name()
+                                )
-                                    .map(|x| match_algorithm
+                                && matches!(
+                                    item.path().file_name().map(|x| match_algorithm
                                         .matches_str(&x.to_string_lossy(), prefix)),
-                                Some(true)
+                                    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);
@@ -199,12 +201,19 @@ impl Completer for CommandCompletion {
             return subcommands;
         }
 
+        let config = working_set.get_config();
         let commands = if matches!(self.flat_shape, nu_parser::FlatShape::External)
             || matches!(self.flat_shape, nu_parser::FlatShape::InternalCall)
             || ((span.end - span.start) == 0)
         {
             // we're in a gap or at a command
-            self.complete_commands(working_set, span, offset, true, options.match_algorithm)
+            self.complete_commands(
+                working_set,
+                span,
+                offset,
+                config.enable_external_completion,
+                options.match_algorithm,
+            )
         } else {
             vec![]
         };

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

@@ -37,7 +37,10 @@ impl NuCompleter {
     ) -> Vec<Suggestion> {
         let config = self.engine_state.get_config();
 
-        let mut options = CompletionOptions::default();
+        let mut options = CompletionOptions {
+            case_sensitive: config.case_sensitive_completions,
+            ..Default::default()
+        };
 
         if config.completion_algorithm == "fuzzy" {
             options.match_algorithm = MatchAlgorithm::Fuzzy;
@@ -56,61 +59,39 @@ impl NuCompleter {
     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 mut line = line.to_string();
+        new_line.push(b'a');
-        line.insert(pos, 'a');
         let pos = offset + pos;
-        let (output, _err) = parse(
+        let (output, _err) = parse(&mut working_set, Some("completer"), &new_line, false, &[]);
-            &mut working_set,
-            Some("completer"),
-            line.as_bytes(),
-            false,
-            &[],
-        );
 
         for pipeline in output.pipelines.into_iter() {
             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() {
-                    if pos >= flat.0.start && pos < flat.0.end {
+                    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());
 
                         // Create a new span
-                        let new_span = Span {
+                        let new_span = if flat_idx == 0 {
-                            start: flat.0.start,
+                            Span {
-                            end: flat.0.end - 1,
+                                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,
+                            }
                         };
 
                         // Parses the prefix
                         let mut prefix = working_set.get_span_contents(flat.0).to_vec();
-                        prefix.remove(pos - flat.0.start);
+                        prefix.remove(pos - (flat.0.start - span_offset));
-
-                        // 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,
-                                    );
-                                }
-                            }
-                        }
 
                         // Variables completion
                         if prefix.starts_with(b"$") || most_left_var.is_some() {
@@ -144,6 +125,42 @@ impl NuCompleter {
                             );
                         }
 
+                        // 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,
+                                        &working_set,
+                                        prefix,
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
+                                }
+                            }
+                        }
+
                         // Match other types
                         match &flat.1 {
                             FlatShape::Custom(decl_id) => {
@@ -176,6 +193,18 @@ impl NuCompleter {
                                     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(),
@@ -226,6 +255,85 @@ impl ReedlineCompleter for NuCompleter {
     }
 }
 
+type MatchedAlias = Vec<(Vec<u8>, Vec<u8>)>;
+
+// Handler the completion when giving lines contains at least one alias. (e.g: `g checkout`)
+// that `g` is an alias of `git`
+fn try_find_alias(line: &[u8], working_set: &StateWorkingSet) -> (Vec<u8>, Vec<usize>) {
+    // An vector represents the offsets of alias
+    // e.g: the offset is 2 for the alias `g` of `git`
+    let mut alias_offset = vec![];
+    let mut output = vec![];
+    if let Some(matched_alias) = search_alias(line, working_set) {
+        let mut lens = matched_alias.len();
+        for (input_vec, line_vec) in matched_alias {
+            alias_offset.push(line_vec.len() - input_vec.len());
+            output.extend(line_vec);
+            if lens > 1 {
+                output.push(b' ');
+                lens -= 1;
+            }
+        }
+
+        if !line.is_empty() {
+            let last = line.last().expect("input is empty");
+            if last == &b' ' {
+                output.push(b' ');
+            }
+        }
+    } else {
+        output = line.to_vec();
+    }
+
+    (output, alias_offset)
+}
+
+fn search_alias(input: &[u8], working_set: &StateWorkingSet) -> Option<MatchedAlias> {
+    let mut vec_names = vec![];
+    let mut vec_alias = vec![];
+    let mut pos = 0;
+    let mut is_alias = false;
+    for (index, character) in input.iter().enumerate() {
+        if *character == b' ' {
+            let range = &input[pos..index];
+            vec_names.push(range.to_owned());
+            pos = index + 1;
+        }
+    }
+    // Push the rest to names vector.
+    if pos < input.len() {
+        vec_names.push((&input[pos..]).to_owned());
+    }
+
+    for name in &vec_names {
+        if let Some(alias_id) = working_set.find_alias(&name[..]) {
+            let alias_span = working_set.get_alias(alias_id);
+            let mut span_vec = vec![];
+            is_alias = true;
+            for alias in alias_span {
+                let name = working_set.get_span_contents(*alias);
+                if !name.is_empty() {
+                    span_vec.push(name);
+                }
+            }
+            // Join span of vector together for complex alias, e.g: `f` is an alias for `git remote -v`
+            let full_aliases = span_vec.join(&[b' '][..]);
+            vec_alias.push(full_aliases);
+        } else {
+            vec_alias.push(name.to_owned());
+        }
+    }
+
+    if is_alias {
+        // Zip names and alias vectors, the original inputs and its aliases mapping.
+        // e.g:(['g'], ['g','i','t'])
+        let output = vec_names.into_iter().zip(vec_alias).collect();
+        Some(output)
+    } else {
+        None
+    }
+}
+
 // reads the most left variable returning it's name (e.g: $myvar)
 // and the depth (a.b.c)
 fn most_left_variable(

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

@@ -41,7 +41,7 @@ impl Completer for VariableCompletion {
         options: &CompletionOptions,
     ) -> Vec<Suggestion> {
         let mut output = vec![];
-        let builtins = ["$nu", "$in", "$config", "$env", "$nothing"];
+        let builtins = ["$nu", "$in", "$env", "$nothing"];
         let var_str = std::str::from_utf8(&self.var_context.0)
             .unwrap_or("")
             .to_lowercase();
@@ -70,7 +70,18 @@ impl Completer for VariableCompletion {
                         self.var_context.1.clone().into_iter().skip(1).collect();
 
                     if let Some(val) = env_vars.get(&target_var_str) {
-                        return nested_suggestions(val.clone(), nested_levels, current_span);
+                        for suggestion in
+                            nested_suggestions(val.clone(), nested_levels, current_span)
+                        {
+                            if options
+                                .match_algorithm
+                                .matches_u8(suggestion.value.as_bytes(), &prefix)
+                            {
+                                output.push(suggestion);
+                            }
+                        }
+
+                        return output;
                     }
                 } else {
                     // No nesting provided, return all env vars
@@ -105,7 +116,18 @@ impl Completer for VariableCompletion {
                         end: current_span.end,
                     },
                 ) {
-                    return nested_suggestions(nuval, self.var_context.1.clone(), current_span);
+                    for suggestion in
+                        nested_suggestions(nuval, self.var_context.1.clone(), current_span)
+                    {
+                        if options
+                            .match_algorithm
+                            .matches_u8(suggestion.value.as_bytes(), &prefix)
+                        {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return output;
                 }
             }
 
@@ -122,7 +144,18 @@ impl Completer for VariableCompletion {
 
                 // If the value exists and it's of type Record
                 if let Ok(value) = var {
-                    return nested_suggestions(value, self.var_context.1.clone(), current_span);
+                    for suggestion in
+                        nested_suggestions(value, self.var_context.1.clone(), current_span)
+                    {
+                        if options
+                            .match_algorithm
+                            .matches_u8(suggestion.value.as_bytes(), &prefix)
+                        {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return output;
                 }
             }
         }

crates/nu-cli/src/config_files.rs

@@ -1,23 +1,33 @@
 use crate::util::{eval_source, report_error};
 #[cfg(feature = "plugin")]
 use log::info;
-use nu_protocol::engine::{EngineState, Stack, StateDelta, StateWorkingSet};
+#[cfg(feature = "plugin")]
-use nu_protocol::{PipelineData, Span};
+use nu_parser::ParseError;
+#[cfg(feature = "plugin")]
+use nu_path::canonicalize_with;
+use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
+#[cfg(feature = "plugin")]
+use nu_protocol::Spanned;
+use nu_protocol::{HistoryFileFormat, PipelineData, Span};
 use std::path::PathBuf;
 
 #[cfg(feature = "plugin")]
 const PLUGIN_FILE: &str = "plugin.nu";
 
+const HISTORY_FILE_TXT: &str = "history.txt";
+const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
+
 #[cfg(feature = "plugin")]
 pub fn read_plugin_file(
     engine_state: &mut EngineState,
     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
-    add_plugin_file(engine_state, storage_path);
+    add_plugin_file(engine_state, plugin_file, storage_path);
 
     let plugin_path = engine_state.plugin_signatures.clone();
     if let Some(plugin_path) = plugin_path {
@@ -40,8 +50,23 @@ pub fn read_plugin_file(
 }
 
 #[cfg(feature = "plugin")]
-pub fn add_plugin_file(engine_state: &mut EngineState, storage_path: &str) {
+pub fn add_plugin_file(
-    if let Some(mut plugin_path) = nu_path::config_dir() {
+    engine_state: &mut EngineState,
+    plugin_file: Option<Spanned<String>>,
+    storage_path: &str,
+) {
+    if let Some(plugin_file) = plugin_file {
+        let working_set = StateWorkingSet::new(engine_state);
+        let cwd = working_set.get_cwd();
+
+        match canonicalize_with(&plugin_file.item, cwd) {
+            Ok(path) => engine_state.plugin_signatures = Some(path),
+            Err(_) => {
+                let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
+                report_error(&working_set, &e);
+            }
+        }
+    } else if let Some(mut plugin_path) = nu_path::config_dir() {
         // Path to store plugins signatures
         plugin_path.push(storage_path);
         plugin_path.push(PLUGIN_FILE);
@@ -66,12 +91,10 @@ pub fn eval_config_contents(
                 PipelineData::new(Span::new(0, 0)),
             );
 
-            // Merge the delta in case env vars changed in the config
+            // Merge the environment in case env vars changed in the config
             match nu_engine::env::current_dir(engine_state, stack) {
                 Ok(cwd) => {
-                    if let Err(e) =
+                    if let Err(e) = engine_state.merge_env(stack, cwd) {
-                        engine_state.merge_delta(StateDelta::new(engine_state), Some(stack), cwd)
-                    {
                         let working_set = StateWorkingSet::new(engine_state);
                         report_error(&working_set, &e);
                     }
@@ -84,3 +107,14 @@ pub fn eval_config_contents(
         }
     }
 }
+
+pub(crate) fn get_history_path(storage_path: &str, mode: HistoryFileFormat) -> Option<PathBuf> {
+    nu_path::config_dir().map(|mut history_path| {
+        history_path.push(storage_path);
+        history_path.push(match mode {
+            HistoryFileFormat::PlainText => HISTORY_FILE_TXT,
+            HistoryFileFormat::Sqlite => HISTORY_FILE_SQLITE,
+        });
+        history_path
+    })
+}

crates/nu-cli/src/eval_file.rs

@@ -4,6 +4,7 @@ use log::trace;
 use miette::{IntoDiagnostic, Result};
 use nu_engine::convert_env_values;
 use nu_parser::parse;
+use nu_protocol::Type;
 use nu_protocol::{
     ast::Call,
     engine::{EngineState, Stack, StateWorkingSet},
@@ -34,7 +35,7 @@ pub fn evaluate_file(
 
     let _ = parse(&mut working_set, Some(&path), &file, false, &[]);
 
-    if working_set.find_decl(b"main").is_some() {
+    if working_set.find_decl(b"main", &Type::Any).is_some() {
         let args = format!("main {}", args.join(" "));
 
         if !eval_source(
@@ -65,7 +66,7 @@ pub fn print_table_or_error(
     stack: &mut Stack,
     mut pipeline_data: PipelineData,
     config: &mut Config,
-) {
+) -> Option<i64> {
     let exit_code = match &mut pipeline_data {
         PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
         _ => None,
@@ -76,59 +77,63 @@ pub fn print_table_or_error(
 
     match engine_state.find_decl("table".as_bytes(), &[]) {
         Some(decl_id) => {
-            let table = engine_state.get_decl(decl_id).run(
+            let command = engine_state.get_decl(decl_id);
-                engine_state,
+            if command.get_block_id().is_some() {
-                stack,
+                print_or_exit(pipeline_data, engine_state, config);
-                &Call::new(Span::new(0, 0)),
+            } else {
-                pipeline_data,
+                let table = command.run(
-            );
+                    engine_state,
+                    stack,
+                    &Call::new(Span::new(0, 0)),
+                    pipeline_data,
+                );
 
-            match table {
+                match table {
-                Ok(table) => {
+                    Ok(table) => {
-                    for item in table {
+                        print_or_exit(table, engine_state, config);
-                        if let Value::Error { error } = item {
-                            let working_set = StateWorkingSet::new(engine_state);
-
-                            report_error(&working_set, &error);
-
-                            std::process::exit(1);
-                        }
-
-                        let mut out = item.into_string("\n", config);
-                        out.push('\n');
-
-                        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
                     }
-                }
+                    Err(error) => {
-                Err(error) => {
+                        let working_set = StateWorkingSet::new(engine_state);
-                    let working_set = StateWorkingSet::new(engine_state);
 
-                    report_error(&working_set, &error);
+                        report_error(&working_set, &error);
 
-                    std::process::exit(1);
+                        std::process::exit(1);
+                    }
                 }
             }
         }
         None => {
-            for item in pipeline_data {
+            print_or_exit(pipeline_data, engine_state, config);
-                if let Value::Error { error } = item {
-                    let working_set = StateWorkingSet::new(engine_state);
-
-                    report_error(&working_set, &error);
-
-                    std::process::exit(1);
-                }
-
-                let mut out = item.into_string("\n", config);
-                out.push('\n');
-
-                let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
-            }
         }
     };
 
     // Make sure everything has finished
     if let Some(exit_code) = exit_code {
-        let _: Vec<_> = exit_code.into_iter().collect();
+        let mut exit_code: Vec<_> = exit_code.into_iter().collect();
+        exit_code
+            .pop()
+            .and_then(|last_exit_code| match last_exit_code {
+                Value::Int { val: code, .. } => Some(code),
+                _ => None,
+            })
+    } else {
+        None
+    }
+}
+
+fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, config: &Config) {
+    for item in pipeline_data {
+        if let Value::Error { error } = item {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &error);
+
+            std::process::exit(1);
+        }
+
+        let mut out = item.into_string("\n", config);
+        out.push('\n');
+
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
     }
 }

crates/nu-cli/src/lib.rs

@@ -22,8 +22,9 @@ pub use nu_highlight::NuHighlight;
 pub use print::Print;
 pub use prompt::NushellPrompt;
 pub use repl::evaluate_repl;
+pub use repl::{eval_env_change_hook, eval_hook};
 pub use syntax_highlight::NuHighlighter;
-pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error};
+pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error, report_error_new};
 pub use validation::NuValidator;
 
 #[cfg(feature = "plugin")]

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

@@ -1,6 +1,7 @@
 use nu_engine::documentation::get_flags_section;
 use nu_protocol::{engine::EngineState, levenshtein_distance};
 use reedline::{Completer, Suggestion};
+use std::fmt::Write;
 use std::sync::Arc;
 
 pub struct NuHelpCompleter(Arc<EngineState>);
@@ -19,6 +20,10 @@ impl NuHelpCompleter {
             .filter(|(sig, _, _, _)| {
                 sig.name.to_lowercase().contains(&line.to_lowercase())
                     || sig.usage.to_lowercase().contains(&line.to_lowercase())
+                    || sig
+                        .search_terms
+                        .iter()
+                        .any(|term| term.to_lowercase().contains(&line.to_lowercase()))
                     || sig
                         .extra_usage
                         .to_lowercase()
@@ -49,7 +54,7 @@ impl NuHelpCompleter {
                     long_desc.push_str("\r\n\r\n");
                 }
 
-                long_desc.push_str(&format!("Usage:\r\n  > {}\r\n", sig.call_signature()));
+                let _ = write!(long_desc, "Usage:\r\n  > {}\r\n", sig.call_signature());
 
                 if !sig.named.is_empty() {
                     long_desc.push_str(&get_flags_section(sig))
@@ -61,27 +66,28 @@ impl NuHelpCompleter {
                 {
                     long_desc.push_str("\r\nParameters:\r\n");
                     for positional in &sig.required_positional {
-                        long_desc
+                        let _ = write!(long_desc, "  {}: {}\r\n", positional.name, positional.desc);
-                            .push_str(&format!("  {}: {}\r\n", positional.name, positional.desc));
                     }
                     for positional in &sig.optional_positional {
-                        long_desc.push_str(&format!(
+                        let _ = write!(
+                            long_desc,
                             "  (optional) {}: {}\r\n",
                             positional.name, positional.desc
-                        ));
+                        );
                     }
 
                     if let Some(rest_positional) = &sig.rest_positional {
-                        long_desc.push_str(&format!(
+                        let _ = write!(
+                            long_desc,
                             "  ...{}: {}\r\n",
                             rest_positional.name, rest_positional.desc
-                        ));
+                        );
                     }
                 }
 
                 let extra: Vec<String> = examples
                     .iter()
-                    .map(|example| example.example.to_string())
+                    .map(|example| example.example.replace('\n', "\r\n"))
                     .collect();
 
                 Suggestion {

crates/nu-cli/src/nu_highlight.rs

@@ -19,6 +19,10 @@ impl Command for NuHighlight {
         "Syntax highlight the input string."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["syntax", "color", "convert"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,

crates/nu-cli/src/print.rs

@@ -17,15 +17,27 @@ impl Command for Print {
         Signature::build("print")
             .rest("rest", SyntaxShape::Any, "the values to print")
             .switch(
-                "no_newline",
+                "no-newline",
                 "print without inserting a newline for the line ending",
                 Some('n'),
             )
+            .switch("stderr", "print to stderr instead of stdout", Some('e'))
             .category(Category::Strings)
     }
 
     fn usage(&self) -> &str {
-        "Prints the values given"
+        "Print the given values to stdout"
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"Unlike `echo`, this command does not return any value (`print | describe` will return "nothing").
+Since this command has no output, there is no point in piping it with other commands.
+
+`print` may be used inside blocks of code (e.g.: hooks) to display text during execution without interfering with the pipeline."#
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["display"]
     }
 
     fn run(
@@ -36,12 +48,13 @@ impl Command for Print {
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
-        let no_newline = call.has_flag("no_newline");
+        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)?;
+                .print(engine_state, stack, no_newline, to_stderr)?;
         }
 
         Ok(PipelineData::new(head))

crates/nu-cli/src/prompt.rs

@@ -1,5 +1,6 @@
+#[cfg(windows)]
+use nu_utils::enable_vt_processing;
 use reedline::DefaultPrompt;
-
 use {
     reedline::{
         Prompt, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus, PromptViMode,
@@ -86,6 +87,11 @@ impl NushellPrompt {
 
 impl Prompt for NushellPrompt {
     fn render_prompt_left(&self) -> Cow<str> {
+        #[cfg(windows)]
+        {
+            let _ = enable_vt_processing();
+        }
+
         if let Some(prompt_string) = &self.left_prompt_string {
             prompt_string.replace('\n', "\r\n").into()
         } else {

crates/nu-cli/src/prompt_update.rs

@@ -15,6 +15,10 @@ pub(crate) const PROMPT_INDICATOR: &str = "PROMPT_INDICATOR";
 pub(crate) const PROMPT_INDICATOR_VI_INSERT: &str = "PROMPT_INDICATOR_VI_INSERT";
 pub(crate) const PROMPT_INDICATOR_VI_NORMAL: &str = "PROMPT_INDICATOR_VI_NORMAL";
 pub(crate) const PROMPT_MULTILINE_INDICATOR: &str = "PROMPT_MULTILINE_INDICATOR";
+// According to Daniel Imms @Tyriar, we need to do these this way:
+// <133 A><prompt><133 B><command><133 C><command output>
+const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
 
 fn get_prompt_string(
     prompt: &str,
@@ -98,6 +102,20 @@ pub(crate) fn update_prompt<'prompt>(
         is_perf_true,
     );
 
+    // Now that we have the prompt string lets ansify it.
+    // <133 A><prompt><133 B><command><133 C><command output>
+    let left_prompt_string = if config.shell_integration {
+        match left_prompt_string {
+            Some(prompt_string) => Some(format!(
+                "{}{}{}",
+                PRE_PROMPT_MARKER, prompt_string, POST_PROMPT_MARKER
+            )),
+            None => left_prompt_string,
+        }
+    } else {
+        left_prompt_string
+    };
+
     let right_prompt_string = get_prompt_string(
         PROMPT_COMMAND_RIGHT,
         config,

crates/nu-cli/src/reedline_config.rs

@@ -875,7 +875,16 @@ fn edit_from_record(
         "moveleft" => EditCommand::MoveLeft,
         "moveright" => EditCommand::MoveRight,
         "movewordleft" => EditCommand::MoveWordLeft,
+        "movebigwordleft" => EditCommand::MoveBigWordLeft,
         "movewordright" => EditCommand::MoveWordRight,
+        "movewordrightend" => EditCommand::MoveWordRightEnd,
+        "movebigwordrightend" => EditCommand::MoveBigWordRightEnd,
+        "movewordrightstart" => EditCommand::MoveWordRightStart,
+        "movebigwordrightstart" => EditCommand::MoveBigWordRightStart,
+        "movetoposition" => {
+            let value = extract_value("value", cols, vals, span)?;
+            EditCommand::MoveToPosition(value.as_integer()? as usize)
+        }
         "insertchar" => {
             let value = extract_value("value", cols, vals, span)?;
             let char = extract_char(value, config)?;
@@ -888,6 +897,7 @@ fn edit_from_record(
         "insertnewline" => EditCommand::InsertNewline,
         "backspace" => EditCommand::Backspace,
         "delete" => EditCommand::Delete,
+        "cutchar" => EditCommand::CutChar,
         "backspaceword" => EditCommand::BackspaceWord,
         "deleteword" => EditCommand::DeleteWord,
         "clear" => EditCommand::Clear,
@@ -898,7 +908,11 @@ fn edit_from_record(
         "cuttoend" => EditCommand::CutToEnd,
         "cuttolineend" => EditCommand::CutToLineEnd,
         "cutwordleft" => EditCommand::CutWordLeft,
+        "cutbigwordleft" => EditCommand::CutBigWordLeft,
         "cutwordright" => EditCommand::CutWordRight,
+        "cutbigwordright" => EditCommand::CutBigWordRight,
+        "cutwordrighttonext" => EditCommand::CutWordRightToNext,
+        "cutbigwordrighttonext" => EditCommand::CutBigWordRightToNext,
         "pastecutbufferbefore" => EditCommand::PasteCutBufferBefore,
         "pastecutbufferafter" => EditCommand::PasteCutBufferAfter,
         "uppercaseword" => EditCommand::UppercaseWord,

crates/nu-cli/src/repl.rs

@@ -2,31 +2,40 @@ use crate::{
     completions::NuCompleter,
     prompt_update,
     reedline_config::{add_menus, create_keybindings, KeybindingsMode},
-    util::{eval_source, report_error},
+    util::{eval_source, get_guaranteed_cwd, report_error, report_error_new},
     NuHighlighter, NuValidator, NushellPrompt,
 };
-use log::{info, trace};
+use lazy_static::lazy_static;
+use log::{info, trace, warn};
 use miette::{IntoDiagnostic, Result};
 use nu_color_config::get_color_config;
 use nu_engine::{convert_env_values, eval_block};
-use nu_parser::lex;
+use nu_parser::{lex, parse};
 use nu_protocol::{
+    ast::PathMember,
     engine::{EngineState, Stack, StateWorkingSet},
-    BlockId, PipelineData, PositionalArg, ShellError, Span, Value,
+    BlockId, HistoryFileFormat, PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId,
 };
-use reedline::{DefaultHinter, Emacs, Vi};
+use reedline::{DefaultHinter, Emacs, SqliteBackedHistory, Vi};
+use regex::Regex;
 use std::io::{self, Write};
-use std::path::PathBuf;
 use std::{sync::atomic::Ordering, time::Instant};
+use sysinfo::SystemExt;
 
-const PRE_EXECUTE_MARKER: &str = "\x1b]133;A\x1b\\";
+// According to Daniel Imms @Tyriar, we need to do these this way:
-const PRE_PROMPT_MARKER: &str = "\x1b]133;C\x1b\\";
+// <133 A><prompt><133 B><command><133 C><command output>
+// These first two have been moved to prompt_update to get as close as possible to the prompt.
+// const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+// const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
+const PRE_EXECUTE_MARKER: &str = "\x1b]133;C\x1b\\";
+// This one is in get_command_finished_marker() now so we can capture the exit codes properly.
+// const CMD_FINISHED_MARKER: &str = "\x1b]133;D;{}\x1b\\";
 const RESET_APPLICATION_MODE: &str = "\x1b[?1l";
 
 pub fn evaluate_repl(
     engine_state: &mut EngineState,
     stack: &mut Stack,
-    history_path: Option<PathBuf>,
+    nushell_path: &str,
     is_perf_true: bool,
 ) -> Result<()> {
     use reedline::{FileBackedHistory, Reedline, Signal};
@@ -78,26 +87,38 @@ pub fn evaluate_repl(
 
     // Get the config once for the history `max_history_size`
     // Updating that will not be possible in one session
-    let mut config = engine_state.get_config();
+    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() {
         if is_perf_true {
             info!("setup history {}:{}:{}", file!(), line!(), column!());
         }
-        let history = Box::new(
+
-            FileBackedHistory::with_file(
+        let history: Box<dyn reedline::History> = match engine_state.config.history_file_format {
-                config.max_history_size as usize,
+            HistoryFileFormat::PlainText => Box::new(
-                history_path.to_path_buf(),
+                FileBackedHistory::with_file(
-            )
+                    config.max_history_size as usize,
-            .into_diagnostic()?,
+                    history_path.to_path_buf(),
-        );
+                )
+                .into_diagnostic()?,
+            ),
+            HistoryFileFormat::Sqlite => Box::new(
+                SqliteBackedHistory::with_file(history_path.to_path_buf()).into_diagnostic()?,
+            ),
+        };
         line_editor = line_editor.with_history(history);
     };
 
+    let sys = sysinfo::System::new();
+
     loop {
         if is_perf_true {
             info!(
@@ -108,12 +129,24 @@ pub fn evaluate_repl(
             );
         }
 
+        let cwd = get_guaranteed_cwd(engine_state, stack);
+
+        // Before doing anything, merge the environment from the previous REPL iteration into the
+        // permanent state.
+        if let Err(err) = engine_state.merge_env(stack, cwd) {
+            report_error_new(engine_state, &err);
+        }
+
         //Reset the ctrl-c handler
         if let Some(ctrlc) = &mut engine_state.ctrlc {
             ctrlc.store(false, Ordering::SeqCst);
         }
+        // Reset the SIGQUIT handler
+        if let Some(sig_quit) = engine_state.get_sig_quit() {
+            sig_quit.store(false, Ordering::SeqCst);
+        }
 
-        config = engine_state.get_config();
+        let config = engine_state.get_config();
 
         if is_perf_true {
             info!("setup colors {}:{}:{}", file!(), line!(), column!());
@@ -130,7 +163,6 @@ pub fn evaluate_repl(
                 engine_state: engine_state.clone(),
                 config: config.clone(),
             }))
-            .with_animation(config.animate_prompt)
             .with_validator(Box::new(NuValidator {
                 engine_state: engine_state.clone(),
             }))
@@ -184,7 +216,10 @@ pub fn evaluate_repl(
             if is_perf_true {
                 info!("sync history {}:{}:{}", file!(), line!(), column!());
             }
-            line_editor.sync_history().into_diagnostic()?;
+
+            if let Err(e) = line_editor.sync_history() {
+                warn!("Failed to sync history: {}", e);
+            }
         }
 
         if is_perf_true {
@@ -219,63 +254,22 @@ pub fn evaluate_repl(
 
         // 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 {
+        if let Some(hook) = config.hooks.pre_prompt.clone() {
-            if let Err(err) = run_hook(engine_state, stack, vec![], hook) {
+            if let Err(err) = eval_hook(engine_state, stack, vec![], &hook) {
-                let working_set = StateWorkingSet::new(engine_state);
+                report_error_new(engine_state, &err);
-                report_error(&working_set, &err);
             }
         }
 
         // Next, check all the environment variables they ask for
         // fire the "env_change" hook
-        if let Some(hook) = config.hooks.env_change.clone() {
+        let config = engine_state.get_config();
-            match hook {
+        if let Err(error) =
-                Value::Record {
+            eval_env_change_hook(config.hooks.env_change.clone(), engine_state, stack)
-                    cols, vals: blocks, ..
+        {
-                } => {
+            report_error_new(engine_state, &error)
-                    for (idx, env_var) in cols.iter().enumerate() {
-                        let before = engine_state
-                            .previous_env_vars
-                            .get(env_var)
-                            .cloned()
-                            .unwrap_or_default();
-                        let after = stack.get_env_var(engine_state, env_var).unwrap_or_default();
-                        if before != after {
-                            if let Err(err) = run_hook(
-                                engine_state,
-                                stack,
-                                vec![before, after.clone()],
-                                &blocks[idx],
-                            ) {
-                                let working_set = StateWorkingSet::new(engine_state);
-                                report_error(&working_set, &err);
-                            }
-
-                            engine_state
-                                .previous_env_vars
-                                .insert(env_var.to_string(), after);
-                        }
-                    }
-                }
-                x => {
-                    let working_set = StateWorkingSet::new(engine_state);
-                    report_error(
-                        &working_set,
-                        &ShellError::TypeMismatch(
-                            "record for 'env_change' hook".to_string(),
-                            x.span().unwrap_or_else(|_| Span::new(0, 0)),
-                        ),
-                    )
-                }
-            }
-        }
-
-        config = engine_state.get_config();
-
-        if config.shell_integration {
-            run_ansi_sequence(PRE_EXECUTE_MARKER)?;
         }
 
+        let config = engine_state.get_config();
         let prompt =
             prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt, is_perf_true);
 
@@ -291,37 +285,51 @@ pub fn evaluate_repl(
         }
 
         let input = line_editor.read_line(prompt);
+        let shell_integration = config.shell_integration;
 
         match input {
             Ok(Signal::Success(s)) => {
+                let history_supports_meta =
+                    matches!(config.history_file_format, HistoryFileFormat::Sqlite);
+                if history_supports_meta && !s.is_empty() {
+                    line_editor
+                        .update_last_command_context(&|mut c| {
+                            c.start_timestamp = Some(chrono::Utc::now());
+                            c.hostname = sys.host_name();
+
+                            c.cwd = Some(StateWorkingSet::new(engine_state).get_cwd());
+                            c
+                        })
+                        .into_diagnostic()?; // todo: don't stop repl if error here?
+                }
+
                 // Right before we start running the code the user gave us,
                 // fire the "pre_execution" hook
-                if let Some(hook) = &config.hooks.pre_execution {
+                if let Some(hook) = config.hooks.pre_execution.clone() {
-                    if let Err(err) = run_hook(engine_state, stack, vec![], hook) {
+                    if let Err(err) = eval_hook(engine_state, stack, vec![], &hook) {
-                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error_new(engine_state, &err);
-                        report_error(&working_set, &err);
                     }
                 }
 
-                if config.shell_integration {
+                if shell_integration {
                     run_ansi_sequence(RESET_APPLICATION_MODE)?;
-                    run_ansi_sequence(PRE_PROMPT_MARKER)?;
+                    run_ansi_sequence(PRE_EXECUTE_MARKER)?;
-                    if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                    // if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
-                        let path = cwd.as_string()?;
+                    //     let path = cwd.as_string()?;
-                        // Try to abbreviate string for windows title
+                    //     // Try to abbreviate string for windows title
-                        let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                    //     let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
-                            path.replace(&p.as_path().display().to_string(), "~")
+                    //         path.replace(&p.as_path().display().to_string(), "~")
-                        } else {
+                    //     } else {
-                            path
+                    //         path
-                        };
+                    //     };
 
-                        // Set window title too
+                    //     // Set window title too
-                        // https://tldp.org/HOWTO/Xterm-Title-3.html
+                    //     // https://tldp.org/HOWTO/Xterm-Title-3.html
-                        // ESC]0;stringBEL -- Set icon name and window title to string
+                    //     // ESC]0;stringBEL -- Set icon name and window title to string
-                        // ESC]1;stringBEL -- Set icon name to string
+                    //     // ESC]1;stringBEL -- Set icon name to string
-                        // ESC]2;stringBEL -- Set window title to string
+                    //     // ESC]2;stringBEL -- Set window title to string
-                        run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
+                    //     run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
-                    }
+                    // }
                 }
 
                 let start_time = Instant::now();
@@ -332,13 +340,7 @@ pub fn evaluate_repl(
 
                 let orig = s.clone();
 
-                if (orig.starts_with('.')
+                if looks_like_path(&orig) && path.is_dir() && tokens.0.len() == 1 {
-                    || orig.starts_with('~')
-                    || orig.starts_with('/')
-                    || orig.starts_with('\\'))
-                    && path.is_dir()
-                    && tokens.0.len() == 1
-                {
                     // We have an auto-cd
                     let (path, span) = {
                         if !path.exists() {
@@ -354,6 +356,14 @@ pub fn evaluate_repl(
                         (path.to_string_lossy().to_string(), tokens.0[0].span)
                     };
 
+                    stack.add_env_var(
+                        "OLDPWD".into(),
+                        Value::String {
+                            val: cwd.clone(),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+
                     //FIXME: this only changes the current scope, but instead this environment variable
                     //should probably be a block that loads the information from the state in the overlay
                     stack.add_env_var(
@@ -395,28 +405,59 @@ pub fn evaluate_repl(
                         PipelineData::new(Span::new(0, 0)),
                     );
                 }
+                let cmd_duration = start_time.elapsed();
 
                 stack.add_env_var(
                     "CMD_DURATION_MS".into(),
                     Value::String {
-                        val: format!("{}", start_time.elapsed().as_millis()),
+                        val: format!("{}", cmd_duration.as_millis()),
                         span: Span { start: 0, end: 0 },
                     },
                 );
 
-                // FIXME: permanent state changes like this hopefully in time can be removed
+                if history_supports_meta && !s.is_empty() {
-                // and be replaced by just passing the cwd in where needed
+                    line_editor
-                if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                        .update_last_command_context(&|mut c| {
-                    let path = cwd.as_string()?;
+                            c.duration = Some(cmd_duration);
-                    let _ = std::env::set_current_dir(path);
+                            c.exit_status = stack
-                    engine_state.add_env_var("PWD".into(), cwd);
+                                .get_env_var(engine_state, "LAST_EXIT_CODE")
+                                .and_then(|e| e.as_i64().ok());
+                            c
+                        })
+                        .into_diagnostic()?; // todo: don't stop repl if error here?
+                }
+
+                if shell_integration {
+                    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()?;
+                        // 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))?;
+                    }
                 }
             }
             Ok(Signal::CtrlC) => {
                 // `Reedline` clears the line content. New prompt is shown
+                if shell_integration {
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
+                }
             }
             Ok(Signal::CtrlD) => {
                 // When exiting clear to a new line
+                if shell_integration {
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
+                }
                 println!();
                 break;
             }
@@ -425,6 +466,9 @@ pub fn evaluate_repl(
                 if !message.contains("duration") {
                     println!("Error: {:?}", err);
                 }
+                if shell_integration {
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
+                }
             }
         }
     }
@@ -432,6 +476,285 @@ pub fn evaluate_repl(
     Ok(())
 }
 
+pub fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
+    let exit_code = stack
+        .get_env_var(engine_state, "LAST_EXIT_CODE")
+        .and_then(|e| e.as_i64().ok());
+
+    format!("\x1b]133;D;{}\x1b\\", exit_code.unwrap_or(0))
+}
+
+pub fn eval_env_change_hook(
+    env_change_hook: Option<Value>,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+) -> Result<(), ShellError> {
+    if let Some(hook) = env_change_hook {
+        match hook {
+            Value::Record {
+                cols: env_names,
+                vals: hook_values,
+                ..
+            } => {
+                for (env_name, hook_value) in env_names.iter().zip(hook_values.iter()) {
+                    let before = engine_state
+                        .previous_env_vars
+                        .get(env_name)
+                        .cloned()
+                        .unwrap_or_default();
+
+                    let after = stack
+                        .get_env_var(engine_state, env_name)
+                        .unwrap_or_default();
+
+                    if before != after {
+                        eval_hook(
+                            engine_state,
+                            stack,
+                            vec![("$before".into(), before), ("$after".into(), after.clone())],
+                            hook_value,
+                        )?;
+
+                        engine_state
+                            .previous_env_vars
+                            .insert(env_name.to_string(), after);
+                    }
+                }
+            }
+            x => {
+                return Err(ShellError::TypeMismatch(
+                    "record for the 'env_change' hook".to_string(),
+                    x.span()?,
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn eval_hook(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    arguments: Vec<(String, Value)>,
+    value: &Value,
+) -> Result<(), ShellError> {
+    let value_span = value.span()?;
+
+    let condition_path = PathMember::String {
+        val: "condition".to_string(),
+        span: value_span,
+    };
+
+    let code_path = PathMember::String {
+        val: "code".to_string(),
+        span: value_span,
+    };
+
+    match value {
+        Value::List { vals, .. } => {
+            for val in vals {
+                eval_hook(engine_state, stack, arguments.clone(), val)?
+            }
+        }
+        Value::Record { .. } => {
+            let do_run_hook =
+                if let Ok(condition) = value.clone().follow_cell_path(&[condition_path], false) {
+                    match condition {
+                        Value::Block {
+                            val: block_id,
+                            span: block_span,
+                            ..
+                        } => {
+                            match run_hook_block(
+                                engine_state,
+                                stack,
+                                block_id,
+                                arguments.clone(),
+                                block_span,
+                            ) {
+                                Ok(value) => match value {
+                                    Value::Bool { val, .. } => val,
+                                    other => {
+                                        return Err(ShellError::UnsupportedConfigValue(
+                                            "boolean output".to_string(),
+                                            format!("{}", other.get_type()),
+                                            other.span()?,
+                                        ));
+                                    }
+                                },
+                                Err(err) => {
+                                    return Err(err);
+                                }
+                            }
+                        }
+                        other => {
+                            return Err(ShellError::UnsupportedConfigValue(
+                                "block".to_string(),
+                                format!("{}", other.get_type()),
+                                other.span()?,
+                            ));
+                        }
+                    }
+                } else {
+                    // always run the hook
+                    true
+                };
+
+            if do_run_hook {
+                match value.clone().follow_cell_path(&[code_path], false)? {
+                    Value::String {
+                        val,
+                        span: source_span,
+                    } => {
+                        let (block, delta, vars) = {
+                            let mut working_set = StateWorkingSet::new(engine_state);
+
+                            let mut vars: Vec<(VarId, Value)> = vec![];
+
+                            for (name, val) in arguments {
+                                let var_id = working_set.add_variable(
+                                    name.as_bytes().to_vec(),
+                                    val.span()?,
+                                    Type::Any,
+                                );
+
+                                vars.push((var_id, val));
+                            }
+
+                            let (output, err) =
+                                parse(&mut working_set, Some("hook"), val.as_bytes(), false, &[]);
+                            if let Some(err) = err {
+                                report_error(&working_set, &err);
+
+                                return Err(ShellError::UnsupportedConfigValue(
+                                    "valid source code".into(),
+                                    "source code with syntax errors".into(),
+                                    source_span,
+                                ));
+                            }
+
+                            (output, working_set.render(), vars)
+                        };
+
+                        engine_state.merge_delta(delta)?;
+                        let input = PipelineData::new(value_span);
+
+                        let var_ids: Vec<VarId> = vars
+                            .into_iter()
+                            .map(|(var_id, val)| {
+                                stack.add_var(var_id, val);
+                                var_id
+                            })
+                            .collect();
+
+                        match eval_block(engine_state, stack, &block, input, false, false) {
+                            Ok(_) => {}
+                            Err(err) => {
+                                report_error_new(engine_state, &err);
+                            }
+                        }
+
+                        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, arguments, block_span)?;
+                        let cwd = get_guaranteed_cwd(engine_state, stack);
+                        engine_state.merge_env(stack, cwd)?;
+                    }
+                    other => {
+                        return Err(ShellError::UnsupportedConfigValue(
+                            "block or string".to_string(),
+                            format!("{}", other.get_type()),
+                            other.span()?,
+                        ));
+                    }
+                }
+            }
+        }
+        Value::Block {
+            val: block_id,
+            span: block_span,
+            ..
+        } => {
+            run_hook_block(engine_state, stack, *block_id, arguments, *block_span)?;
+        }
+        other => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "block, record, or list of records".into(),
+                format!("{}", other.get_type()),
+                other.span()?,
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+pub fn run_hook_block(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    block_id: BlockId,
+    arguments: Vec<(String, Value)>,
+    span: Span,
+) -> Result<Value, ShellError> {
+    let block = engine_state.get_block(block_id);
+
+    let input = PipelineData::new(span);
+
+    let mut callee_stack = stack.gather_captures(&block.captures);
+
+    for (idx, PositionalArg { var_id, .. }) in
+        block.signature.required_positional.iter().enumerate()
+    {
+        if let Some(var_id) = var_id {
+            if let Some(arg) = arguments.get(idx) {
+                callee_stack.add_var(*var_id, arg.1.clone())
+            } else {
+                return Err(ShellError::IncompatibleParametersSingle(
+                    "This hook block has too many parameters".into(),
+                    span,
+                ));
+            }
+        }
+    }
+
+    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);
+
+                // 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);
+                }
+
+                Ok(val)
+            }
+        },
+        Err(err) => Err(err),
+    }
+}
+
 fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
     match io::stdout().write_all(seq.as_bytes()) {
         Ok(it) => it,
@@ -456,62 +779,33 @@ fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
     })
 }
 
-pub fn run_hook(
+lazy_static! {
-    engine_state: &EngineState,
+    // Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
-    stack: &mut Stack,
+    static ref DRIVE_PATH_REGEX: Regex =
-    arguments: Vec<Value>,
+        Regex::new(r"^[a-zA-Z]:[/\\]?").expect("Internal error: regex creation");
-    value: &Value,
-) -> Result<(), ShellError> {
-    match value {
-        Value::List { vals, .. } => {
-            for val in vals {
-                run_hook(engine_state, stack, arguments.clone(), val)?
-            }
-            Ok(())
-        }
-        Value::Block {
-            val: block_id,
-            span,
-            ..
-        } => run_hook_block(engine_state, stack, *block_id, arguments, *span),
-        x => match x.span() {
-            Ok(span) => Err(ShellError::MissingConfigValue(
-                "block for hook in config".into(),
-                span,
-            )),
-            _ => Err(ShellError::MissingConfigValue(
-                "block for hook in config".into(),
-                Span { start: 0, end: 0 },
-            )),
-        },
-    }
 }
 
-pub fn run_hook_block(
+// A best-effort "does this string look kinda like a path?" function to determine whether to auto-cd
-    engine_state: &EngineState,
+fn looks_like_path(orig: &str) -> bool {
-    stack: &mut Stack,
+    #[cfg(windows)]
-    block_id: BlockId,
-    arguments: Vec<Value>,
-    span: Span,
-) -> Result<(), ShellError> {
-    let block = engine_state.get_block(block_id);
-    let input = PipelineData::new(span);
-
-    let mut callee_stack = stack.gather_captures(&block.captures);
-
-    for (idx, PositionalArg { var_id, .. }) in
-        block.signature.required_positional.iter().enumerate()
     {
-        if let Some(var_id) = var_id {
+        if DRIVE_PATH_REGEX.is_match(orig) {
-            callee_stack.add_var(*var_id, arguments[idx].clone())
+            return true;
         }
     }
 
-    match eval_block(engine_state, &mut callee_stack, block, input, false, false) {
+    orig.starts_with('.')
-        Ok(pipeline_data) => match pipeline_data.into_value(span) {
+        || orig.starts_with('~')
-            Value::Error { error } => Err(error),
+        || orig.starts_with('/')
-            _ => Ok(()),
+        || orig.starts_with('\\')
-        },
+}
-        Err(err) => Err(err),
+
-    }
+#[test]
+fn looks_like_path_windows_drive_path_works() {
+    let on_windows = cfg!(windows);
+    assert_eq!(looks_like_path("C:"), on_windows);
+    assert_eq!(looks_like_path("D:\\"), on_windows);
+    assert_eq!(looks_like_path("E:/"), on_windows);
+    assert_eq!(looks_like_path("F:\\some_dir"), on_windows);
+    assert_eq!(looks_like_path("G:/some_dir"), on_windows);
 }

crates/nu-cli/src/util.rs

@@ -9,18 +9,35 @@ use nu_protocol::{
 };
 #[cfg(windows)]
 use nu_utils::enable_vt_processing;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 // This will collect environment variables from std::env and adds them to a stack.
 //
 // In order to ensure the values have spans, it first creates a dummy file, writes the collected
 // env vars into it (in a "NAME"="value" format, quite similar to the output of the Unix 'env'
 // tool), then uses the file to get the spans. The file stays in memory, no filesystem IO is done.
-pub fn gather_parent_env_vars(engine_state: &mut EngineState) {
+//
-    gather_env_vars(std::env::vars(), engine_state);
+// The "PWD" env value will be forced to `init_cwd`.
+// The reason to use `init_cwd`:
+//
+// While gathering parent env vars, the parent `PWD` may not be the same as `current working directory`.
+// Consider to the following command as the case (assume we execute command inside `/tmp`):
+//
+//     tmux split-window -v -c "#{pane_current_path}"
+//
+// Here nu execute external command `tmux`, and tmux starts a new `nushell`, with `init_cwd` value "#{pane_current_path}".
+// But at the same time `PWD` still remains to be `/tmp`.
+//
+// In this scenario, the new `nushell`'s PWD should be "#{pane_current_path}" rather init_cwd.
+pub fn gather_parent_env_vars(engine_state: &mut EngineState, init_cwd: &Path) {
+    gather_env_vars(std::env::vars(), engine_state, init_cwd);
 }
 
-fn gather_env_vars(vars: impl Iterator<Item = (String, String)>, engine_state: &mut EngineState) {
+fn gather_env_vars(
+    vars: impl Iterator<Item = (String, String)>,
+    engine_state: &mut EngineState,
+    init_cwd: &Path,
+) {
     fn report_capture_error(engine_state: &EngineState, env_str: &str, msg: &str) {
         let working_set = StateWorkingSet::new(engine_state);
         report_error(
@@ -43,35 +60,31 @@ fn gather_env_vars(vars: impl Iterator<Item = (String, String)>, engine_state: &
     }
 
     let mut fake_env_file = String::new();
-    let mut has_pwd = false;
-
     // Write all the env vars into a fake file
     for (name, val) in vars {
-        if name == "PWD" {
-            has_pwd = true;
-        }
         put_env_to_fake_file(&name, &val, &mut fake_env_file);
     }
 
-    if !has_pwd {
+    match init_cwd.to_str() {
-        match std::env::current_dir() {
+        Some(cwd) => {
-            Ok(cwd) => {
+            put_env_to_fake_file("PWD", cwd, &mut fake_env_file);
-                put_env_to_fake_file("PWD", &cwd.to_string_lossy(), &mut fake_env_file);
+        }
-            }
+        None => {
-            Err(e) => {
+            // Could not capture current working directory
-                // Could not capture current working directory
+            let working_set = StateWorkingSet::new(engine_state);
-                let working_set = StateWorkingSet::new(engine_state);
+            report_error(
-                report_error(
+                &working_set,
-                    &working_set,
+                &ShellError::GenericError(
-                    &ShellError::GenericError(
+                    "Current directory is not a valid utf-8 path".to_string(),
-                        "Current directory not found".to_string(),
+                    "".to_string(),
-                        "".to_string(),
+                    None,
-                        None,
+                    Some(format!(
-                        Some(format!("Retrieving current directory failed: {:?}", e)),
+                        "Retrieving current directory failed: {:?} not a valid utf-8 path",
-                        Vec::new(),
+                        init_cwd
-                    ),
+                    )),
-                );
+                    Vec::new(),
-            }
+                ),
+            );
         }
     }
 
@@ -211,16 +224,11 @@ pub fn eval_source(
         (output, working_set.render())
     };
 
-    let cwd = match nu_engine::env::current_dir(engine_state, stack) {
+    if let Err(err) = engine_state.merge_delta(delta) {
-        Ok(p) => p,
+        set_last_exit_code(stack, 1);
-        Err(e) => {
+        report_error_new(engine_state, &err);
-            let working_set = StateWorkingSet::new(engine_state);
+        return false;
-            report_error(&working_set, &e);
+    }
-            get_init_cwd()
-        }
-    };
-
-    let _ = engine_state.merge_delta(delta, Some(stack), &cwd);
 
     match eval_block(engine_state, stack, &block, input, false, false) {
         Ok(mut pipeline_data) => {
@@ -234,7 +242,7 @@ pub fn eval_source(
                 set_last_exit_code(stack, 0);
             }
 
-            if let Err(err) = pipeline_data.print(engine_state, stack, false) {
+            if let Err(err) = pipeline_data.print(engine_state, stack, false, false) {
                 let working_set = StateWorkingSet::new(engine_state);
 
                 report_error(&working_set, &err);
@@ -284,6 +292,15 @@ pub fn report_error(
     }
 }
 
+pub fn report_error_new(
+    engine_state: &EngineState,
+    error: &(dyn miette::Diagnostic + Send + Sync + 'static),
+) {
+    let working_set = StateWorkingSet::new(engine_state);
+
+    report_error(&working_set, error);
+}
+
 pub fn get_init_cwd() -> PathBuf {
     match std::env::current_dir() {
         Ok(cwd) => cwd,
@@ -297,6 +314,17 @@ pub fn get_init_cwd() -> PathBuf {
     }
 }
 
+pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
+    match nu_engine::env::current_dir(engine_state, stack) {
+        Ok(p) => p,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            get_init_cwd()
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -314,6 +342,7 @@ mod test {
             ]
             .into_iter(),
             &mut engine_state,
+            Path::new("t"),
         );
 
         let env = engine_state.render_env_vars();

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

@@ -2,10 +2,24 @@ pub mod support;
 
 use nu_cli::NuCompleter;
 use reedline::Completer;
+use rstest::{fixture, rstest};
 use support::{match_suggestions, new_engine};
 
-#[test]
+#[fixture]
-fn variables_completions() {
+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();
 
@@ -14,16 +28,42 @@ fn variables_completions() {
     def my-command [animal: string@animals] { print $animal }"#;
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
-    // Instatiate a new completer
+    // Instantiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
 
-    // Test completions for $nu
+#[rstest]
-    let suggestions = completer.complete("my-command ".into(), 11);
+fn variables_completions_double_dash_argument(mut completer: NuCompleter) {
-
+    let suggestions = completer.complete("tst --", 6);
-    assert_eq!(3, suggestions.len());
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into()];
-
+    // dbg!(&expected, &suggestions);
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
-
+}
-    // Match results
+
+#[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/file_completions.rs

@@ -30,8 +30,8 @@ fn file_completions() {
     // Match the results
     match_suggestions(expected_paths, suggestions);
 
-    // Test completions for the completions/another folder
+    // Test completions for a file
-    let target_dir = format!("cd {}", folder(dir.join("another")));
+    let target_dir = format!("cp {}", folder(dir.join("another")));
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values
@@ -40,3 +40,233 @@ fn file_completions() {
     // 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

@@ -12,17 +12,19 @@ fn flag_completions() {
     // 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 -".into(), 4);
+    let suggestions = completer.complete("ls -", 4);
 
-    assert_eq!(12, suggestions.len());
+    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(),

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

@@ -4,7 +4,7 @@ use nu_command::create_default_context;
 use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_protocol::{
-    engine::{EngineState, Stack, StateDelta, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
     PipelineData, ShellError, Span, Value,
 };
 use nu_test_support::fs;
@@ -23,14 +23,11 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
     dir_str.push(SEP);
 
     // Create a new engine with default context
-    let mut engine_state = create_default_context(&dir);
+    let mut engine_state = create_default_context();
 
     // New stack
     let mut stack = Stack::new();
 
-    // New delta state
-    let delta = StateDelta::new(&engine_state);
-
     // Add pwd as env var
     stack.add_env_var(
         "PWD".to_string(),
@@ -42,9 +39,19 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
             },
         },
     );
+    stack.add_env_var(
+        "TEST".to_string(),
+        Value::String {
+            val: "NUSHELL".to_string(),
+            span: nu_protocol::Span {
+                start: 0,
+                end: dir_str.len(),
+            },
+        },
+    );
 
-    // Merge delta
+    // Merge environment into the permanent state
-    let merge_result = engine_state.merge_delta(delta, Some(&mut stack), &dir);
+    let merge_result = engine_state.merge_env(&mut stack, &dir);
     assert!(merge_result.is_ok());
 
     (dir, dir_str, engine_state, stack)
@@ -52,6 +59,15 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
 
 // match a list of suggestions with the expected values
 pub fn match_suggestions(expected: Vec<String>, suggestions: Vec<Suggestion>) {
+    let expected_len = expected.len();
+    let suggestions_len = suggestions.len();
+    if expected_len != suggestions_len {
+        panic!(
+            "\nexpected {expected_len} suggestions but got {suggestions_len}: \n\
+            Suggestions: {suggestions:#?} \n\
+            Expected: {expected:#?}\n"
+        )
+    }
     expected.iter().zip(suggestions).for_each(|it| {
         assert_eq!(it.0, &it.1.value);
     });
@@ -79,7 +95,7 @@ pub fn merge_input(
     dir: PathBuf,
 ) -> Result<(), ShellError> {
     let (block, delta) = {
-        let mut working_set = StateWorkingSet::new(&engine_state);
+        let mut working_set = StateWorkingSet::new(engine_state);
 
         let (block, err) = parse(&mut working_set, None, input, false, &[]);
 
@@ -87,8 +103,13 @@ pub fn merge_input(
 
         (block, working_set.render())
     };
+
+    if let Err(err) = engine_state.merge_delta(delta) {
+        return Err(err);
+    }
+
     assert!(eval_block(
-        &engine_state,
+        engine_state,
         stack,
         &block,
         PipelineData::Value(
@@ -102,6 +123,6 @@ pub fn merge_input(
     )
     .is_ok());
 
-    // Merge delta
+    // Merge environment into the permanent state
-    engine_state.merge_delta(delta, Some(stack), &dir)
+    engine_state.merge_env(stack, &dir)
 }

crates/nu-cli/tests/variables_completions.rs

@@ -17,15 +17,16 @@ fn variables_completions() {
     let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
 
     // Test completions for $nu
-    let suggestions = completer.complete("$nu.".into(), 4);
+    let suggestions = completer.complete("$nu.", 4);
 
-    assert_eq!(8, suggestions.len());
+    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(),
@@ -35,8 +36,18 @@ fn variables_completions() {
     // 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.".into(), 7);
+    let suggestions = completer.complete("$actor.", 7);
 
     assert_eq!(2, suggestions.len());
 
@@ -45,12 +56,32 @@ fn variables_completions() {
     // Match results
     match_suggestions(expected, suggestions);
 
-    // Test completions for $env
+    // Test completions for custom var (filtering)
-    let suggestions = completer.complete("$env.".into(), 5);
+    let suggestions = completer.complete("$actor.n", 8);
 
     assert_eq!(1, suggestions.len());
 
-    let expected: Vec<String> = vec!["PWD".into()];
+    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

@@ -4,11 +4,11 @@ description = "Color configuration code used by Nushell"
 edition = "2021"
 license = "MIT"
 name = "nu-color-config"
-version = "0.63.0"
+version = "0.66.0"
 
 [dependencies]
-nu-protocol = { path = "../nu-protocol", version = "0.63.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.0"  }
-nu-ansi-term = "0.45.1"
+nu-ansi-term = "0.46.0"
-nu-json = { path = "../nu-json", version = "0.63.0"  }
+nu-json = { path = "../nu-json", version = "0.66.0"  }
-nu-table = { path = "../nu-table", version = "0.63.0"  }
+nu-table = { path = "../nu-table", version = "0.66.0"  }
 serde = { version="1.0.123", features=["derive"] }

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

@@ -1,7 +1,7 @@
 use nu_ansi_term::{Color, Style};
 use serde::Deserialize;
 
-#[derive(Deserialize, PartialEq, Debug)]
+#[derive(Deserialize, PartialEq, Eq, Debug)]
 pub struct NuStyle {
     pub fg: Option<String>,
     pub bg: Option<String>,

crates/nu-command/Cargo.toml

@@ -4,30 +4,31 @@ description = "Nushell's built-in commands"
 edition = "2021"
 license = "MIT"
 name = "nu-command"
-version = "0.63.0"
+version = "0.66.0"
 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.63.0"  }
+nu-color-config = { path = "../nu-color-config", version = "0.66.0"  }
-nu-engine = { path = "../nu-engine", version = "0.63.0"  }
+nu-engine = { path = "../nu-engine", version = "0.66.0"  }
-nu-glob = { path = "../nu-glob", version = "0.63.0" }
+nu-glob = { path = "../nu-glob", version = "0.66.0" }
-nu-json = { path = "../nu-json", version = "0.63.0"  }
+nu-json = { path = "../nu-json", version = "0.66.0"  }
-nu-parser = { path = "../nu-parser", version = "0.63.0"  }
+nu-parser = { path = "../nu-parser", version = "0.66.0"  }
-nu-path = { path = "../nu-path", version = "0.63.0"  }
+nu-path = { path = "../nu-path", version = "0.66.0"  }
-nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.63.0"  }
+nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.66.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.63.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.0"  }
-nu-system = { path = "../nu-system", version = "0.63.0"  }
+nu-system = { path = "../nu-system", version = "0.66.0"  }
-nu-table = { path = "../nu-table", version = "0.63.0"  }
+nu-table = { path = "../nu-table", version = "0.66.0"  }
-nu-term-grid = { path = "../nu-term-grid", version = "0.63.0"  }
+nu-term-grid = { path = "../nu-term-grid", version = "0.66.0"  }
-nu-test-support = { path = "../nu-test-support", version = "0.63.0"  }
+nu-test-support = { path = "../nu-test-support", version = "0.66.0"  }
-nu-utils = { path = "../nu-utils", version = "0.63.0" }
+nu-utils = { path = "../nu-utils", version = "0.66.0" }
-nu-ansi-term = "0.45.1"
+nu-ansi-term = "0.46.0"
 
 # Potential dependencies for extras
 alphanumeric-sort = "1.4.4"
 base64 = "0.13.0"
+byteorder = "1.4.3"
 bytesize = "1.1.0"
 calamine = "0.18.0"
 chrono = { version = "0.4.19", features = ["serde"] }
@@ -47,18 +48,19 @@ htmlescape = "0.3.1"
 ical = "0.7.0"
 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.9.0", features = ["crossterm"]}
+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 }
 pathdiff = "0.2.1"
-powierza-coefficient = "1.0"
+powierza-coefficient = "1.0.1"
-quick-xml = "0.22"
+quick-xml = "0.23.0"
 rand = "0.8"
 rayon = "1.5.1"
 regex = "1.5.4"
@@ -71,20 +73,20 @@ serde_urlencoded = "0.7.0"
 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.11.0", default-features = false }
+shadow-rs = { version = "0.16.1", default-features = false }
 strip-ansi-escapes = "0.1.1"
-sysinfo = "0.23.5"
+sysinfo = "0.24.6"
-terminal_size = "0.1.17"
+terminal_size = "0.2.1"
-thiserror = "1.0.29"
+thiserror = "1.0.31"
-titlecase = "1.1.0"
+titlecase = "2.0.0"
 toml = "0.5.8"
 unicode-segmentation = "1.8.0"
 url = "2.2.1"
-uuid = { version = "0.8.2", features = ["v4"] }
+uuid = { version = "1.1.2", features = ["v4"] }
 which = { version = "4.2.2", optional = true }
-reedline = { version = "0.6.0", features = ["bashisms"]}
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
-wax = { version =  "0.4.0", features = ["diagnostics"] }
+wax = { version =  "0.5.0", features = ["diagnostics"] }
-rusqlite = { version = "0.27.0", features = ["bundled"], optional = true }
+rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }
 sqlparser = { version = "0.16.0", features = ["serde"], optional = true }
 
 [target.'cfg(unix)'.dependencies]
@@ -96,15 +98,24 @@ version = "2.1.3"
 optional = true
 
 [dependencies.polars]
-version = "0.21.1"
+version = "0.22.8"
 # path = "../../../../polars/polars"
 optional = true
 features = [
 	"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",
+    "dtype-datetime", "dtype-struct", "lazy", "cross_join",
-	"dynamic_groupby"
+	"dynamic_groupby", "dtype-categorical", "concat_str"
+]
+
+[target.'cfg(windows)'.dependencies.windows]
+version = "0.37.0"
+features = [
+    "alloc",
+    "Win32_Foundation",
+    "Win32_Storage_FileSystem",
+	"Win32_System_SystemServices",
 ]
 
 [features]
@@ -115,10 +126,11 @@ dataframe = ["polars", "num"]
 database = ["sqlparser", "rusqlite"]
 
 [build-dependencies]
-shadow-rs = { version = "0.11.0", default-features = false }
+shadow-rs = { version = "0.16.1", default-features = false }
 
 [dev-dependencies]
 hamcrest2 = "0.3.0"
 dirs-next = "2.0.0"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
+rstest = "0.15.0"

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

@@ -0,0 +1,167 @@
+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, Value};
+
+struct Arguments {
+    added_data: Vec<u8>,
+    index: Option<usize>,
+    end: bool,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesAdd;
+
+impl Command for BytesAdd {
+    fn name(&self) -> &str {
+        "bytes add"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes add")
+            .required("data", SyntaxShape::Binary, "the binary to add")
+            .named(
+                "index",
+                SyntaxShape::Int,
+                "index to insert binary data",
+                Some('i'),
+            )
+            .switch("end", "add to the end of binary", Some('e'))
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "add specified bytes to the input"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["append", "truncate", "padding"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let added_data: Vec<u8> = call.req(engine_state, stack, 0)?;
+        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");
+
+        let arg = Arguments {
+            added_data,
+            index,
+            end,
+            column_paths,
+        };
+        operate(add, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Add bytes `0x[AA]` to `0x[1F FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes add 0x[AA]",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0x1F, 0xFF, 0xAA, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[AA BB]` to `0x[1F FF AA AA]` at index 1",
+                example: "0x[1F FF AA AA] | bytes add 0x[AA BB] -i 1",
+                result: Some(Value::Binary {
+                    val: vec![0x1F, 0xAA, 0xBB, 0xFF, 0xAA, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[11]` to `0x[FF AA AA]` at the end",
+                example: "0x[FF AA AA] | bytes add 0x[11] -e",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0xAA, 0x11],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[11 22 33]` to `0x[FF AA AA]` at the end, at index 1(the index is start from end)",
+                example: "0x[FF AA BB] | bytes add 0x[11 22 33] -e -i 1",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0x11, 0x22, 0x33, 0xBB],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn add(input: &[u8], args: &Arguments, span: Span) -> Value {
+    match args.index {
+        None => {
+            if args.end {
+                let mut added_data = args.added_data.clone();
+                let mut result = input.to_vec();
+                result.append(&mut added_data);
+                Value::Binary { val: result, span }
+            } else {
+                let mut result = args.added_data.clone();
+                let mut input = input.to_vec();
+                result.append(&mut input);
+                Value::Binary { val: result, span }
+            }
+        }
+        Some(mut indx) => {
+            let inserted_index = if args.end {
+                input.len().saturating_sub(indx)
+            } else {
+                if indx > input.len() {
+                    indx = input.len()
+                }
+                indx
+            };
+            let mut result = vec![];
+            let mut prev_data = input[..inserted_index].to_vec();
+            result.append(&mut prev_data);
+            let mut added_data = args.added_data.clone();
+            result.append(&mut added_data);
+            let mut after_data = input[inserted_index..].to_vec();
+            result.append(&mut after_data);
+            Value::Binary { val: result, span }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesAdd {})
+    }
+}

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

@@ -0,0 +1,281 @@
+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, Value,
+};
+use std::cmp::Ordering;
+
+#[derive(Clone)]
+pub struct BytesAt;
+
+struct Arguments {
+    start: isize,
+    end: isize,
+    arg_span: Span,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+/// ensure given `range` is valid, and returns [start, end, val_span] pair.
+fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellError> {
+    let (start, end, span) = match range {
+        Value::List { mut vals, span } => {
+            if vals.len() != 2 {
+                return Err(ShellError::UnsupportedInput(
+                    "More than two indices given".to_string(),
+                    span,
+                ));
+            } else {
+                let end = vals.pop().expect("Already check has size 2");
+                let end = match end {
+                    Value::Int { val, .. } => val.to_string(),
+                    Value::String { val, .. } => val,
+                    other => {
+                        return Err(ShellError::UnsupportedInput(
+                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            other.span().unwrap_or(head),
+                        ))
+                    }
+                };
+                let start = vals.pop().expect("Already check has size 1");
+                let start = match start {
+                    Value::Int { val, .. } => val.to_string(),
+                    Value::String { val, .. } => val,
+                    other => {
+                        return Err(ShellError::UnsupportedInput(
+                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            other.span().unwrap_or(head),
+                        ))
+                    }
+                };
+                (start, end, span)
+            }
+        }
+        Value::String { val, span } => {
+            let splitted_result = val.split_once(',');
+            match splitted_result {
+                Some((start, end)) => (start.to_string(), end.to_string(), span),
+                None => {
+                    return Err(ShellError::UnsupportedInput(
+                        "could not perform subbytes".to_string(),
+                        span,
+                    ))
+                }
+            }
+        }
+        other => {
+            return Err(ShellError::UnsupportedInput(
+                "could not perform subbytes".to_string(),
+                other.span().unwrap_or(head),
+            ))
+        }
+    };
+
+    let start: isize = if start.is_empty() || start == "_" {
+        0
+    } else {
+        match start.trim().parse() {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(ShellError::UnsupportedInput(
+                    "could not perform subbytes".to_string(),
+                    span,
+                ))
+            }
+        }
+    };
+    let end: isize = if end.is_empty() || end == "_" {
+        isize::max_value()
+    } else {
+        match end.trim().parse() {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(ShellError::UnsupportedInput(
+                    "could not perform subbytes".to_string(),
+                    span,
+                ))
+            }
+        }
+    };
+    Ok((start, end, span))
+}
+
+impl Command for BytesAt {
+    fn name(&self) -> &str {
+        "bytes at"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes at")
+            .required("range", SyntaxShape::Any, "the indexes to get bytes")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally get bytes by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Get bytes defined by a range. Note that the start is included but the end is excluded, and that the first byte is index 0."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["slice"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let range: Value = call.req(engine_state, stack, 0)?;
+        let (start, end, arg_span) = parse_range(range, call.head)?;
+        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,
+            column_paths,
+        };
+        operate(at, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get a subbytes `0x[10 01]` from the bytes `0x[33 44 55 10 01 13]`",
+                example: " 0x[33 44 55 10 01 13] | bytes at [3 4]",
+                result: Some(Value::Binary {
+                    val: vec![0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Alternatively, you can use the form",
+                example: " 0x[33 44 55 10 01 13] | bytes at '3,4'",
+                result: Some(Value::Binary {
+                    val: vec![0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Drop the last `n` characters from the string",
+                example: " 0x[33 44 55 10 01 13] | bytes at ',-3'",
+                result: Some(Value::Binary {
+                    val: vec![0x33, 0x44, 0x55],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Get the remaining characters from a starting index",
+                example: " 0x[33 44 55 10 01 13] | bytes at '3,'",
+                result: Some(Value::Binary {
+                    val: vec![0x10, 0x01, 0x13],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Get the characters from the beginning until ending index",
+                example: " 0x[33 44 55 10 01 13] | bytes at ',4'",
+                result: Some(Value::Binary {
+                    val: vec![0x33, 0x44, 0x55, 0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description:
+                    "Or the characters from the beginning until ending index inside a table",
+                example: r#" [[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes at "1," ColB ColC"#,
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x11, 0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn at(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let len: isize = input.len() as isize;
+
+    let start: isize = if arg.start < 0 {
+        arg.start + len
+    } else {
+        arg.start
+    };
+    let end: isize = if arg.end < 0 {
+        std::cmp::max(len + arg.end, 0)
+    } else {
+        arg.end
+    };
+
+    if start < len && end >= 0 {
+        match start.cmp(&end) {
+            Ordering::Equal => Value::Binary { val: vec![], span },
+            Ordering::Greater => Value::Error {
+                error: ShellError::UnsupportedInput(
+                    "End must be greater than or equal to Start".to_string(),
+                    arg.arg_span,
+                ),
+            },
+            Ordering::Less => Value::Binary {
+                val: {
+                    let input_iter = input.iter().copied().skip(start as usize);
+                    if end == isize::max_value() {
+                        input_iter.collect()
+                    } else {
+                        input_iter.take((end - start) as usize).collect()
+                    }
+                },
+                span,
+            },
+        }
+    } else {
+        Value::Binary { val: vec![], span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesAt {})
+    }
+}

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

@@ -0,0 +1,81 @@
+use nu_engine::eval_expression;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone)]
+pub struct BytesBuild;
+
+impl Command for BytesBuild {
+    fn name(&self) -> &str {
+        "bytes build"
+    }
+
+    fn usage(&self) -> &str {
+        "Create bytes from the arguments."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["concatenate", "join"]
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("bytes build")
+            .rest("rest", SyntaxShape::Any, "list of bytes")
+            .category(Category::Bytes)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            example: "bytes build 0x[01 02] 0x[03] 0x[04]",
+            description: "Builds binary data from 0x[01 02], 0x[03], 0x[04]",
+            result: Some(Value::Binary {
+                val: vec![0x01, 0x02, 0x03, 0x04],
+                span: Span::test_data(),
+            }),
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let mut output = vec![];
+        for expr in call.positional_iter() {
+            let val = eval_expression(engine_state, stack, expr)?;
+            match val {
+                Value::Binary { mut val, .. } => output.append(&mut val),
+                other => {
+                    return Err(ShellError::UnsupportedInput(
+                        "only support expression which yields to binary data".to_string(),
+                        other.span().unwrap_or(call.head),
+                    ))
+                }
+            }
+        }
+
+        Ok(Value::Binary {
+            val: output,
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesBuild {})
+    }
+}

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

@@ -0,0 +1,49 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Bytes;
+
+impl Command for Bytes {
+    fn name(&self) -> &str {
+        "bytes"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes").category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Various commands for working with byte data"
+    }
+
+    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(&Bytes.signature(), &Bytes.examples(), engine_state, stack),
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::Bytes;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Bytes {})
+    }
+}

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

@@ -0,0 +1,127 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone, Copy)]
+pub struct BytesCollect;
+
+impl Command for BytesCollect {
+    fn name(&self) -> &str {
+        "bytes collect"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes collect")
+            .optional(
+                "separator",
+                SyntaxShape::Binary,
+                "optional separator to use when creating binary",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Concatenate multiple binary into a single binary, with an optional separator between each"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["join", "concatenate"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let separator: Option<Vec<u8>> = call.opt(engine_state, stack, 0)?;
+        // input should be a list of binary data.
+        let mut output_binary = vec![];
+        for value in input {
+            match value {
+                Value::Binary { mut val, .. } => {
+                    output_binary.append(&mut val);
+                    // manually concat
+                    // TODO: make use of std::slice::Join when it's available in stable.
+                    if let Some(sep) = &separator {
+                        let mut work_sep = sep.clone();
+                        output_binary.append(&mut work_sep)
+                    }
+                }
+                other => {
+                    return Err(ShellError::UnsupportedInput(
+                        format!(
+                            "The element type is {}, this command only works with bytes.",
+                            other.get_type()
+                        ),
+                        other.span().unwrap_or(call.head),
+                    ))
+                }
+            }
+        }
+
+        match separator {
+            None => Ok(Value::Binary {
+                val: output_binary,
+                span: call.head,
+            }
+            .into_pipeline_data()),
+            Some(sep) => {
+                if output_binary.is_empty() {
+                    Ok(Value::Binary {
+                        val: output_binary,
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
+                } else {
+                    // have push one extra separator in previous step, pop them out.
+                    for _ in sep {
+                        let _ = output_binary.pop();
+                    }
+                    Ok(Value::Binary {
+                        val: output_binary,
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
+                }
+            }
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create a byte array from input",
+                example: "[0x[11] 0x[13 15]] | bytes collect",
+                result: Some(Value::Binary {
+                    val: vec![0x11, 0x13, 0x15],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Create a byte array from input with a separator",
+                example: "[0x[11] 0x[33] 0x[44]] | bytes collect 0x[01]",
+                result: Some(Value::Binary {
+                    val: vec![0x11, 0x01, 0x33, 0x01, 0x44],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesCollect {})
+    }
+}

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

@@ -0,0 +1,116 @@
+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, Value};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesEndsWith;
+
+impl Command for BytesEndsWith {
+    fn name(&self) -> &str {
+        "bytes ends-with"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes ends-with")
+            .required("pattern", SyntaxShape::Binary, "the pattern to match")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Check if bytes ends with a pattern"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        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,
+            column_paths,
+        };
+        operate(ends_with, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Checks if binary ends with `0x[AA]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[AA]",
+                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::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::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn ends_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
+    Value::Bool {
+        val: input.ends_with(pattern),
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesEndsWith {})
+    }
+}

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

@@ -0,0 +1,210 @@
+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, Value,
+};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    end: bool,
+    all: bool,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesIndexOf;
+
+impl Command for BytesIndexOf {
+    fn name(&self) -> &str {
+        "bytes index-of"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes index-of")
+            .required(
+                "pattern",
+                SyntaxShape::Binary,
+                "the pattern to find index of",
+            )
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "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'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns start index of first occurrence of pattern in bytes, or -1 if no match"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search", "index"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        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"),
+            column_paths,
+        };
+        operate(index_of, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Returns index of pattern in bytes",
+                example: " 0x[33 44 55 10 01 13 44 55] | bytes index-of 0x[44 55]",
+                result: Some(Value::test_int(1)),
+            },
+            Example {
+                description: "Returns index of pattern, search from end",
+                example: " 0x[33 44 55 10 01 13 44 55] | bytes index-of -e 0x[44 55]",
+                result: Some(Value::test_int(6)),
+            },
+            Example {
+                description: "Returns all matched index",
+                example: " 0x[33 44 55 10 01 33 44 33 44] | bytes index-of -a 0x[33 44]",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(0), Value::test_int(5), Value::test_int(7)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Returns all matched index, searching from end",
+                example: " 0x[33 44 55 10 01 33 44 33 44] | bytes index-of -a -e 0x[33 44]",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(7), Value::test_int(5), Value::test_int(0)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Returns index of pattern for specific column",
+                example: r#" [[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes index-of 0x[11] ColA ColC"#,
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::test_int(0),
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::test_int(-1),
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn index_of(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    if arg.all {
+        search_all_index(input, &arg.pattern, arg.end, span)
+    } else {
+        let mut iter = input.windows(arg.pattern.len());
+
+        if arg.end {
+            Value::Int {
+                val: iter
+                    .rev()
+                    .position(|sub_bytes| sub_bytes == arg.pattern)
+                    .map(|x| (input.len() - arg.pattern.len() - x) as i64)
+                    .unwrap_or(-1),
+                span,
+            }
+        } else {
+            Value::Int {
+                val: iter
+                    .position(|sub_bytes| sub_bytes == arg.pattern)
+                    .map(|x| x as i64)
+                    .unwrap_or(-1),
+                span,
+            }
+        }
+    }
+}
+
+fn search_all_index(input: &[u8], pattern: &[u8], from_end: bool, span: Span) -> Value {
+    let mut result = vec![];
+    if from_end {
+        let (mut left, mut right) = (
+            input.len() as isize - pattern.len() as isize,
+            input.len() as isize,
+        );
+        while left >= 0 {
+            if &input[left as usize..right as usize] == pattern {
+                result.push(Value::Int {
+                    val: left as i64,
+                    span,
+                });
+                left -= pattern.len() as isize;
+                right -= pattern.len() as isize;
+            } else {
+                left -= 1;
+                right -= 1;
+            }
+        }
+        Value::List { vals: result, span }
+    } else {
+        // doing find stuff.
+        let (mut left, mut right) = (0, pattern.len());
+        let input_len = input.len();
+        let pattern_len = pattern.len();
+        while right <= input_len {
+            if &input[left..right] == pattern {
+                result.push(Value::Int {
+                    val: left as i64,
+                    span,
+                });
+                left += pattern_len;
+                right += pattern_len;
+            } else {
+                left += 1;
+                right += 1;
+            }
+        }
+
+        Value::List { vals: result, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesIndexOf {})
+    }
+}

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

@@ -0,0 +1,98 @@
+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, 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"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes length")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally find length of binary by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Output the length of any bytes in the pipeline"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["len", "size", "count"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        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())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Return the lengths of multiple strings",
+                example: "0x[1F FF AA AB] | bytes length",
+                result: Some(Value::test_int(4)),
+            },
+            Example {
+                description: "Return the lengths of multiple strings",
+                example: "[0x[1F FF AA AB] 0x[1F]] | bytes length",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(4), Value::test_int(1)],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn length(input: &[u8], _arg: &Arguments, span: Span) -> Value {
+    Value::Int {
+        val: input.len() as i64,
+        span,
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesLen {})
+    }
+}

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

@@ -0,0 +1,98 @@
+mod add;
+mod at;
+mod build_;
+mod bytes_;
+mod collect;
+mod ends_with;
+mod index_of;
+mod length;
+mod remove;
+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;
+pub use bytes_::Bytes;
+pub use collect::BytesCollect;
+pub use ends_with::BytesEndsWith;
+pub use index_of::BytesIndexOf;
+pub use length::BytesLen;
+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

@@ -0,0 +1,196 @@
+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, Value,
+};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    end: bool,
+    column_paths: Option<Vec<CellPath>>,
+    all: bool,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesRemove;
+
+impl Command for BytesRemove {
+    fn name(&self) -> &str {
+        "bytes remove"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes remove")
+            .required("pattern", SyntaxShape::Binary, "the pattern to find")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally remove bytes by column paths",
+            )
+            .switch("end", "remove from end of binary", Some('e'))
+            .switch("all", "remove occurrences of finding binary", Some('a'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "remove bytes"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["search", "shift", "switch"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        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(
+                "the pattern to remove cannot be empty".to_string(),
+                pattern_to_remove.span,
+            ));
+        }
+
+        let pattern_to_remove: Vec<u8> = pattern_to_remove.item;
+        let arg = Arguments {
+            pattern: pattern_to_remove,
+            end: call.has_flag("end"),
+            column_paths,
+            all: call.has_flag("all"),
+        };
+
+        operate(remove, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Remove contents",
+                example: "0x[10 AA FF AA FF] | bytes remove 0x[10 AA]",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove all occurrences of find binary",
+                example: "0x[10 AA 10 BB 10] | bytes remove -a 0x[10]",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xBB],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove occurrences of find binary from end",
+                example: "0x[10 AA 10 BB CC AA 10] | bytes remove -e 0x[10]",
+                result: Some(Value::Binary {
+                    val: vec![0x10, 0xAA, 0x10, 0xBB, 0xCC, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove all occurrences of find binary in table",
+                example: "[[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes remove 0x[11] ColA ColC",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x17, 0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn remove(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let mut result = vec![];
+    let remove_all = arg.all;
+    let input_len = input.len();
+    let pattern_len = arg.pattern.len();
+
+    // Note:
+    // remove_all from start and end will generate the same result.
+    // so we'll put `remove_all` relative logic into else clouse.
+    if arg.end && !remove_all {
+        let (mut left, mut right) = (
+            input.len() as isize - arg.pattern.len() as isize,
+            input.len() as isize,
+        );
+        while left >= 0 && input[left as usize..right as usize] != arg.pattern {
+            result.push(input[right as usize - 1]);
+            left -= 1;
+            right -= 1;
+        }
+        // append the remaining thing to result, this can be happeneed when
+        // we have something to remove and remove_all is False.
+        let mut remain = input[..left as usize].iter().copied().rev().collect();
+        result.append(&mut remain);
+        result = result.into_iter().rev().collect();
+        Value::Binary { val: result, span }
+    } else {
+        let (mut left, mut right) = (0, arg.pattern.len());
+        while right <= input_len {
+            if input[left..right] == arg.pattern {
+                left += pattern_len;
+                right += pattern_len;
+                if !remove_all {
+                    break;
+                }
+            } else {
+                result.push(input[left]);
+                left += 1;
+                right += 1;
+            }
+        }
+        // append the remaing thing to result, this can happened when
+        // we have something to remove and remove_all is False.
+        let mut remain = input[left..].to_vec();
+        result.append(&mut remain);
+        Value::Binary { val: result, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesRemove {})
+    }
+}

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

@@ -0,0 +1,171 @@
+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, Value,
+};
+
+struct Arguments {
+    find: Vec<u8>,
+    replace: Vec<u8>,
+    column_paths: Option<Vec<CellPath>>,
+    all: bool,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesReplace;
+
+impl Command for BytesReplace {
+    fn name(&self) -> &str {
+        "bytes replace"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes replace")
+            .required("find", SyntaxShape::Binary, "the pattern to find")
+            .required("replace", SyntaxShape::Binary, "the replacement pattern")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally find and replace text by column paths",
+            )
+            .switch("all", "replace all occurrences of find binary", Some('a'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Find and replace binary"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["search", "shift", "switch"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        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(
+                "the pattern to find cannot be empty".to_string(),
+                find.span,
+            ));
+        }
+
+        let arg = Arguments {
+            find: find.item,
+            replace: call.req::<Vec<u8>>(engine_state, stack, 1)?,
+            column_paths,
+            all: call.has_flag("all"),
+        };
+
+        operate(replace, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Find and replace contents",
+                example: "0x[10 AA FF AA FF] | bytes replace 0x[10 AA] 0x[FF]",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xFF, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Find and replace all occurrences of find binary",
+                example: "0x[10 AA 10 BB 10] | bytes replace -a 0x[10] 0x[A0]",
+                result: Some(Value::Binary {
+                    val: vec![0xA0, 0xAA, 0xA0, 0xBB, 0xA0],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Find and replace all occurrences of find binary in table",
+                example: "[[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes replace -a 0x[11] 0x[13] ColA ColC",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x13, 0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x17, 0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn replace(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let mut replaced = vec![];
+    let replace_all = arg.all;
+
+    // doing find-and-replace stuff.
+    let (mut left, mut right) = (0, arg.find.len());
+    let input_len = input.len();
+    let pattern_len = arg.find.len();
+    while right <= input_len {
+        if input[left..right] == arg.find {
+            let mut to_replace = arg.replace.clone();
+            replaced.append(&mut to_replace);
+            left += pattern_len;
+            right += pattern_len;
+            if !replace_all {
+                break;
+            }
+        } else {
+            replaced.push(input[left]);
+            left += 1;
+            right += 1;
+        }
+    }
+
+    let mut remain = input[left..].to_vec();
+    replaced.append(&mut remain);
+    Value::Binary {
+        val: replaced,
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesReplace {})
+    }
+}

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

@@ -0,0 +1,104 @@
+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, 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)]
+
+pub struct BytesReverse;
+
+impl Command for BytesReverse {
+    fn name(&self) -> &str {
+        "bytes reverse"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes reverse")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Reverse every bytes in the pipeline"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["convert", "inverse", "flip"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        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())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Reverse bytes `0x[1F FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes reverse",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xAA, 0xFF, 0x1F],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Reverse bytes `0x[FF AA AA]`",
+                example: "0x[FF AA AA] | bytes reverse",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+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,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesReverse {})
+    }
+}

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

@@ -0,0 +1,122 @@
+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, Value};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesStartsWith;
+
+impl Command for BytesStartsWith {
+    fn name(&self) -> &str {
+        "bytes starts-with"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes starts-with")
+            .required("pattern", SyntaxShape::Binary, "the pattern to match")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Check if bytes starts with a pattern"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        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,
+            column_paths,
+        };
+        operate(
+            starts_with,
+            arg,
+            input,
+            call.head,
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            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::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::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::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn starts_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
+    Value::Bool {
+        val: input.starts_with(pattern),
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesStartsWith {})
+    }
+}

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

@@ -1,3 +1,4 @@
+use crate::{generate_strftime_list, parse_date_from_string};
 use chrono::{DateTime, FixedOffset, Local, TimeZone, Utc};
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
@@ -7,9 +8,6 @@ use nu_protocol::{
     Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
 
-use crate::generate_strftime_list;
-use crate::parse_date_from_string;
-
 struct Arguments {
     timezone: Option<Spanned<String>>,
     offset: Option<Spanned<i64>>,
@@ -148,6 +146,15 @@ impl Command for SubCommand {
                 example: "1614434140 | into datetime -o +9",
                 result: None,
             },
+            Example {
+                description:
+                    "Convert timestamps like the sqlite history t",
+                example: "1656165681720 | into datetime",
+                result: Some(Value::Date {
+                    val: Utc.timestamp_millis(1656165681720).into(),
+                    span: Span::test_data(),
+                }),
+            },
         ]
     }
 }
@@ -251,10 +258,19 @@ fn action(
 
         return match timezone {
             // default to UTC
-            None => Value::Date {
+            None => {
-                val: Utc.timestamp(ts, 0).into(),
+                // be able to convert chrono::Utc::now()
-                span: head,
+                let dt = match ts.to_string().len() {
-            },
+                    x if x > 13 => Utc.timestamp_nanos(ts).into(),
+                    x if x > 10 => Utc.timestamp_millis(ts).into(),
+                    _ => Utc.timestamp(ts, 0).into(),
+                };
+
+                Value::Date {
+                    val: dt,
+                    span: head,
+                }
+            }
             Some(Spanned { item, span }) => match item {
                 Zone::Utc => Value::Date {
                     val: Utc.timestamp(ts, 0).into(),

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

@@ -28,6 +28,10 @@ impl Command for SubCommand {
         "Convert value to duration"
     }
 
+    fn extra_usage(&self) -> &str {
+        "into duration does not take leap years into account and every month is calculated with 30 days"
+    }
+
     fn search_terms(&self) -> Vec<&str> {
         vec!["convert", "time", "period"]
     }
@@ -136,7 +140,7 @@ fn into_duration(
     )
 }
 
-fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
+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 {
             if let Expr::Int(x) = value.expr {
@@ -149,16 +153,21 @@ fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
                     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
                     _ => {}
                 }
             }
         }
     }
 
-    Err(ShellError::CantConvert(
+    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, and wk".to_string()),
     ))
 }
@@ -166,7 +175,10 @@ fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
 fn action(input: &Value, span: Span) -> Value {
     match input {
         Value::Duration { .. } => input.clone(),
-        Value::String { val, .. } => match string_to_duration(val, span) {
+        Value::String {
+            val,
+            span: value_span,
+        } => match string_to_duration(val, span, *value_span) {
             Ok(val) => Value::Duration { val, span },
             Err(error) => Value::Error { error },
         },

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

@@ -8,6 +8,7 @@ use nu_protocol::{
 struct Arguments {
     radix: Option<Value>,
     column_paths: Vec<CellPath>,
+    little_endian: bool,
 }
 
 #[derive(Clone)]
@@ -21,6 +22,7 @@ impl Command for SubCommand {
     fn signature(&self) -> Signature {
         Signature::build("into int")
             .named("radix", SyntaxShape::Number, "radix of integer", Some('r'))
+            .switch("little-endian", "use little-endian byte decoding", None)
             .rest(
                 "rest",
                 SyntaxShape::CellPath,
@@ -100,6 +102,21 @@ impl Command for SubCommand {
                 example: "'FF' |  into int -r 16",
                 result: Some(Value::test_int(255)),
             },
+            Example {
+                description: "Convert octal string to integer",
+                example: "'0o10132' | into int",
+                result: Some(Value::test_int(4186)),
+            },
+            Example {
+                description: "Convert 0 padded string to integer",
+                example: "'0010132' | into int",
+                result: Some(Value::test_int(10132)),
+            },
+            Example {
+                description: "Convert 0 padded string to integer with radix",
+                example: "'0010132' | into int -r 8",
+                result: Some(Value::test_int(4186)),
+            },
         ]
     }
 }
@@ -114,6 +131,7 @@ fn into_int(
 
     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)?,
     };
 
@@ -135,13 +153,13 @@ fn into_int(
     input.map(
         move |v| {
             if options.column_paths.is_empty() {
-                action(&v, head, radix)
+                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)),
+                        Box::new(move |old| action(old, head, radix, options.little_endian)),
                     );
                     if let Err(error) = r {
                         return Value::Error { error };
@@ -155,7 +173,7 @@ fn into_int(
     )
 }
 
-pub fn action(input: &Value, span: Span, radix: u32) -> Value {
+pub fn action(input: &Value, span: Span, radix: u32, little_endian: bool) -> Value {
     match input {
         Value::Int { val: _, .. } => {
             if radix == 10 {
@@ -166,7 +184,32 @@ pub fn action(input: &Value, span: Span, radix: u32) -> Value {
         }
         Value::Filesize { val, .. } => Value::Int { val: *val, span },
         Value::Float { val, .. } => Value::Int {
-            val: *val as i64,
+            val: {
+                if radix == 10 {
+                    *val as i64
+                } else {
+                    match convert_int(
+                        &Value::Int {
+                            val: *val as i64,
+                            span,
+                        },
+                        span,
+                        radix,
+                    )
+                    .as_i64()
+                    {
+                        Ok(v) => v,
+                        _ => {
+                            return Value::Error {
+                                error: ShellError::UnsupportedInput(
+                                    "Could not convert float to integer".to_string(),
+                                    span,
+                                ),
+                            }
+                        }
+                    }
+                }
+            },
             span,
         },
         Value::String { val, .. } => {
@@ -190,8 +233,38 @@ pub fn action(input: &Value, span: Span, radix: u32) -> Value {
             val: val.timestamp(),
             span,
         },
+        Value::Binary { val, span } => {
+            use byteorder::{BigEndian, ByteOrder, LittleEndian};
+
+            let mut val = val.to_vec();
+
+            if little_endian {
+                while val.len() < 8 {
+                    val.push(0);
+                }
+                val.resize(8, 0);
+
+                Value::Int {
+                    val: LittleEndian::read_i64(&val),
+                    span: *span,
+                }
+            } else {
+                while val.len() < 8 {
+                    val.insert(0, 0);
+                }
+                val.resize(8, 0);
+
+                Value::Int {
+                    val: BigEndian::read_i64(&val),
+                    span: *span,
+                }
+            }
+        }
         _ => Value::Error {
-            error: ShellError::UnsupportedInput("'into int' for unsupported type".into(), span),
+            error: ShellError::UnsupportedInput(
+                format!("'into int' for unsupported type '{}'", input.get_type()),
+                span,
+            ),
         },
     }
 }
@@ -200,11 +273,31 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
     let i = match input {
         Value::Int { val, .. } => val.to_string(),
         Value::String { val, .. } => {
-            if val.starts_with("0x") || val.starts_with("0b") {
+            let val = val.trim();
+            if val.starts_with("0x") // hex
+                || val.starts_with("0b") // binary
+                || val.starts_with("0o")
+            // octal
+            {
                 match int_from_string(val, 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 { val: n, span: head },
+                    Err(e) => {
+                        return Value::Error {
+                            error: ShellError::CantConvert(
+                                "string".to_string(),
+                                "int".to_string(),
+                                head,
+                                Some(e.to_string()),
+                            ),
+                        }
+                    }
+                }
             }
             val.to_string()
         }
@@ -217,10 +310,10 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             }
         }
     };
-    match i64::from_str_radix(&i, radix) {
+    match i64::from_str_radix(i.trim(), radix) {
         Ok(n) => Value::Int { val: n, span: head },
         Err(_reason) => Value::Error {
-            error: ShellError::CantConvert("int".to_string(), "string".to_string(), head, None),
+            error: ShellError::CantConvert("string".to_string(), "int".to_string(), head, None),
         },
     }
 }
@@ -258,7 +351,21 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                 };
             Ok(num)
         }
-        _ => match a_string.parse::<i64>() {
+        o if o.starts_with("0o") => {
+            let num = match i64::from_str_radix(o.trim_start_matches("0o"), 8) {
+                Ok(n) => n,
+                Err(_reason) => {
+                    return Err(ShellError::CantConvert(
+                        "int".to_string(),
+                        "string".to_string(),
+                        span,
+                        Some(r#"octal digits following "0o" should be in 0-7"#.to_string()),
+                    ))
+                }
+            };
+            Ok(num)
+        }
+        _ => match trimmed.parse::<i64>() {
             Ok(n) => Ok(n),
             Err(_) => match a_string.parse::<f64>() {
                 Ok(f) => Ok(f as i64),
@@ -266,7 +373,10 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                     "int".to_string(),
                     "string".to_string(),
                     span,
-                    None,
+                    Some(format!(
+                        r#"string "{}" does not represent a valid integer"#,
+                        trimmed
+                    )),
                 )),
             },
         },
@@ -291,21 +401,21 @@ mod test {
         let word = Value::test_string("10");
         let expected = Value::test_int(10);
 
-        let actual = action(&word, Span::test_data(), 10);
+        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, Span::test_data(), 10);
+        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, Span::test_data(), 16);
+        let actual = action(&s, Span::test_data(), 16, false);
         assert_eq!(actual, Value::test_int(255));
     }
 
@@ -313,7 +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, Span::test_data(), 10);
+        let actual = action(&integer_str, Span::test_data(), 10, false);
 
         assert_eq!(actual.get_type(), Error)
     }

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

@@ -2,8 +2,8 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::{Call, CellPath},
     engine::{Command, EngineState, Stack},
-    Category, Config, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span,
+    into_code, Category, Config, Example, IntoPipelineData, PipelineData, ShellError, Signature,
-    SyntaxShape, Value,
+    Span, SyntaxShape, Value,
 };
 
 // TODO num_format::SystemLocale once platform-specific dependencies are stable (see Cargo.toml)
@@ -53,6 +53,14 @@ impl Command for SubCommand {
 
     fn examples(&self) -> Vec<Example> {
         vec![
+            Example {
+                description: "convert integer to string and append three decimal places",
+                example: "5 | into string -d 3",
+                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",
@@ -210,6 +218,15 @@ pub fn action(
         Value::Int { val, .. } => {
             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()
             };
@@ -247,6 +264,15 @@ pub fn action(
             val: input.into_string(", ", config),
             span,
         },
+        Value::Error { error } => Value::String {
+            val: {
+                match into_code(error) {
+                    Some(code) => code,
+                    None => "".to_string(),
+                }
+            },
+            span,
+        },
         Value::Nothing { .. } => Value::String {
             val: "".to_string(),
             span,

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

@@ -26,14 +26,18 @@ impl Command for Alias {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
         true
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["abbr", "aka", "fn", "func", "function"]
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,

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

@@ -27,8 +27,8 @@ impl Command for Def {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -27,8 +27,34 @@ impl Command for DefEnv {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html
+
+=== EXTRA NOTE ===
+All blocks are scoped, including variable definition and environment variable changes.
+
+Because of this, the following doesn't work:
+
+def-env cd_with_fallback [arg = ""] {
+    let fall_back_path = "/tmp"
+    if $arg != "" {
+        cd $arg
+    } else {
+        cd $fall_back_path
+    }
+}
+
+Instead, you have to use cd in the top level scope:
+
+def-env cd_with_fallback [arg = ""] {
+    let fall_back_path = "/tmp"
+    let path = if $arg != "" {
+        $arg
+    } else {
+        $fall_back_path
+    }
+    cd $path
+}"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -13,7 +13,7 @@ impl Command for Describe {
     }
 
     fn usage(&self) -> &str {
-        "Describe the value(s) piped in."
+        "Describe the type and structure of the value(s) piped in."
     }
 
     fn signature(&self) -> Signature {
@@ -55,6 +55,10 @@ impl Command for Describe {
             result: Some(Value::test_string("string")),
         }]
     }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["type", "typeof", "info", "structure"]
+    }
 }
 
 #[cfg(test)]

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

@@ -1,7 +1,9 @@
 use nu_engine::{eval_block, CallExt};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{CaptureBlock, Command, EngineState, Stack};
-use nu_protocol::{Category, Example, PipelineData, Signature, SyntaxShape, Value};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, Signature, SyntaxShape, Value,
+};
 
 #[derive(Clone)]
 pub struct Do;
@@ -23,6 +25,11 @@ impl Command for Do {
                 "ignore errors as the block runs",
                 Some('i'),
             )
+            .switch(
+                "capture-errors",
+                "capture errors as the block runs and return it",
+                Some('c'),
+            )
             .rest("rest", SyntaxShape::Any, "the parameter(s) for the block")
             .category(Category::Core)
     }
@@ -37,6 +44,7 @@ impl Command for Do {
         let block: CaptureBlock = call.req(engine_state, stack, 0)?;
         let rest: Vec<Value> = call.rest(engine_state, stack, 1)?;
         let ignore_errors = call.has_flag("ignore-errors");
+        let capture_errors = call.has_flag("capture-errors");
 
         let mut stack = stack.captures_to_stack(&block.captures);
         let block = engine_state.get_block(block.block_id);
@@ -85,7 +93,7 @@ impl Command for Do {
             block,
             input,
             call.redirect_stdout,
-            ignore_errors,
+            ignore_errors || capture_errors,
         );
 
         if ignore_errors {
@@ -93,6 +101,11 @@ impl Command for Do {
                 Ok(x) => Ok(x),
                 Err(_) => Ok(PipelineData::new(call.head)),
             }
+        } else if capture_errors {
+            match result {
+                Ok(x) => Ok(x),
+                Err(err) => Ok((Value::Error { error: err }).into_pipeline_data()),
+            }
         } else {
             result
         }

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

@@ -23,6 +23,10 @@ impl Command for Echo {
             .category(Category::Core)
     }
 
+    fn extra_usage(&self) -> &str {
+        "Unlike `print`, this command returns an actual value that will be passed to the next command of the pipeline."
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,

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

@@ -2,8 +2,7 @@ use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
-    Value,
 };
 
 #[derive(Clone)]
@@ -16,7 +15,12 @@ impl Command for ErrorMake {
 
     fn signature(&self) -> Signature {
         Signature::build("error make")
-            .optional("error_struct", SyntaxShape::Record, "the error to create")
+            .required("error_struct", SyntaxShape::Record, "the error to create")
+            .switch(
+                "unspanned",
+                "remove the origin label from the error",
+                Some('u'),
+            )
             .category(Category::Core)
     }
 
@@ -24,47 +28,41 @@ impl Command for ErrorMake {
         "Create an error."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["err", "panic", "crash", "throw"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
         stack: &mut Stack,
         call: &Call,
-        input: PipelineData,
+        _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         let span = call.head;
-        let ctrlc = engine_state.ctrlc.clone();
+        let arg: Value = call.req(engine_state, stack, 0)?;
-        let arg: Option<Value> = call.opt(engine_state, stack, 0)?;
+        let unspanned = call.has_flag("unspanned");
 
-        if let Some(arg) = arg {
+        if unspanned {
-            Ok(make_error(&arg, span)
+            Err(make_error(&arg, None).unwrap_or_else(|| {
-                .map(|err| Value::Error { error: err })
+                ShellError::GenericError(
-                .unwrap_or_else(|| Value::Error {
+                    "Creating error value not supported.".into(),
-                    error: ShellError::GenericError(
+                    "unsupported error format".into(),
-                        "Creating error value not supported.".into(),
+                    Some(span),
-                        "unsupported error format".into(),
+                    None,
-                        Some(span),
+                    Vec::new(),
-                        None,
+                )
-                        Vec::new(),
+            }))
-                    ),
-                })
-                .into_pipeline_data())
         } else {
-            input.map(
+            Err(make_error(&arg, Some(span)).unwrap_or_else(|| {
-                move |value| {
+                ShellError::GenericError(
-                    make_error(&value, span)
+                    "Creating error value not supported.".into(),
-                        .map(|err| Value::Error { error: err })
+                    "unsupported error format".into(),
-                        .unwrap_or_else(|| Value::Error {
+                    Some(span),
-                            error: ShellError::GenericError(
+                    None,
-                                "Creating error value not supported.".into(),
+                    Vec::new(),
-                                "unsupported error format".into(),
+                )
-                                Some(span),
+            }))
-                                None,
-                                Vec::new(),
-                            ),
-                        })
-                },
-                ctrlc,
-            )
         }
     }
 
@@ -89,7 +87,7 @@ impl Command for ErrorMake {
     }
 }
 
-fn make_error(value: &Value, throw_span: Span) -> Option<ShellError> {
+fn make_error(value: &Value, throw_span: Option<Span>) -> Option<ShellError> {
     if let Value::Record { .. } = &value {
         let msg = value.get_data_by_key("msg");
         let label = value.get_data_by_key("label");
@@ -126,7 +124,7 @@ fn make_error(value: &Value, throw_span: Span) -> Option<ShellError> {
                     ) => Some(ShellError::GenericError(
                         message,
                         label_text,
-                        Some(throw_span),
+                        throw_span,
                         None,
                         Vec::new(),
                     )),
@@ -136,7 +134,7 @@ fn make_error(value: &Value, throw_span: Span) -> Option<ShellError> {
             (Some(Value::String { val: message, .. }), None) => Some(ShellError::GenericError(
                 message,
                 "originates from here".to_string(),
-                Some(throw_span),
+                throw_span,
                 None,
                 Vec::new(),
             )),

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

@@ -22,8 +22,8 @@ impl Command for ExportCommand {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -26,8 +26,8 @@ impl Command for ExportAlias {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -27,8 +27,8 @@ impl Command for ExportDef {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -27,8 +27,34 @@ impl Command for ExportDefEnv {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html
+
+=== EXTRA NOTE ===
+All blocks are scoped, including variable definition and environment variable changes.
+
+Because of this, the following doesn't work:
+
+export def-env cd_with_fallback [arg = ""] {
+    let fall_back_path = "/tmp"
+    if $arg != "" {
+        cd $arg
+    } else {
+        cd $fall_back_path
+    }
+}
+
+Instead, you have to use cd in the top level scope:
+
+export def-env cd_with_fallback [arg = ""] {
+    let fall_back_path = "/tmp"
+    let path = if $arg != "" {
+        $arg
+    } else {
+        $fall_back_path
+    }
+    cd $path
+}"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -30,8 +30,8 @@ impl Command for ExportEnv {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -22,8 +22,8 @@ impl Command for ExportExtern {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -22,8 +22,8 @@ impl Command for Extern {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -45,8 +45,8 @@ impl Command for For {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -1,12 +1,15 @@
+use nu_ansi_term::{
+    Color::{Default, Red, White},
+    Style,
+};
+use nu_color_config::get_color_config;
+use nu_engine::{get_full_help, CallExt};
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
     span, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
-    ShellError, Signature, Spanned, SyntaxShape, Value,
+    ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
-
-use nu_engine::{get_full_help, CallExt};
-
 use std::borrow::Borrow;
 
 #[derive(Clone)]
@@ -81,23 +84,29 @@ fn help(
     let head = call.head;
     let find: Option<Spanned<String>> = call.get_flag(engine_state, stack, "find")?;
     let rest: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
-
     let commands = engine_state.get_decl_ids_sorted(false);
+    let config = engine_state.get_config();
+    let color_hm = get_color_config(config);
+    let default_style = Style::new().fg(Default).on(Default);
+    let string_style = match color_hm.get("string") {
+        Some(style) => style,
+        None => &default_style,
+    };
 
     if let Some(f) = find {
+        let org_search_string = f.item.clone();
         let search_string = f.item.to_lowercase();
         let mut found_cmds_vec = Vec::new();
 
         for decl_id in commands {
             let mut cols = vec![];
             let mut vals = vec![];
-
             let decl = engine_state.get_decl(decl_id);
             let sig = decl.signature().update_from_command(decl.borrow());
-
             let key = sig.name;
             let usage = sig.usage;
             let search_terms = sig.search_terms;
+
             let matches_term = if !search_terms.is_empty() {
                 search_terms
                     .iter()
@@ -106,13 +115,16 @@ fn help(
                 false
             };
 
-            if key.to_lowercase().contains(&search_string)
+            let key_match = key.to_lowercase().contains(&search_string);
-                || usage.to_lowercase().contains(&search_string)
+            let usage_match = usage.to_lowercase().contains(&search_string);
-                || matches_term
+            if key_match || usage_match || matches_term {
-            {
                 cols.push("name".into());
                 vals.push(Value::String {
-                    val: key,
+                    val: if key_match {
+                        highlight_search_string(&key, &org_search_string, string_style)?
+                    } else {
+                        key
+                    },
                     span: head,
                 });
 
@@ -142,7 +154,11 @@ fn help(
 
                 cols.push("usage".into());
                 vals.push(Value::String {
-                    val: usage,
+                    val: if usage_match {
+                        highlight_search_string(&usage, &org_search_string, string_style)?
+                    } else {
+                        usage
+                    },
                     span: head,
                 });
 
@@ -151,7 +167,30 @@ fn help(
                     Value::nothing(head)
                 } else {
                     Value::String {
-                        val: search_terms.join(", "),
+                        val: if matches_term {
+                            search_terms
+                                .iter()
+                                .map(|term| {
+                                    if term.to_lowercase().contains(&search_string) {
+                                        match highlight_search_string(
+                                            term,
+                                            &org_search_string,
+                                            string_style,
+                                        ) {
+                                            Ok(s) => s,
+                                            Err(_) => {
+                                                string_style.paint(term.to_string()).to_string()
+                                            }
+                                        }
+                                    } else {
+                                        string_style.paint(term.to_string()).to_string()
+                                    }
+                                })
+                                .collect::<Vec<_>>()
+                                .join(", ")
+                        } else {
+                            search_terms.join(", ")
+                        },
                         span: head,
                     }
                 });
@@ -303,3 +342,48 @@ You can also learn more at https://www.nushell.sh/book/"#;
         .into_pipeline_data())
     }
 }
+
+// Highlight the search string using ANSI escape sequences and regular expressions.
+pub fn highlight_search_string(
+    haystack: &str,
+    needle: &str,
+    string_style: &Style,
+) -> Result<String, ShellError> {
+    let regex_string = format!("(?i){}", needle);
+    let regex = match regex::Regex::new(&regex_string) {
+        Ok(regex) => regex,
+        Err(err) => {
+            return Err(ShellError::GenericError(
+                "Could not compile regex".into(),
+                err.to_string(),
+                Some(Span::test_data()),
+                None,
+                Vec::new(),
+            ));
+        }
+    };
+    let mut last_match_end = 0;
+    let style = Style::new().fg(White).on(Red);
+    let mut highlighted = String::new();
+
+    for cap in regex.captures_iter(haystack) {
+        let start = match cap.get(0) {
+            Some(cap) => cap.start(),
+            None => 0,
+        };
+        let end = match cap.get(0) {
+            Some(cap) => cap.end(),
+            None => 0,
+        };
+        highlighted.push_str(
+            &string_style
+                .paint(&haystack[last_match_end..start])
+                .to_string(),
+        );
+        highlighted.push_str(&style.paint(&haystack[start..end]).to_string());
+        last_match_end = end;
+    }
+
+    highlighted.push_str(&string_style.paint(&haystack[last_match_end..]).to_string());
+    Ok(highlighted)
+}

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

@@ -25,9 +25,8 @@ impl Command for Hide {
     fn extra_usage(&self) -> &str {
         r#"Symbols are hidden by priority: First aliases, then custom commands, then environment variables.
 
-This command is a parser keyword. For details, check
+This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
-            "#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -1,102 +0,0 @@
-use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Value,
-};
-
-const NEWLINE_ESCAPE_CODE: &str = "<\\n>";
-
-fn decode_newlines(escaped: &str) -> String {
-    escaped.replace(NEWLINE_ESCAPE_CODE, "\n")
-}
-
-#[derive(Clone)]
-pub struct History;
-
-impl Command for History {
-    fn name(&self) -> &str {
-        "history"
-    }
-
-    fn usage(&self) -> &str {
-        "Get the command history"
-    }
-
-    fn signature(&self) -> nu_protocol::Signature {
-        Signature::build("history")
-            .switch("clear", "Clears out the history entries", Some('c'))
-            .category(Category::Core)
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        _stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let head = call.head;
-        if let Some(config_path) = nu_path::config_dir() {
-            let clear = call.has_flag("clear");
-            let ctrlc = engine_state.ctrlc.clone();
-
-            let mut history_path = config_path;
-            history_path.push("nushell");
-            history_path.push("history.txt");
-
-            if clear {
-                let _ = std::fs::remove_file(history_path);
-                Ok(PipelineData::new(head))
-            } else {
-                let contents = std::fs::read_to_string(history_path);
-
-                if let Ok(contents) = contents {
-                    Ok(contents
-                        .lines()
-                        .enumerate()
-                        .map(move |(index, command)| Value::Record {
-                            cols: vec!["command".to_string(), "index".to_string()],
-                            vals: vec![
-                                Value::String {
-                                    val: decode_newlines(command),
-                                    span: head,
-                                },
-                                Value::Int {
-                                    val: index as i64,
-                                    span: head,
-                                },
-                            ],
-                            span: head,
-                        })
-                        .collect::<Vec<_>>()
-                        .into_iter()
-                        .into_pipeline_data(ctrlc))
-                } else {
-                    Err(ShellError::FileNotFound(head))
-                }
-            }
-        } else {
-            Err(ShellError::FileNotFound(head))
-        }
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![
-            Example {
-                example: "history | length",
-                description: "Get current history length",
-                result: None,
-            },
-            Example {
-                example: "history | last 5",
-                description: "Show last 5 commands you have ran",
-                result: None,
-            },
-            Example {
-                example: "history | wrap cmd | where cmd =~ cargo",
-                description: "Search all the commands from history that contains 'cargo'",
-                result: None,
-            },
-        ]
-    }
-}

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

@@ -34,8 +34,8 @@ impl Command for If {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
@@ -92,6 +92,7 @@ https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-
                                 call.redirect_stdout,
                                 call.redirect_stderr,
                             )
+                            .map(|res| res.0)
                         }
                     } else {
                         eval_expression_with_input(
@@ -102,6 +103,7 @@ https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-
                             call.redirect_stdout,
                             call.redirect_stderr,
                         )
+                        .map(|res| res.0)
                     }
                 } else {
                     Ok(PipelineData::new(call.head))

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

@@ -27,14 +27,18 @@ impl Command for Let {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
         true
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["set", "const"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -61,7 +65,8 @@ https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-
             input,
             call.redirect_stdout,
             call.redirect_stderr,
-        )?;
+        )?
+        .0;
 
         //println!("Adding: {:?} to {}", rhs, var_id);
 

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

@@ -14,9 +14,8 @@ mod export_env;
 mod export_extern;
 mod extern_;
 mod for_;
-mod help;
+pub mod help;
 mod hide;
-mod history;
 mod if_;
 mod ignore;
 mod let_;
@@ -24,7 +23,6 @@ mod metadata;
 mod module;
 pub(crate) mod overlay;
 mod source;
-mod tutor;
 mod use_;
 mod version;
 
@@ -46,7 +44,6 @@ pub use extern_::Extern;
 pub use for_::For;
 pub use help::Help;
 pub use hide::Hide;
-pub use history::History;
 pub use if_::If;
 pub use ignore::Ignore;
 pub use let_::Let;
@@ -54,7 +51,6 @@ pub use metadata::Metadata;
 pub use module::Module;
 pub use overlay::*;
 pub use source::Source;
-pub use tutor::Tutor;
 pub use use_::Use;
 pub use version::Version;
 #[cfg(feature = "plugin")]

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

@@ -26,8 +26,8 @@ impl Command for Module {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

crates/nu-command/src/core_commands/overlay/add.rs

@@ -34,8 +34,8 @@ impl Command for OverlayAdd {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -22,8 +22,8 @@ impl Command for Overlay {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -1,9 +1,11 @@
 mod add;
 mod command;
 mod list;
+mod new;
 mod remove;
 
 pub use add::OverlayAdd;
 pub use command::Overlay;
 pub use list::OverlayList;
+pub use new::OverlayNew;
 pub use remove::OverlayRemove;

crates/nu-command/src/core_commands/overlay/new.rs

@@ -0,0 +1,74 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape};
+
+#[derive(Clone)]
+pub struct OverlayNew;
+
+impl Command for OverlayNew {
+    fn name(&self) -> &str {
+        "overlay new"
+    }
+
+    fn usage(&self) -> &str {
+        "Create an empty overlay"
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("overlay new")
+            .required("name", SyntaxShape::String, "Name of the overlay")
+            // TODO:
+            // .switch(
+            //     "prefix",
+            //     "Prepend module name to the imported symbols",
+            //     Some('p'),
+            // )
+            .category(Category::Core)
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"The command will first create an empty module, then add it as an overlay.
+
+This command is a parser keyword. For details, check:
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
+    }
+
+    fn is_parser_keyword(&self) -> bool {
+        true
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let name_arg: Spanned<String> = call.req(engine_state, stack, 0)?;
+
+        stack.add_overlay(name_arg.item);
+
+        Ok(PipelineData::new(call.head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Create an empty overlay",
+            example: r#"overlay new spam"#,
+            result: None,
+        }]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(OverlayNew {})
+    }
+}

crates/nu-command/src/core_commands/overlay/remove.rs

@@ -1,9 +1,7 @@
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape};
-    Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Value,
-};
 
 #[derive(Clone)]
 pub struct OverlayRemove;
@@ -22,15 +20,21 @@ impl Command for OverlayRemove {
             .optional("name", SyntaxShape::String, "Overlay to remove")
             .switch(
                 "keep-custom",
-                "Keep newly added symbols within the next activated overlay",
+                "Keep all newly added symbols within the next activated overlay",
                 Some('k'),
             )
+            .named(
+                "keep-env",
+                SyntaxShape::List(Box::new(SyntaxShape::String)),
+                "List of environment variables to keep from the removed overlay",
+                Some('e'),
+            )
             .category(Category::Core)
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
@@ -60,30 +64,44 @@ https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-
             ));
         }
 
-        if call.has_flag("keep-custom") {
+        let keep_env: Option<Vec<Spanned<String>>> =
+            call.get_flag(engine_state, stack, "keep-env")?;
+
+        let env_vars_to_keep = if call.has_flag("keep-custom") {
             if let Some(overlay_id) = engine_state.find_overlay(overlay_name.item.as_bytes()) {
                 let overlay_frame = engine_state.get_overlay(overlay_id);
                 let origin_module = engine_state.get_module(overlay_frame.origin);
 
-                let env_vars_to_keep: Vec<(String, Value)> = stack
+                stack
                     .get_overlay_env_vars(engine_state, &overlay_name.item)
                     .into_iter()
                     .filter(|(name, _)| !origin_module.has_env_var(name.as_bytes()))
-                    .collect();
+                    .collect()
-
-                stack.remove_overlay(&overlay_name.item);
-
-                for (name, val) in env_vars_to_keep {
-                    stack.add_env_var(name, val);
-                }
             } else {
                 return Err(ShellError::OverlayNotFoundAtRuntime(
                     overlay_name.item,
                     overlay_name.span,
                 ));
             }
+        } else if let Some(env_var_names_to_keep) = keep_env {
+            let mut env_vars_to_keep = vec![];
+
+            for name in env_var_names_to_keep.into_iter() {
+                match stack.get_env_var(engine_state, &name.item) {
+                    Some(val) => env_vars_to_keep.push((name.item, val.clone())),
+                    None => return Err(ShellError::EnvVarNotFoundAtRuntime(name.item, name.span)),
+                }
+            }
+
+            env_vars_to_keep
         } else {
-            stack.remove_overlay(&overlay_name.item);
+            vec![]
+        };
+
+        stack.remove_overlay(&overlay_name.item);
+
+        for (name, val) in env_vars_to_keep {
+            stack.add_env_var(name, val);
         }
 
         Ok(PipelineData::new(call.head))
@@ -112,6 +130,13 @@ https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-
     overlay remove"#,
                 result: None,
             },
+            Example {
+                description: "Keep the current working directory when removing an overlay",
+                example: r#"overlay new spam
+    cd some-dir
+    overlay remove --keep-env [ PWD ] spam"#,
+                result: None,
+            },
         ]
     }
 }

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

@@ -42,8 +42,8 @@ impl Command for Register {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -27,8 +27,8 @@ impl Command for Source {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {
@@ -69,11 +69,6 @@ https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-
                 example: r#"source ./foo.nu; say-hi"#,
                 result: None,
             },
-            Example {
-                description: "Runs foo.nu in current context and call the `main` command automatically, suppose foo.nu has content: `def main [] { echo 'Hi!' }`",
-                example: r#"source ./foo.nu"#,
-                result: None,
-            },
         ]
     }
 }

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

@@ -24,8 +24,8 @@ impl Command for Use {
     }
 
     fn extra_usage(&self) -> &str {
-        r#"This command is a parser keyword. For details, check
+        r#"This command is a parser keyword. For details, check:
-https://www.nushell.sh/book/thinking_in_nushell.html#parsing-and-evaluation-are-different-stages"#
+  https://www.nushell.sh/book/thinking_in_nushell.html"#
     }
 
     fn is_parser_keyword(&self) -> bool {

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

@@ -1,26 +1,26 @@
-use crate::{
+use crate::SQLiteDatabase;
-    database::values::dsl::{ExprDb, SelectDb},
-    SQLiteDatabase,
-};
 use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Type, Value,
 };
-use sqlparser::ast::{Ident, SelectItem, SetExpr, Statement, TableAlias, TableFactor};
+use sqlparser::ast::{Ident, SetExpr, Statement, TableAlias, TableFactor};
 
 #[derive(Clone)]
-pub struct AliasExpr;
+pub struct AliasDb;
 
-impl Command for AliasExpr {
+impl Command for AliasDb {
     fn name(&self) -> &str {
-        "db as"
+        "as"
     }
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("alias", SyntaxShape::String, "alias name")
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -29,11 +29,59 @@ impl Command for AliasExpr {
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
+        vec![
-            description: "Creates an alias for a column selection",
+            Example {
-            example: "db col name_a | db as new_a",
+                description: "Creates an alias for a selected table",
-            result: None,
+                example: r#"open db.mysql
-        }]
+    | into db
+    | select a
+    | from table_1
+    | as t1
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT a FROM table_1 AS t1".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Creates an alias for a derived table",
+                example: r#"open db.mysql
+    | into db
+    | select a
+    | from (
+        open db.mysql
+        | into db
+        | select a b
+        | from table_a
+      )
+    | as t1
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT a FROM (SELECT a, b FROM table_a) AS t1".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
     }
 
     fn search_terms(&self) -> Vec<&str> {
@@ -48,52 +96,12 @@ impl Command for AliasExpr {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let alias: String = call.req(engine_state, stack, 0)?;
-        let value = input.into_value(call.head);
 
-        if let Ok(expr) = ExprDb::try_from_value(&value) {
+        let db = SQLiteDatabase::try_from_pipeline(input, call.head)?;
-            alias_selection(expr.into_native().into(), alias, call)
+        alias_db(db, alias, call)
-        } else if let Ok(select) = SelectDb::try_from_value(&value) {
-            alias_selection(select, alias, call)
-        } else if let Ok(db) = SQLiteDatabase::try_from_value(value.clone()) {
-            alias_db(db, alias, call)
-        } else {
-            Err(ShellError::CantConvert(
-                "expression or query".into(),
-                value.get_type().to_string(),
-                value.span()?,
-                None,
-            ))
-        }
     }
 }
 
-fn alias_selection(
-    select: SelectDb,
-    alias: String,
-    call: &Call,
-) -> Result<PipelineData, ShellError> {
-    let select = match select.into_native() {
-        SelectItem::UnnamedExpr(expr) => SelectItem::ExprWithAlias {
-            expr,
-            alias: Ident {
-                value: alias,
-                quote_style: None,
-            },
-        },
-        SelectItem::ExprWithAlias { expr, .. } => SelectItem::ExprWithAlias {
-            expr,
-            alias: Ident {
-                value: alias,
-                quote_style: None,
-            },
-        },
-        select => select,
-    };
-
-    let select: SelectDb = select.into();
-    Ok(select.into_value(call.head).into_pipeline_data())
-}
-
 fn alias_db(
     mut db: SQLiteDatabase,
     new_alias: String,
@@ -142,7 +150,7 @@ fn alias_db(
             },
             s => {
                 return Err(ShellError::GenericError(
-                    "Connection doesnt define a query".into(),
+                    "Connection doesn't define a query".into(),
                     format!("Expected a connection with query. Got {}", s),
                     Some(call.head),
                     None,
@@ -152,3 +160,19 @@ fn alias_db(
         },
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::{FromDb, ProjectionDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(AliasDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FromDb {}),
+        ])
+    }
+}

crates/nu-command/src/database/commands/and.rs

@@ -6,7 +6,7 @@ use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Value,
+    Type, Value,
 };
 use sqlparser::ast::{BinaryOperator, Expr, Query, Select, SetExpr, Statement};
 
@@ -15,16 +15,18 @@ pub struct AndDb;
 
 impl Command for AndDb {
     fn name(&self) -> &str {
-        "db and"
+        "and"
     }
 
     fn usage(&self) -> &str {
-        "Includes an AND clause for a query or expression"
+        "Includes an AND clause for a query"
     }
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("where", SyntaxShape::Any, "Where expression on the table")
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -35,23 +37,52 @@ impl Command for AndDb {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "selects a column from a database with a where clause",
+                description: "Selects a column from a database with an AND clause",
-                example: r#"db open db.mysql 
+                example: r#"open db.mysql
-    | db select a 
+    | into db
-    | db from table_1 
+    | select a
-    | db where ((db col a) > 1) 
+    | from table_1
-    | db and ((db col b) == 1) 
+    | where ((field a) > 1)
-    | db describe"#,
+    | and ((field b) == 1)
-                result: None,
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT a FROM table_1 WHERE a > 1 AND b = 1".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
             },
             Example {
-                description: "Creates a nested where clause",
+                description: "Creates a AND clause combined with an expression AND",
-                example: r#"db open db.mysql 
+                example: r#"open db.mysql
-    | db select a 
+    | into db
-    | db from table_1 
+    | select a
-    | db where ((db col a) > 1 | db and ((db col a) < 10)) 
+    | from table_1
-    | db describe"#,
+    | where ((field a) > 1 | and ((field a) < 10))
-                result: None,
+    | and ((field b) == 1)
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT a FROM table_1 WHERE (a > 1 AND a < 10) AND b = 1".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
             },
         ]
     }
@@ -66,51 +97,32 @@ impl Command for AndDb {
         let value: Value = call.req(engine_state, stack, 0)?;
         let expr = ExprDb::try_from_value(&value)?.into_native();
 
-        let value = input.into_value(call.head);
+        let mut db = SQLiteDatabase::try_from_pipeline(input, call.head)?;
-        if let Ok(expression) = ExprDb::try_from_value(&value) {
+        match db.statement.as_mut() {
-            let expression = Expr::BinaryOp {
+            Some(statement) => match statement {
-                left: Box::new(expression.into_native()),
+                Statement::Query(query) => modify_query(query, expr, call.head)?,
-                op: BinaryOperator::And,
+                s => {
-                right: Box::new(expr),
-            };
-
-            let expression: ExprDb = Expr::Nested(Box::new(expression)).into();
-
-            Ok(expression.into_value(call.head).into_pipeline_data())
-        } else if let Ok(mut db) = SQLiteDatabase::try_from_value(value.clone()) {
-            match db.statement.as_mut() {
-                Some(statement) => match statement {
-                    Statement::Query(query) => modify_query(query, expr, call.head)?,
-                    s => {
-                        return Err(ShellError::GenericError(
-                            "Connection doesnt define a query".into(),
-                            format!("Expected a connection with query. Got {}", s),
-                            Some(call.head),
-                            None,
-                            Vec::new(),
-                        ))
-                    }
-                },
-                None => {
                     return Err(ShellError::GenericError(
-                        "Connection without statement".into(),
+                        "Connection doesn't define a query".into(),
-                        "The connection needs a statement defined".into(),
+                        format!("Expected a connection with query. Got {}", s),
                         Some(call.head),
                         None,
                         Vec::new(),
                     ))
                 }
-            };
+            },
+            None => {
+                return Err(ShellError::GenericError(
+                    "Connection without statement".into(),
+                    "The connection needs a statement defined".into(),
+                    Some(call.head),
+                    None,
+                    Vec::new(),
+                ))
+            }
+        };
 
-            Ok(db.into_value(call.head).into_pipeline_data())
+        Ok(db.into_value(call.head).into_pipeline_data())
-        } else {
-            Err(ShellError::CantConvert(
-                "expression or query".into(),
-                value.get_type().to_string(),
-                value.span()?,
-                None,
-            ))
-        }
     }
 }
 
@@ -150,3 +162,23 @@ fn modify_select(select: &mut Box<Select>, expression: Expr, span: Span) -> Resu
     select.as_mut().selection = Some(new_expression);
     Ok(())
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::super::expressions::{AndExpr, FieldExpr};
+    use super::super::{FromDb, ProjectionDb, WhereDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(AndDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FromDb {}),
+            Box::new(WhereDb {}),
+            Box::new(FieldExpr {}),
+            Box::new(AndExpr {}),
+        ])
+    }
+}

crates/nu-command/src/database/commands/col.rs

@@ -1,51 +0,0 @@
-use crate::database::values::dsl::ExprDb;
-use nu_engine::CallExt;
-use nu_protocol::{
-    ast::Call,
-    engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
-};
-
-#[derive(Clone)]
-pub struct ColExpr;
-
-impl Command for ColExpr {
-    fn name(&self) -> &str {
-        "db col"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build(self.name())
-            .required("name", SyntaxShape::String, "column name")
-            .category(Category::Custom("database".into()))
-    }
-
-    fn usage(&self) -> &str {
-        "Creates column expression for database"
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Creates a named column expression",
-            example: "db col name_1",
-            result: None,
-        }]
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["database", "column", "expression"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        let value: Value = call.req(engine_state, stack, 0)?;
-        let expression = ExprDb::try_from_value(&value)?;
-
-        Ok(expression.into_value(call.head).into_pipeline_data())
-    }
-}

crates/nu-command/src/database/commands/collect.rs

@@ -1,7 +1,7 @@
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type,
 };
 
 use super::super::SQLiteDatabase;
@@ -11,21 +11,24 @@ pub struct CollectDb;
 
 impl Command for CollectDb {
     fn name(&self) -> &str {
-        "db collect"
+        "collect"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build(self.name()).category(Category::Custom("database".into()))
+        Signature::build(self.name())
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Any)
+            .category(Category::Custom("database".into()))
     }
 
     fn usage(&self) -> &str {
-        "Query a database using SQL."
+        "Collects a query from a database database connection"
     }
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Collect from a select query",
-            example: "open foo.db | db select a | db from table_1 | db collect",
+            example: "open foo.db | into db | select a | from table_1 | collect",
             result: None,
         }]
     }

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

@@ -1,42 +0,0 @@
-use nu_engine::get_full_help;
-use nu_protocol::{
-    ast::Call,
-    engine::{Command, EngineState, Stack},
-    Category, IntoPipelineData, PipelineData, ShellError, Signature, Value,
-};
-
-#[derive(Clone)]
-pub struct Database;
-
-impl Command for Database {
-    fn name(&self) -> &str {
-        "db"
-    }
-
-    fn usage(&self) -> &str {
-        "Database commands"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build(self.name()).category(Category::Custom("database".into()))
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        Ok(Value::String {
-            val: get_full_help(
-                &Database.signature(),
-                &Database.examples(),
-                engine_state,
-                stack,
-            ),
-            span: call.head,
-        }
-        .into_pipeline_data())
-    }
-}

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

@@ -1,7 +1,7 @@
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type, Value,
 };
 
 use super::super::SQLiteDatabase;
@@ -11,11 +11,14 @@ pub struct DescribeDb;
 
 impl Command for DescribeDb {
     fn name(&self) -> &str {
-        "db describe"
+        "describe"
     }
 
     fn signature(&self) -> Signature {
-        Signature::build(self.name()).category(Category::Custom("database".into()))
+        Signature::build(self.name())
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Any)
+            .category(Category::Custom("database".into()))
     }
 
     fn usage(&self) -> &str {
@@ -25,13 +28,26 @@ impl Command for DescribeDb {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Describe SQLite database constructed query",
-            example: "db open foo.db | db select table_1 | db describe",
+            example: "open foo.db | into db | select col_1 | from table_1 | describe",
-            result: None,
+            result: Some(Value::Record {
+                cols: vec!["connection".into(), "query".into()],
+                vals: vec![
+                    Value::String {
+                        val: "foo.db".into(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "SELECT col_1 FROM table_1".into(),
+                        span: Span::test_data(),
+                    },
+                ],
+                span: Span::test_data(),
+            }),
         }]
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["database", "SQLite"]
+        vec!["database", "SQLite", "describe"]
     }
 
     fn run(
@@ -45,3 +61,19 @@ impl Command for DescribeDb {
         Ok(db.describe(call.head).into_pipeline_data())
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::{FromDb, ProjectionDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(DescribeDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FromDb {}),
+        ])
+    }
+}

crates/nu-command/src/database/commands/from.rs

@@ -5,7 +5,8 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Type, Value,
 };
 use sqlparser::ast::{Ident, Query, Select, SetExpr, Statement, TableAlias, TableWithJoins};
 
@@ -14,7 +15,7 @@ pub struct FromDb;
 
 impl Command for FromDb {
     fn name(&self) -> &str {
-        "db from"
+        "from"
     }
 
     fn usage(&self) -> &str {
@@ -34,6 +35,8 @@ impl Command for FromDb {
                 "Alias for the selected table",
                 Some('a'),
             )
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -43,9 +46,22 @@ impl Command for FromDb {
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
-            description: "Selects table from database",
+            description: "Selects a table from database",
-            example: "db open db.mysql | db from table_a",
+            example: "open db.mysql | into db | from table_a | describe",
-            result: None,
+            result: Some(Value::Record {
+                cols: vec!["connection".into(), "query".into()],
+                vals: vec![
+                    Value::String {
+                        val: "db.mysql".into(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "SELECT  FROM table_a".into(),
+                        span: Span::test_data(),
+                    },
+                ],
+                span: Span::test_data(),
+            }),
         }]
     }
 
@@ -180,3 +196,14 @@ fn create_table(
 
     Ok(table)
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![Box::new(FromDb {})])
+    }
+}

crates/nu-command/src/database/commands/function.rs

@@ -1,85 +0,0 @@
-use crate::database::values::dsl::ExprDb;
-use nu_engine::CallExt;
-use nu_protocol::{
-    ast::Call,
-    engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
-};
-use sqlparser::ast::{Expr, Function, FunctionArg, FunctionArgExpr, Ident, ObjectName};
-
-#[derive(Clone)]
-pub struct FunctionExpr;
-
-impl Command for FunctionExpr {
-    fn name(&self) -> &str {
-        "db fn"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build(self.name())
-            .required("name", SyntaxShape::String, "function name")
-            .switch("distinct", "distict values", Some('d'))
-            .rest("arguments", SyntaxShape::Any, "function arguments")
-            .category(Category::Custom("database".into()))
-    }
-
-    fn usage(&self) -> &str {
-        "Creates function expression for a select operation"
-    }
-
-    fn examples(&self) -> Vec<Example> {
-        vec![Example {
-            description: "Creates a function expression",
-            example: "db fn count name_1",
-            result: None,
-        }]
-    }
-
-    fn search_terms(&self) -> Vec<&str> {
-        vec!["database", "function", "expression"]
-    }
-
-    fn run(
-        &self,
-        engine_state: &EngineState,
-        stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        let name: String = call.req(engine_state, stack, 0)?;
-        let vals: Vec<Value> = call.rest(engine_state, stack, 1)?;
-        let value = Value::List {
-            vals,
-            span: call.head,
-        };
-        let expressions = ExprDb::extract_exprs(value)?;
-
-        let name: Vec<Ident> = name
-            .split('.')
-            .map(|part| Ident {
-                value: part.to_string(),
-                quote_style: None,
-            })
-            .collect();
-        let name = ObjectName(name);
-
-        let args: Vec<FunctionArg> = expressions
-            .into_iter()
-            .map(|expr| {
-                let arg = FunctionArgExpr::Expr(expr);
-
-                FunctionArg::Unnamed(arg)
-            })
-            .collect();
-
-        let expression: ExprDb = Expr::Function(Function {
-            name,
-            args,
-            over: None,
-            distinct: call.has_flag("distinct"),
-        })
-        .into();
-
-        Ok(expression.into_value(call.head).into_pipeline_data())
-    }
-}

crates/nu-command/src/database/commands/group_by.rs

@@ -5,7 +5,8 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Type, Value,
 };
 use sqlparser::ast::{SetExpr, Statement};
 
@@ -14,7 +15,7 @@ pub struct GroupByDb;
 
 impl Command for GroupByDb {
     fn name(&self) -> &str {
-        "db group-by"
+        "group-by"
     }
 
     fn usage(&self) -> &str {
@@ -28,6 +29,8 @@ impl Command for GroupByDb {
                 SyntaxShape::Any,
                 "Select expression(s) on the table",
             )
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -36,15 +39,54 @@ impl Command for GroupByDb {
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
+        vec![
-            description: "orders query by a column",
+            Example {
-            example: r#"db open db.mysql 
+                description: "groups by column a and calculates the max",
-    | db from table_a 
+                example: r#"open db.mysql
-    | db select a 
+    | into db
-    | db group-by a 
+    | from table_a
-    | db describe"#,
+    | select (fn max a)
-            result: None,
+    | group-by a
-        }]
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT max(a) FROM table_a GROUP BY a".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "groups by column column a and counts records",
+                example: r#"open db.mysql
+    | into db
+    | from table_a
+    | select (fn count *)
+    | group-by a
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT count(*) FROM table_a GROUP BY a".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
     }
 
     fn run(
@@ -100,3 +142,24 @@ impl Command for GroupByDb {
         Ok(db.into_value(call.head).into_pipeline_data())
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::super::expressions::{FieldExpr, FunctionExpr, OrExpr};
+    use super::super::{FromDb, ProjectionDb, WhereDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(GroupByDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FunctionExpr {}),
+            Box::new(FromDb {}),
+            Box::new(WhereDb {}),
+            Box::new(FieldExpr {}),
+            Box::new(OrExpr {}),
+        ])
+    }
+}

crates/nu-command/src/database/commands/join.rs

@@ -4,7 +4,8 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Type, Value,
 };
 use sqlparser::ast::{
     Ident, Join, JoinConstraint, JoinOperator, Select, SetExpr, Statement, TableAlias,
@@ -15,7 +16,7 @@ pub struct JoinDb;
 
 impl Command for JoinDb {
     fn name(&self) -> &str {
-        "db join"
+        "join"
     }
 
     fn usage(&self) -> &str {
@@ -40,6 +41,8 @@ impl Command for JoinDb {
             .switch("right", "right outer join", Some('r'))
             .switch("outer", "full outer join", Some('o'))
             .switch("cross", "cross join", Some('c'))
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -48,11 +51,61 @@ impl Command for JoinDb {
     }
 
     fn examples(&self) -> Vec<Example> {
-        vec![Example {
+        vec![
-            description: "",
+            Example {
-            example: "",
+                description: "joins two tables on col_b",
-            result: None,
+                example: r#"open db.mysql
-        }]
+    | into db
+    | select col_a
+    | from table_1 --as t1
+    | join table_2 col_b --as t2
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT col_a FROM table_1 AS t1 JOIN table_2 AS t2 ON col_b"
+                                .into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "joins a table with a derived table using aliases",
+                example: r#"open db.mysql
+    | into db
+    | select col_a
+    | from table_1 --as t1
+    | join (
+        open db.mysql
+        | into db
+        | select col_c
+        | from table_2
+      ) ((field t1.col_a) == (field t2.col_c)) --as t2 --right
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT col_a FROM table_1 AS t1 RIGHT JOIN (SELECT col_c FROM table_2) AS t2 ON t1.col_a = t2.col_c"
+                                .into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
     }
 
     fn run(
@@ -176,3 +229,23 @@ fn modify_from(
         )),
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::super::expressions::{FieldExpr, OrExpr};
+    use super::super::{FromDb, ProjectionDb, WhereDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(JoinDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FromDb {}),
+            Box::new(WhereDb {}),
+            Box::new(FieldExpr {}),
+            Box::new(OrExpr {}),
+        ])
+    }
+}

crates/nu-command/src/database/commands/limit.rs

@@ -4,7 +4,8 @@ use nu_engine::CallExt;
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Value,
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Type, Value,
 };
 use sqlparser::ast::Statement;
 
@@ -13,7 +14,7 @@ pub struct LimitDb;
 
 impl Command for LimitDb {
     fn name(&self) -> &str {
-        "db limit"
+        "limit"
     }
 
     fn usage(&self) -> &str {
@@ -27,6 +28,8 @@ impl Command for LimitDb {
                 SyntaxShape::Int,
                 "Number of rows to extract for query",
             )
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -37,12 +40,26 @@ impl Command for LimitDb {
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Limits selection from table",
-            example: r#"db open db.mysql 
+            example: r#"open db.mysql
-    | db from table_a 
+    | into db
-    | db select a 
+    | from table_a
-    | db limit 10 
+    | select a
-    | db describe"#,
+    | limit 10
-            result: None,
+    | describe"#,
+            result: Some(Value::Record {
+                cols: vec!["connection".into(), "query".into()],
+                vals: vec![
+                    Value::String {
+                        val: "db.mysql".into(),
+                        span: Span::test_data(),
+                    },
+                    Value::String {
+                        val: "SELECT a FROM table_a LIMIT 10".into(),
+                        span: Span::test_data(),
+                    },
+                ],
+                span: Span::test_data(),
+            }),
         }]
     }
 
@@ -84,3 +101,23 @@ impl Command for LimitDb {
         Ok(db.into_value(call.head).into_pipeline_data())
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::super::expressions::{FieldExpr, OrExpr};
+    use super::super::{FromDb, ProjectionDb, WhereDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(LimitDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FromDb {}),
+            Box::new(WhereDb {}),
+            Box::new(FieldExpr {}),
+            Box::new(OrExpr {}),
+        ])
+    }
+}

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

@@ -3,22 +3,19 @@ pub mod conversions;
 
 mod alias;
 mod and;
-mod col;
 mod collect;
-mod command;
 mod describe;
 mod from;
-mod function;
 mod group_by;
 mod join;
 mod limit;
 mod open;
 mod or;
 mod order_by;
-mod over;
 mod query;
 mod schema;
 mod select;
+mod to_db;
 mod where_;
 
 // Temporal module to create Query objects
@@ -27,27 +24,24 @@ use testing::TestingDb;
 
 use nu_protocol::engine::StateWorkingSet;
 
-use alias::AliasExpr;
+use alias::AliasDb;
 use and::AndDb;
-use col::ColExpr;
 use collect::CollectDb;
-use command::Database;
+pub(crate) use describe::DescribeDb;
-use describe::DescribeDb;
+pub(crate) use from::FromDb;
-use from::FromDb;
-use function::FunctionExpr;
 use group_by::GroupByDb;
 use join::JoinDb;
 use limit::LimitDb;
 use open::OpenDb;
 use or::OrDb;
 use order_by::OrderByDb;
-use over::OverExpr;
 use query::QueryDb;
 use schema::SchemaDb;
-use select::ProjectionDb;
+pub(crate) use select::ProjectionDb;
+pub(crate) use to_db::ToDataBase;
 use where_::WhereDb;
 
-pub fn add_database_decls(working_set: &mut StateWorkingSet) {
+pub fn add_commands_decls(working_set: &mut StateWorkingSet) {
     macro_rules! bind_command {
             ( $command:expr ) => {
                 working_set.add_decl(Box::new($command));
@@ -59,21 +53,18 @@ pub fn add_database_decls(working_set: &mut StateWorkingSet) {
 
     // Series commands
     bind_command!(
-        AliasExpr,
+        ToDataBase,
+        AliasDb,
         AndDb,
-        ColExpr,
         CollectDb,
-        Database,
         DescribeDb,
         FromDb,
-        FunctionExpr,
         GroupByDb,
         JoinDb,
         LimitDb,
         OpenDb,
         OrderByDb,
         OrDb,
-        OverExpr,
         QueryDb,
         ProjectionDb,
         SchemaDb,

crates/nu-command/src/database/commands/open.rs

@@ -4,6 +4,7 @@ use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Spanned, SyntaxShape,
+    Type,
 };
 use std::path::PathBuf;
 
@@ -12,12 +13,14 @@ pub struct OpenDb;
 
 impl Command for OpenDb {
     fn name(&self) -> &str {
-        "db open"
+        "open-db"
     }
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("query", SyntaxShape::Filepath, "SQLite file to be opened")
+            .input_type(Type::Any)
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -31,8 +34,8 @@ impl Command for OpenDb {
 
     fn examples(&self) -> Vec<Example> {
         vec![Example {
-            description: "Open a sqlite file",
+            description: "Creates a connection to a sqlite database based on the file name",
-            example: r#"db open file.sqlite"#,
+            example: r#"open-db file.sqlite"#,
             result: None,
         }]
     }

crates/nu-command/src/database/commands/or.rs

@@ -6,7 +6,7 @@ use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
-    Value,
+    Type, Value,
 };
 use sqlparser::ast::{BinaryOperator, Expr, Query, Select, SetExpr, Statement};
 
@@ -15,16 +15,18 @@ pub struct OrDb;
 
 impl Command for OrDb {
     fn name(&self) -> &str {
-        "db or"
+        "or"
     }
 
     fn usage(&self) -> &str {
-        "Includes an OR clause for a query or expression"
+        "Includes an OR clause for a query"
     }
 
     fn signature(&self) -> Signature {
         Signature::build(self.name())
             .required("where", SyntaxShape::Any, "Where expression on the table")
+            .input_type(Type::Custom("database".into()))
+            .output_type(Type::Custom("database".into()))
             .category(Category::Custom("database".into()))
     }
 
@@ -35,23 +37,52 @@ impl Command for OrDb {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "selects a column from a database with a where clause",
+                description: "selects a column from a database with an OR clause",
-                example: r#"db open db.mysql 
+                example: r#"open db.mysql
-    | db select a 
+    | into db
-    | db from table_1 
+    | select a
-    | db where ((db col a) > 1) 
+    | from table_1
-    | db or ((db col b) == 1) 
+    | where ((field a) > 1)
-    | db describe"#,
+    | or ((field b) == 1)
-                result: None,
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT a FROM table_1 WHERE a > 1 OR b = 1".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
             },
             Example {
-                description: "Creates a nested where clause",
+                description: "Creates an OR clause in the column names and a column",
-                example: r#"db open db.mysql 
+                example: r#"open db.mysql
-    | db select a 
+    | into db
-    | db from table_1 
+    | select a
-    | db where ((db col a) > 1 | db or ((db col a) < 10)) 
+    | from table_1
-    | db describe"#,
+    | where ((field a) > 1 | or ((field a) < 10))
-                result: None,
+    | or ((field b) == 1)
+    | describe"#,
+                result: Some(Value::Record {
+                    cols: vec!["connection".into(), "query".into()],
+                    vals: vec![
+                        Value::String {
+                            val: "db.mysql".into(),
+                            span: Span::test_data(),
+                        },
+                        Value::String {
+                            val: "SELECT a FROM table_1 WHERE (a > 1 OR a < 10) OR b = 1".into(),
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
             },
         ]
     }
@@ -66,51 +97,32 @@ impl Command for OrDb {
         let value: Value = call.req(engine_state, stack, 0)?;
         let expr = ExprDb::try_from_value(&value)?.into_native();
 
-        let value = input.into_value(call.head);
+        let mut db = SQLiteDatabase::try_from_pipeline(input, call.head)?;
-        if let Ok(expression) = ExprDb::try_from_value(&value) {
+        match db.statement {
-            let expression = Expr::BinaryOp {
+            Some(ref mut statement) => match statement {
-                left: Box::new(expression.into_native()),
+                Statement::Query(query) => modify_query(query, expr, call.head)?,
-                op: BinaryOperator::Or,
+                s => {
-                right: Box::new(expr),
-            };
-
-            let expression: ExprDb = Expr::Nested(Box::new(expression)).into();
-
-            Ok(expression.into_value(call.head).into_pipeline_data())
-        } else if let Ok(mut db) = SQLiteDatabase::try_from_value(value.clone()) {
-            match db.statement {
-                Some(ref mut statement) => match statement {
-                    Statement::Query(query) => modify_query(query, expr, call.head)?,
-                    s => {
-                        return Err(ShellError::GenericError(
-                            "Connection doesnt define a query".into(),
-                            format!("Expected a connection with query. Got {}", s),
-                            Some(call.head),
-                            None,
-                            Vec::new(),
-                        ))
-                    }
-                },
-                None => {
                     return Err(ShellError::GenericError(
-                        "Connection without statement".into(),
+                        "Connection doesnt define a query".into(),
-                        "The connection needs a statement defined".into(),
+                        format!("Expected a connection with query. Got {}", s),
                         Some(call.head),
                         None,
                         Vec::new(),
                     ))
                 }
-            };
+            },
+            None => {
+                return Err(ShellError::GenericError(
+                    "Connection without statement".into(),
+                    "The connection needs a statement defined".into(),
+                    Some(call.head),
+                    None,
+                    Vec::new(),
+                ))
+            }
+        };
 
-            Ok(db.into_value(call.head).into_pipeline_data())
+        Ok(db.into_value(call.head).into_pipeline_data())
-        } else {
-            Err(ShellError::CantConvert(
-                "expression or query".into(),
-                value.get_type().to_string(),
-                value.span()?,
-                None,
-            ))
-        }
     }
 }
 
@@ -150,3 +162,23 @@ fn modify_select(select: &mut Box<Select>, expression: Expr, span: Span) -> Resu
     select.as_mut().selection = Some(new_expression);
     Ok(())
 }
+
+#[cfg(test)]
+mod test {
+    use super::super::super::expressions::{FieldExpr, OrExpr};
+    use super::super::{FromDb, ProjectionDb, WhereDb};
+    use super::*;
+    use crate::database::test_database::test_database;
+
+    #[test]
+    fn test_examples() {
+        test_database(vec![
+            Box::new(OrDb {}),
+            Box::new(ProjectionDb {}),
+            Box::new(FromDb {}),
+            Box::new(WhereDb {}),
+            Box::new(FieldExpr {}),
+            Box::new(OrExpr {}),
+        ])
+    }
+}