bump miette to 4.4.0 (#5167)

This fixes an issue where docsrs error links were not working.

Ref: https://github.com/zkat/miette/issues/147

.azure/azure-pipelines.yml

@@ -1,66 +0,0 @@
-trigger:
-  - main
-
-strategy:
-  matrix:
-    linux-stable:
-      image: ubuntu-18.04
-      style: 'unflagged'
-    linux-minimal:
-      image: ubuntu-18.04
-      style: 'minimal'
-    linux-extra:
-      image: ubuntu-18.04
-      style: 'extra'
-    linux-wasm:
-      image: ubuntu-18.04
-      style: 'wasm'
-    macos-stable:
-      image: macos-10.14
-      style: 'unflagged'
-    windows-stable:
-      image: windows-2019
-      style: 'unflagged'
-    fmt:
-      image: ubuntu-18.04
-      style: 'fmt'
-
-pool:
-  vmImage: $(image)
-
-steps:
-  - bash: |
-      set -e
-      if [ -e /etc/debian_version ]
-      then
-        sudo apt-get -y install libxcb-composite0-dev libx11-dev
-      fi
-      if [ "$(uname)" == "Darwin" ]; then
-        curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
-        echo "Installing clippy"
-        rustup component add clippy --toolchain stable-x86_64-apple-darwin
-        export PATH=$HOME/.cargo/bin:$PATH
-      fi
-  #     rustup update
-  #     rustc -Vv
-  #     echo "##vso[task.prependpath]$HOME/.cargo/bin"
-  #     rustup component add rustfmt
-    displayName: Install Rust
-  - bash: RUSTFLAGS="-D warnings" cargo test --all
-    condition: eq(variables['style'], 'unflagged')
-    displayName: Run tests
-  - bash: RUSTFLAGS="-D warnings" cargo clippy --all -- -D clippy::unwrap_used -A clippy::needless_collect
-    condition: eq(variables['style'], 'unflagged')
-    displayName: Check clippy lints
-  - bash: cd samples/wasm && npm install wasm-pack && node ./node_modules/wasm-pack/run.js build
-    condition: eq(variables['style'], 'wasm')
-    displayName: Wasm build
-  - bash: RUSTFLAGS="-D warnings" cargo test --all --no-default-features --features=rustyline-support
-    condition: eq(variables['style'], 'minimal')
-    displayName: Run tests
-  - bash: RUSTFLAGS="-D warnings" cargo test --all --features=extra
-    condition: eq(variables['style'], 'extra')
-    displayName: Run tests
-  - bash: cargo fmt --all -- --check
-    condition: eq(variables['style'], 'fmt')
-    displayName: Lint

.cargo/config.toml

@@ -1,6 +1,13 @@
-# use LLD as linker on Windows because it could be faster
-# for full and incremental builds compared to default
-
+# increase the default windows stack size
 [target.x86_64-pc-windows-msvc]
-#linker = "lld-link.exe"
-rustflags = ["-C", "link-args=-stack:10000000"]
+rustflags = ["-C", "link-args=-stack:10000000"]
+
+# keeping this but commentting out in case we need them in the future
+
+# set a 2 gb stack size (0x80000000 = 2147483648 bytes = 2 GB)
+# [target.x86_64-unknown-linux-gnu]
+# rustflags = ["-C", "link-args=-Wl,-z stack-size=0x80000000"]
+
+# set a 2 gb stack size (0x80000000 = 2147483648 bytes = 2 GB)
+# [target.x86_64-apple-darwin]
+# rustflags = ["-C", "link-args=-Wl,-stack_size,0x80000000"]

.circleci/config.yml

@@ -1,165 +0,0 @@
-# CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/configuration-reference/ for more details
-# See https://circleci.com/docs/2.0/config-intro/#section=configuration for spec
-#
-version: 2.1
-
-# Commands
-
-commands:
-
-  pull_cache:
-    description: Pulls Quay.io docker images (latest) for our cache
-    parameters:
-      tag:
-        type: string
-        default: "devel"
-    steps:
-      - run: echo "Tag is << parameters.tag >>"
-      - run: docker pull quay.io/nushell/nu:<< parameters.tag >>
-      - run: docker pull quay.io/nushell/nu-base:<< parameters.tag >>
-
-orbs:
-  # https://circleci.com/orbs/registry/orb/circleci/docker
-  docker: circleci/docker@0.5.13
-
-workflows:
-  version: 2.0
-
-  # This builds on all pull requests to test, and ignores main
-  build_without_deploy:
-    jobs:
-      - docker/publish:
-          deploy: false
-          image: nushell/nu-base
-          tag: latest
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:devel
-          filters:
-            branches:
-              ignore:
-                - main
-          before_build:
-            - pull_cache
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build -f docker/Dockerfile -t quay.io/nushell/nu .
-            - run:
-                name: Preview Docker Tag for Nushell Build
-                command: |
-                   DOCKER_TAG=$(docker run quay.io/nushell/nu --version | cut -d' ' -f2)
-                   echo "Version that would be used for Docker tag is v${DOCKER_TAG}"
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu-base --help
-                   docker run --rm quay.io/nushell/nu --help
-
-  # workflow publishes to Docker Hub, with each job having different triggers
-  build_with_deploy:
-    jobs:
-
-        # Deploy versioned and latest images on tags (releases) only - builds --release.
-      - docker/publish:
-          image: nushell/nu-base
-          registry: quay.io
-          tag: latest
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:latest,quay.io/nushell/nu:latest --build-arg RELEASE=true
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /^\d+\.\d+\.\d+$/
-          before_build:
-            - run: docker pull quay.io/nushell/nu:latest
-            - run: docker pull quay.io/nushell/nu-base:latest
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build -f docker/Dockerfile -t quay.io/nushell/nu .
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu --help
-                   docker run --rm quay.io/nushell/nu-base --help
-            - run:
-                name: Publish Docker Tag with Nushell Version
-                command: |
-                   DOCKER_TAG=$(docker run quay.io/nushell/nu --version | cut -d' ' -f2)
-                   echo "Version for Docker tag is ${DOCKER_TAG}"
-                   docker tag quay.io/nushell/nu-base:latest quay.io/nushell/nu-base:${DOCKER_TAG}
-                   docker tag quay.io/nushell/nu:latest quay.io/nushell/nu:${DOCKER_TAG}
-                   docker push quay.io/nushell/nu-base
-                   docker push quay.io/nushell/nu
-
-
-  # publish devel to Docker Hub on merge to main (doesn't build --release)
-  build_with_deploy_devel:
-    jobs:
-
-      # Deploy devel tag on merge to main
-      - docker/publish:
-          image: nushell/nu-base
-          registry: quay.io
-          tag: devel
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:devel
-          before_build:
-            - pull_cache
-          filters:
-            branches:
-              only: main
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build --build-arg FROMTAG=devel -f docker/Dockerfile -t quay.io/nushell/nu:devel .
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu:devel --help
-                   docker run --rm quay.io/nushell/nu-base:devel --help
-            - run:
-                name: Publish Development Docker Tags
-                command: |
-                   docker push quay.io/nushell/nu-base:devel
-                   docker push quay.io/nushell/nu:devel
-
-  nightly:
-    triggers:
-      - schedule:
-          cron: "0 0 * * *"
-          filters:
-            branches:
-              only:
-                - main
-    jobs:
-      - docker/publish:
-          image: nushell/nu-base
-          registry: quay.io
-          tag: nightly
-          dockerfile: docker/Dockerfile.nu-base
-          extra_build_args: --cache-from=quay.io/nushell/nu-base:nightly --build-arg RELEASE=true
-          before_build:
-            - run: docker pull quay.io/nushell/nu:nightly
-            - run: docker pull quay.io/nushell/nu-base:nightly
-          after_build:
-            - run:
-                name: Build Multistage (smaller) container
-                command: |
-                  docker build -f docker/Dockerfile -t quay.io/nushell/nu:nightly .
-            - run:
-                name: Test Executable
-                command: |
-                   docker run --rm quay.io/nushell/nu:nightly --help
-                   docker run --rm quay.io/nushell/nu-base:nightly --help
-            - run:
-                name: Publish Nightly Nushell Containers
-                command: |
-                   docker push quay.io/nushell/nu-base:nightly
-                   docker push quay.io/nushell/nu:nightly

.dockerignore

@@ -1 +0,0 @@
-target

.editorconfig

@@ -1,14 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = false
-end_of_line = lf
-
-[*.{yml,yaml}]
-indent_size = 2
-charset = utf-8
-insert_final_newline = true

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,17 +1,17 @@
 name: Bug Report
 description: Create a report to help us improve
-body:
+body: 
   - type: textarea
     id: description
     attributes:
-      label: Describe the Bug
-      description: A clear and concise description of what the bug is.
+      label: Describe the bug
+      description: Thank you for your bug report.
     validations:
       required: true
   - type: textarea
     id: repro
     attributes:
-      label: To Reproduce
+      label: How to reproduce
       description: Steps to reproduce the behavior
       placeholder: |
         1.
@@ -38,28 +38,26 @@ body:
     id: config
     attributes:
       label: Configuration
-      description: "Please run `> version | pivot` and paste the output to show OS, features, etc"
+      description: "Please run `version | transpose key value | to md --pretty` and paste the output to show OS, features, etc."
       placeholder: |
-        > version | pivot
-        ╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
-        │ # │ Column0            │ Column1                                                               │
-        ├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
-        │ 0 │ version            │ 0.24.1                                                                │
-        │ 1 │ build_os           │ macos-x86_64                                                          │
-        │ 2 │ rust_version       │ rustc 1.48.0                                                          │
-        │ 3 │ cargo_version      │ cargo 1.48.0                                                          │
-        │ 4 │ pkg_version        │ 0.24.1                                                                │
-        │ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
-        │ 6 │ build_rust_channel │ release                                                               │
-        │ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, rich-benchmark,        │
-        │   │                    │ rustyline, term, uuid, which, zip                                     │
-        ╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
+        > version | transpose key value | to md --pretty
+        | key                | value                                                                                                                                                                   |
+        | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+        | version            | 0.40.0                                                                                                                                                                  |
+        | build_os           | linux-x86_64                                                                                                                                                            |
+        | rust_version       | rustc 1.56.1                                                                                                                                                            |
+        | cargo_version      | cargo 1.56.0                                                                                                                                                            |
+        | pkg_version        | 0.40.0                                                                                                                                                                  |
+        | build_time         | 1980-01-01 00:00:00 +00:00                                                                                                                                              |
+        | build_rust_channel | release                                                                                                                                                                 |
+        | features           | clipboard-cli, ctrlc, dataframe, default, rustyline, term, trash, uuid, which, zip                                                                                      |
+        | installed_plugins  | binaryview, chart bar, chart line, fetch, from bson, from sqlite, inc, match, post, ps, query json, s3, selector, start, sys, textview, to bson, to sqlite, tree, xpath |
     validations:
       required: false
   - type: textarea
     id: context
     attributes:
-      label: Additional Context
+      label: Additional context
       description: Add any other context about the problem here.
     validations:
       required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -4,8 +4,8 @@ body:
   - type: textarea
     id: problem
     attributes:
-      label: Related Problem
-      description: Is your feature request related to a problem? Please describe.
+      label: Related problem
+      description: Thank you for your feature request.
       placeholder: |
         A clear and concise description of what the problem is.
         Example: I am trying to do [...] but [...]
@@ -28,7 +28,7 @@ body:
   - type: textarea
     id: context
     attributes:
-      label: Additional Context and Details
+      label: Additional context and details
       description: Add any other context or screenshots about the feature request here.
     validations:
       required: false

.github/pull_request_template.md

@@ -0,0 +1,11 @@
+# Description
+
+(description of your pull request here)
+
+# Tests
+
+Make sure you've run and fixed any issues with these commands:
+
+- [ ] `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
+- [ ] `cargo clippy --all --all-features -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style
+- [ ] `cargo build; cargo test --all --all-features` to check that all the tests pass

.github/workflows/ci.yml

@@ -0,0 +1,114 @@
+on: [pull_request]
+
+name: Continuous integration
+
+jobs:
+  ci:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-latest]
+        style: [all, default, minimal]
+        rust:
+          - stable
+        include:
+          - style: all
+            flags: '--all-features'
+          - style: default
+            flags: ''
+          - style: minimal
+            flags: '--no-default-features'
+        exclude:
+          - platform: windows-latest
+            style: default
+          - platform: windows-latest
+            style: minimal
+          - platform: macos-latest
+            style: default
+          - platform: macos-latest
+            style: minimal
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - name: Rustfmt
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all ${{ matrix.flags }} -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect
+
+      - name: Build Nushell
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: ${{ matrix.flags }}
+
+      - name: Tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all ${{ matrix.flags }}
+
+
+  python-virtualenv:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+        rust:
+          - stable
+        py:
+          - py
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - name: Install Nushell
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: --path=. --no-default-features
+
+      - name: Setup Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.10"
+
+      - run: python -m pip install tox
+
+      - name: Install virtualenv
+        run: |
+          git clone https://github.com/kubouch/virtualenv.git && \
+          cd virtualenv && \
+          git checkout engine-q-update
+        shell: bash
+
+      - name: Test Nushell in virtualenv
+        run: cd virtualenv && tox -e ${{ matrix.py }} -- -k nushell
+        shell: bash

.github/workflows/docker-publish.yml

@@ -1,118 +0,0 @@
-name: Publish consumable Docker images
-
-on:
-  push:
-    tags: ['v?[0-9]+.[0-9]+.[0-9]+*']
-
-jobs:
-  compile:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        arch:
-        - x86_64-unknown-linux-musl
-        - x86_64-unknown-linux-gnu
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install rust-embedded/cross
-      env: { VERSION: v0.1.16 }
-      run: >-
-        wget -nv https://github.com/rust-embedded/cross/releases/download/${VERSION}/cross-${VERSION}-x86_64-unknown-linux-gnu.tar.gz
-        -O- | sudo tar xz -C /usr/local/bin/
-    - name: compile for specific target
-      env: { arch: '${{ matrix.arch }}' }
-      run: |
-        cross build --target ${{ matrix.arch }} --release
-        # leave only the executable file
-        rm -frd target/${{ matrix.arch }}/release/{*/*,*.d,*.rlib,.fingerprint}
-        find . -empty -delete
-    - uses: actions/upload-artifact@master
-      with:
-        name: ${{ matrix.arch }}
-        path: target/${{ matrix.arch }}/release
-
-  docker:
-    name: Build and publish docker images
-    needs: compile
-    runs-on: ubuntu-latest
-    env:
-      DOCKER_REGISTRY: quay.io/nushell
-      DOCKER_PASSWORD: ${{ secrets.DOCKER_REGISTRY }}
-      DOCKER_USER: ${{ secrets.DOCKER_USER }}
-    strategy:
-      matrix:
-        tag:
-        - alpine
-        - slim
-        - debian
-        - glibc-busybox
-        - musl-busybox
-        - musl-distroless
-        - glibc-distroless
-        - glibc
-        - musl
-        include:
-        - { tag: alpine,           base-image: alpine,                     arch: x86_64-unknown-linux-musl, plugin: true,  use-patch: false}
-        - { tag: slim,             base-image: 'debian:stable-slim',       arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
-        - { tag: debian,           base-image: debian,                     arch: x86_64-unknown-linux-gnu,  plugin: true,  use-patch: false}
-        - { tag: glibc-busybox,    base-image: 'busybox:glibc',            arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
-        - { tag: musl-busybox,     base-image: 'busybox:musl',             arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
-        - { tag: musl-distroless,  base-image: 'gcr.io/distroless/static', arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
-        - { tag: glibc-distroless, base-image: 'gcr.io/distroless/cc',     arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: true }
-        - { tag: glibc,            base-image: scratch,                    arch: x86_64-unknown-linux-gnu,  plugin: false, use-patch: false}
-        - { tag: musl,             base-image: scratch,                    arch: x86_64-unknown-linux-musl, plugin: false, use-patch: false}
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/download-artifact@master
-      with: { name: '${{ matrix.arch }}', path: target/release }
-    - name: Build and publish exact version
-      run: |-
-        export DOCKER_TAG=${GITHUB_REF##*/}-${{ matrix.tag }}
-        export NU_BINS=target/release/$( [ ${{ matrix.plugin }} = true ] && echo nu* || echo nu )
-        export PATCH=$([ ${{ matrix.use-patch }} = true ] && echo .${{ matrix.tag }} || echo '')
-        chmod +x $NU_BINS
-
-        echo ${DOCKER_PASSWORD} | docker login ${DOCKER_REGISTRY} -u ${DOCKER_USER} --password-stdin
-        docker-compose --file docker/docker-compose.package.yml build
-        docker-compose --file docker/docker-compose.package.yml push              # exact version
-      env:
-        BASE_IMAGE: ${{ matrix.base-image }}
-
-    #region semantics tagging
-    - name: Retag and push with suffixed version
-      run: |-
-        VERSION=${GITHUB_REF##*/}
-
-        latest_version=${VERSION%%%.*}-${{ matrix.tag }}
-        latest_feature=${VERSION%%.*}-${{ matrix.tag }}
-        latest_patch=${VERSION%.*}-${{ matrix.tag }}
-        exact_version=${VERSION}-${{ matrix.tag }}
-
-        tags=( ${latest_version} ${latest_feature} ${latest_patch} ${exact_version} )
-
-        for tag in ${tags[@]}; do
-          docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${tag}
-          docker push ${DOCKER_REGISTRY}/nu:${tag}
-        done
-
-        # latest version
-        docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${{ matrix.tag }}
-        docker push ${DOCKER_REGISTRY}/nu:${{ matrix.tag }}
-
-    - name: Retag and push debian as latest
-      if: matrix.tag == 'debian'
-      run: |-
-        VERSION=${GITHUB_REF##*/}
-
-        # ${latest features} ${latest patch} ${exact version}
-        tags=( ${VERSION%%.*} ${VERSION%.*} ${VERSION} )
-
-        for tag in ${tags[@]}; do
-          docker tag ${DOCKER_REGISTRY}/nu:${VERSION}-${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:${tag}
-          docker push ${DOCKER_REGISTRY}/nu:${tag}
-        done
-
-        # latest version
-        docker tag ${DOCKER_REGISTRY}/nu:${{ matrix.tag }} ${DOCKER_REGISTRY}/nu:latest
-        docker push ${DOCKER_REGISTRY}/nu:latest
-    #endregion semantics tagging

.github/workflows/release.yml

@@ -1,8 +1,9 @@
 name: Create Release Draft
 
 on:
+  workflow_dispatch:
   push:
-    tags: ['[0-9]+.[0-9]+.[0-9]+*']
+    tags: ["[0-9]+.[0-9]+.[0-9]+*"]
 
 jobs:
   linux:
@@ -28,6 +29,60 @@ jobs:
           command: build
           args: --release --all --features=extra
 
+      # - 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
 
@@ -37,8 +92,6 @@ jobs:
           cp README.build.txt output/README.txt
           cp LICENSE output/LICENSE
           rm output/*.d
-          rm output/nu_plugin_core_*
-          rm output/nu_plugin_extra_*
 
       # Note: If OpenSSL changes, this path will need to be updated
       - name: Copy OpenSSL to output
@@ -70,6 +123,60 @@ jobs:
           command: build
           args: --release --all --features=extra
 
+      # - 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
 
@@ -79,8 +186,6 @@ jobs:
           cp README.build.txt output/README.txt
           cp LICENSE output/LICENSE
           rm output/*.d
-          rm output/nu_plugin_core_*
-          rm output/nu_plugin_extra_*
 
       - name: Upload artifact
         uses: actions/upload-artifact@v2
@@ -106,7 +211,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: install
-          args: cargo-wix
+          args: cargo-wix --version 0.3.1
 
       - name: Build
         uses: actions-rs/cargo@v1
@@ -114,6 +219,60 @@ jobs:
           command: build
           args: --release --all --features=extra
 
+      # - 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
 
@@ -128,8 +287,6 @@ jobs:
           cp target\release\nu.exe output\
           cp LICENSE output\
           cp target\release\LICENSE-for-less.txt output\
-          rm target\release\nu_plugin_core_*.exe
-          rm target\release\nu_plugin_extra_*.exe
           cp target\release\nu_plugin_*.exe output\
           cp README.build.txt output\README.txt
           cp target\release\less.exe output\
@@ -274,7 +431,7 @@ jobs:
         with:
           name: windows-installer
           path: ./
-          
+
       - name: Upload Windows installer
         uses: actions/upload-release-asset@v1
         env:

.github/workflows/stale.yml

@@ -19,11 +19,10 @@ jobs:
           operations-per-run: 520
           enable-statistics: true
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: 'This issue is being marked stale because it has been open for 90 days without activity. If you feel that this is in error, please comment below and we will keep it marked as active.'
-          stale-pr-message: 'This PR is being marked stale because it has been open for 45 days without activity. If this PR is still active, please comment below and we will keep it marked as active.'
-          close-issue-message: 'This issue has been marked stale for more than 10 days without activity. Closing this issue, but if you find that the issue is still valid, please reopen.'
-          close-pr-message: 'This PR has been marked stale for more than 10 days without activity. Closing this PR, but if you are still working on it, please reopen.'
+          close-issue-message: 'This issue has been marked stale for more than 100000 days without activity. Closing this issue, but if you find that the issue is still valid, please reopen.'
+          close-pr-message: 'This PR has been marked stale for more than 100 days without activity. Closing this PR, but if you are still working on it, please reopen.'
           days-before-issue-stale: 90
           days-before-pr-stale: 45
-          days-before-issue-close: 10
-          days-before-pr-close: 10
+          days-before-issue-close: 100000
+          days-before-pr-close: 100
+          exempt-issue-labels: 'exempt,keep'

.github/workflows/winget-submission.yml

@@ -1,6 +1,7 @@
 name: Submit Nushell package to Windows Package Manager Community Repository 
 
 on:
+  workflow_dispatch:
   release:
     types: [published]
 

.gitignore

@@ -4,6 +4,7 @@
 history.txt
 tests/fixtures/nuplayground
 crates/*/target
+.mailmap
 
 # Debian/Ubuntu
 debian/.debhelper/

.gitpod.Dockerfile

@@ -1,18 +0,0 @@
-FROM gitpod/workspace-full
-
-# Gitpod will not rebuild Nushell's dev image unless *some* change is made to this Dockerfile.
-# To force a rebuild, simply increase this counter:
-ENV TRIGGER_REBUILD 1
-
-USER gitpod
-
-RUN sudo apt-get update && \
-    sudo apt-get install -y \
-        libssl-dev \
-        libxcb-composite0-dev \
-        pkg-config \
-        libpython3.6 \
-        rust-lldb \
-    && sudo rm -rf /var/lib/apt/lists/*
-
-ENV RUST_LLDB=/usr/bin/lldb-11

.gitpod.yml

@@ -1,25 +0,0 @@
-image:
-  file: .gitpod.Dockerfile
-tasks:
-  - name: Clippy
-    init: cargo clippy --all --features=stable -- -D clippy::result_unwrap_used -D clippy::option_unwrap_used
-  - name: Testing
-    init: cargo test --all --features=stable
-  - name: Build
-    init: cargo build --features=stable
-  - name: Nu
-    init: cargo install --path . --features=stable
-    command: nu
-github:
-  prebuilds:
-    branches: true
-    pullRequestsFromForks: true
-    addLabel: prebuilt-in-gitpod
-vscode:
-  extensions:
-    - hbenl.vscode-test-explorer@2.15.0:koqDUMWDPJzELp/hdS/lWw==
-    - Swellaby.vscode-rust-test-adapter@0.11.0:Xg+YeZZQiVpVUsIkH+uiiw==
-    - serayuzgur.crates@0.4.7:HMkoguLcXp9M3ud7ac3eIw==
-    - belfz.search-crates-io@1.2.1:kSLnyrOhXtYPjQpKnMr4eQ==
-    - bungcip.better-toml@0.3.2:3QfgGxxYtGHfJKQU7H0nEw==
-    - webfreak.debug@0.24.0:1zVcRsAhewYEX3/A9xjMNw==

.theia/launch.json

@@ -1,14 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-      {
-          "type": "gdb",
-          "request": "launch",
-          "name": "Debug Rust Code",
-          "preLaunchTask": "cargo",
-          "target": "${workspaceFolder}/target/debug/nu",
-          "cwd": "${workspaceFolder}",
-          "valuesFormatting": "parseText"
-      }
-  ]
-}

.theia/tasks.json

@@ -1,12 +0,0 @@
-{
-    "tasks": [
-        {
-            "command": "cargo",
-            "args": [
-                "build"
-            ],
-            "type": "process",
-            "label": "cargo",
-        }
-    ],
-}

CONTRIBUTING.md

@@ -71,5 +71,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 -- --loglevel trace
+  cargo build --release --features=extra && cargo run --release --features=extra -- --log-level trace
   ```

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-authors = ["The Nu Project Contributors"]
+authors = ["The Nushell Project Developers"]
 default-run = "nu"
 description = "A new type of shell"
 documentation = "https://www.nushell.sh/book/"
@@ -10,250 +10,93 @@ license = "MIT"
 name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.35.0"
-
-[workspace]
-members = ["crates/*/"]
+rust-version = "1.59"
+version = "0.61.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[workspace]
+members = [
+	"crates/nu-cli",
+	"crates/nu-engine",
+	"crates/nu-parser",
+	"crates/nu-system",
+	"crates/nu-command",
+	"crates/nu-protocol",
+	"crates/nu-plugin",
+	"crates/nu_plugin_inc",
+	"crates/nu_plugin_gstat",
+	"crates/nu_plugin_example",
+	"crates/nu_plugin_query",
+	"crates/nu-utils",
+]
+
 [dependencies]
-nu-cli = { version = "0.35.0", path="./crates/nu-cli", default-features=false }
-nu-command = { version = "0.35.0", path="./crates/nu-command" }
-nu-completion = { version = "0.35.0", path="./crates/nu-completion" }
-nu-data = { version = "0.35.0", path="./crates/nu-data" }
-nu-engine = { version = "0.35.0", path="./crates/nu-engine" }
-nu-errors = { version = "0.35.0", path="./crates/nu-errors" }
-nu-parser = { version = "0.35.0", path="./crates/nu-parser" }
-nu-path = { version = "0.35.0", path="./crates/nu-path" }
-nu-plugin = { version = "0.35.0", path="./crates/nu-plugin" }
-nu-protocol = { version = "0.35.0", path="./crates/nu-protocol" }
-nu-source = { version = "0.35.0", path="./crates/nu-source" }
-nu-value-ext = { version = "0.35.0", path="./crates/nu-value-ext" }
-
-nu_plugin_binaryview = { version = "0.35.0", path="./crates/nu_plugin_binaryview", optional=true }
-nu_plugin_chart = { version = "0.35.0", path="./crates/nu_plugin_chart", optional=true }
-nu_plugin_fetch = { version = "0.35.0", path="./crates/nu_plugin_fetch", optional=true }
-nu_plugin_from_bson = { version = "0.35.0", path="./crates/nu_plugin_from_bson", optional=true }
-nu_plugin_from_sqlite = { version = "0.35.0", path="./crates/nu_plugin_from_sqlite", optional=true }
-nu_plugin_inc = { version = "0.35.0", path="./crates/nu_plugin_inc", optional=true }
-nu_plugin_match = { version = "0.35.0", path="./crates/nu_plugin_match", optional=true }
-nu_plugin_post = { version = "0.35.0", path="./crates/nu_plugin_post", optional=true }
-nu_plugin_ps = { version = "0.35.0", path="./crates/nu_plugin_ps", optional=true }
-nu_plugin_query_json = { version = "0.35.0", path="./crates/nu_plugin_query_json", optional=true }
-nu_plugin_s3 = { version = "0.35.0", path="./crates/nu_plugin_s3", optional=true }
-nu_plugin_selector = { version = "0.35.0", path="./crates/nu_plugin_selector", optional=true }
-nu_plugin_start = { version = "0.35.0", path="./crates/nu_plugin_start", optional=true }
-nu_plugin_sys = { version = "0.35.0", path="./crates/nu_plugin_sys", optional=true }
-nu_plugin_textview = { version = "0.35.0", path="./crates/nu_plugin_textview", optional=true }
-nu_plugin_to_bson = { version = "0.35.0", path="./crates/nu_plugin_to_bson", optional=true }
-nu_plugin_to_sqlite = { version = "0.35.0", path="./crates/nu_plugin_to_sqlite", optional=true }
-nu_plugin_tree = { version = "0.35.0", path="./crates/nu_plugin_tree", optional=true }
-nu_plugin_xpath = { version = "0.35.0", path="./crates/nu_plugin_xpath", optional=true }
-
-# Required to bootstrap the main binary
-ctrlc = { version="3.1.7", optional=true }
-futures = { version="0.3.12", features=["compat", "io-compat"] }
-itertools = "0.10.0"
+chrono = "0.4.19"
+crossterm = "0.23.0"
+ctrlc = "3.2.1"
+log = "0.4"
+miette = "4.1.0"
+nu-ansi-term = "0.45.1"
+nu-cli = { path="./crates/nu-cli", version = "0.61.0"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.61.0"  }
+nu-command = { path="./crates/nu-command", version = "0.61.0"  }
+nu-engine = { path="./crates/nu-engine", version = "0.61.0"  }
+nu-json = { path="./crates/nu-json", version = "0.61.0"  }
+nu-parser = { path="./crates/nu-parser", version = "0.61.0"  }
+nu-path = { path="./crates/nu-path", version = "0.61.0"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.61.0"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.61.0"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.61.0"  }
+nu-system = { path = "./crates/nu-system", version = "0.61.0" }
+nu-table = { path = "./crates/nu-table", version = "0.61.0"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.61.0"  }
+pretty_env_logger = "0.4.0"
+rayon = "1.5.1"
+reedline = { version = "0.4.0", features = ["bashisms"]}
+is_executable = "1.0.1"
 
 [dev-dependencies]
-nu-test-support = { version = "0.35.0", path="./crates/nu-test-support" }
-dunce = "1.0.1"
+nu-test-support = { path="./crates/nu-test-support", version = "0.61.0"  }
+tempfile = "3.2.0"
+assert_cmd = "2.0.2"
+pretty_assertions = "1.0.0"
 serial_test = "0.5.1"
 hamcrest2 = "0.3.0"
-rstest = "0.10.0"
+rstest = "0.12.0"
+itertools = "0.10.3"
 
-[build-dependencies]
+[target.'cfg(windows)'.build-dependencies]
+embed-resource = "1"
 
 [features]
-ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
-rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
-term-support = ["nu-command/term"]
-uuid-support = ["nu-command/uuid_crate"]
-which-support = ["nu-command/which", "nu-engine/which"]
-
-default = [
-    "nu-cli/shadow-rs",
-    "sys",
-    "ps",
-    "ctrlc-support",
-    "which-support",
-    "term-support",
-    "rustyline-support",
-    "match",
-    "post",
-    "fetch",
-    "zip-support",
-    "dataframe",
-]
-
+plugin = ["nu-plugin", "nu-cli/plugin", "nu-parser/plugin", "nu-command/plugin", "nu-protocol/plugin", "nu-engine/plugin"]
+default = ["plugin", "which-support", "zip-support", "trash-support"]
 stable = ["default"]
-extra = [
-    "default",
-    "binaryview",
-    "inc",
-    "tree",
-    "textview",
-    "clipboard-cli",
-    "trash-support",
-    "uuid-support",
-    "start",
-    "bson",
-    "sqlite",
-    "s3",
-    "chart",
-    "xpath",
-    "selector",
-    "query-json",
-]
-
-wasi = ["inc", "match", "match", "tree", "rustyline-support"]
+extra = ["default", "dataframe"]
+wasi = []
 
 # Stable (Default)
-fetch = ["nu_plugin_fetch"]
-inc = ["nu_plugin_inc"]
-match = ["nu_plugin_match"]
-post = ["nu_plugin_post"]
-ps = ["nu_plugin_ps"]
-sys = ["nu_plugin_sys"]
-textview = ["nu_plugin_textview"]
+which-support = ["nu-command/which-support"]
+zip-support = ["nu-command/zip"]
+trash-support = ["nu-command/trash-support"]
 
 # Extra
-binaryview = ["nu_plugin_binaryview"]
-bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
-chart = ["nu_plugin_chart"]
-clipboard-cli = ["nu-command/clipboard-cli"]
-query-json = ["nu_plugin_query_json"]
-s3 = ["nu_plugin_s3"]
-selector = ["nu_plugin_selector"]
-sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
-start = ["nu_plugin_start"]
-trash-support = [
-    "nu-command/trash-support",
-    "nu-engine/trash-support",
-]
-tree = ["nu_plugin_tree"]
-xpath = ["nu_plugin_xpath"]
-zip-support = ["nu-command/zip"]
 
-#This is disabled in extra for now
-table-pager = ["nu-command/table-pager"]
+# Dataframe feature for nushell
+dataframe = ["nu-command/dataframe"]
 
-#dataframe feature for nushell
-dataframe = [
-    "nu-engine/dataframe",
-    "nu-protocol/dataframe",
-    "nu-command/dataframe",
-    "nu-value-ext/dataframe",
-    "nu-data/dataframe",
-    "nu_plugin_post/dataframe",
-    "nu_plugin_to_bson/dataframe",
-]
+[profile.release]
+opt-level = "s" # Optimize for size
+strip = "debuginfo"
+lto = "thin"
 
-# Core plugins that ship with `cargo install nu` by default
-# Currently, Cargo limits us to installing only one binary
-# unless we use [[bin]], so we use this as a workaround
-[[bin]]
-name = "nu_plugin_core_textview"
-path = "src/plugins/nu_plugin_core_textview.rs"
-required-features = ["textview"]
-
-[[bin]]
-name = "nu_plugin_core_inc"
-path = "src/plugins/nu_plugin_core_inc.rs"
-required-features = ["inc"]
-
-[[bin]]
-name = "nu_plugin_core_ps"
-path = "src/plugins/nu_plugin_core_ps.rs"
-required-features = ["ps"]
-
-[[bin]]
-name = "nu_plugin_core_sys"
-path = "src/plugins/nu_plugin_core_sys.rs"
-required-features = ["sys"]
-
-[[bin]]
-name = "nu_plugin_core_fetch"
-path = "src/plugins/nu_plugin_core_fetch.rs"
-required-features = ["fetch"]
-
-[[bin]]
-name = "nu_plugin_core_match"
-path = "src/plugins/nu_plugin_core_match.rs"
-required-features = ["match"]
-
-[[bin]]
-name = "nu_plugin_core_post"
-path = "src/plugins/nu_plugin_core_post.rs"
-required-features = ["post"]
-
-# Extra plugins
-
-[[bin]]
-name = "nu_plugin_extra_binaryview"
-path = "src/plugins/nu_plugin_extra_binaryview.rs"
-required-features = ["binaryview"]
-
-[[bin]]
-name = "nu_plugin_extra_tree"
-path = "src/plugins/nu_plugin_extra_tree.rs"
-required-features = ["tree"]
-
-[[bin]]
-name = "nu_plugin_extra_query_json"
-path = "src/plugins/nu_plugin_extra_query_json.rs"
-required-features = ["query-json"]
-
-[[bin]]
-name = "nu_plugin_extra_start"
-path = "src/plugins/nu_plugin_extra_start.rs"
-required-features = ["start"]
-
-[[bin]]
-name = "nu_plugin_extra_s3"
-path = "src/plugins/nu_plugin_extra_s3.rs"
-required-features = ["s3"]
-
-[[bin]]
-name = "nu_plugin_extra_chart_bar"
-path = "src/plugins/nu_plugin_extra_chart_bar.rs"
-required-features = ["chart"]
-
-[[bin]]
-name = "nu_plugin_extra_chart_line"
-path = "src/plugins/nu_plugin_extra_chart_line.rs"
-required-features = ["chart"]
-
-[[bin]]
-name = "nu_plugin_extra_xpath"
-path = "src/plugins/nu_plugin_extra_xpath.rs"
-required-features = ["xpath"]
-
-[[bin]]
-name = "nu_plugin_extra_selector"
-path = "src/plugins/nu_plugin_extra_selector.rs"
-required-features = ["selector"]
-
-[[bin]]
-name = "nu_plugin_extra_from_bson"
-path = "src/plugins/nu_plugin_extra_from_bson.rs"
-required-features = ["bson"]
-
-[[bin]]
-name = "nu_plugin_extra_to_bson"
-path = "src/plugins/nu_plugin_extra_to_bson.rs"
-required-features = ["bson"]
-
-[[bin]]
-name = "nu_plugin_extra_from_sqlite"
-path = "src/plugins/nu_plugin_extra_from_sqlite.rs"
-required-features = ["sqlite"]
-
-[[bin]]
-name = "nu_plugin_extra_to_sqlite"
-path = "src/plugins/nu_plugin_extra_to_sqlite.rs"
-required-features = ["sqlite"]
+# build with `cargo build --profile profiling`
+# to analyze performance with tooling like linux perf
+[profile.profiling]
+inherits = "release"
+strip = false
+debug = true
 
 # Main nu binary
 [[bin]]

LICENSE

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

README.md

@@ -1,7 +1,7 @@
 # README
 
 [![Crates.io](https://img.shields.io/crates/v/nu.svg)](https://crates.io/crates/nu)
-[![Build Status](https://dev.azure.com/nushell/nushell/_apis/build/status/nushell.nushell?branchName=main)](https://dev.azure.com/nushell/nushell/_build/latest?definitionId=2&branchName=main)
+[![Build Status](https://github.com/nushell/nushell/actions/workflows/ci.yml/badge.svg)](https://github.com/nushell/nushell/actions)
 [![Discord](https://img.shields.io/discord/601130461678272522.svg?logo=discord)](https://discord.gg/NtAbbGn)
 [![The Changelog #363](https://img.shields.io/badge/The%20Changelog-%23363-61c192.svg)](https://changelog.com/podcast/363)
 [![@nu_shell](https://img.shields.io/badge/twitter-@nu_shell-1DA1F3?style=flat-square)](https://twitter.com/nu_shell)
@@ -12,7 +12,7 @@
 
 A new type of shell.
 
-![Example of nushell](images/nushell-autocomplete5.gif "Example of nushell")
+![Example of nushell](images/nushell-autocomplete6.gif "Example of nushell")
 
 ## Status
 
@@ -37,17 +37,13 @@ We also have an active [Discord](https://discord.gg/NtAbbGn) and [Twitter](https
 
 You can also find information on more specific topics in our [cookbook](https://www.nushell.sh/cookbook/).
 
-Try it in Gitpod.
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)
-
 ## Installation
 
 ### Local
 
 Up-to-date installation instructions can be found in the [installation chapter of the book](https://www.nushell.sh/book/installation.html). **Windows users**: please note that Nu works on Windows 10 and does not currently have Windows 7/8.1 support.
 
-To build Nu, you will need to use the **latest stable (1.51 or later)** version of the compiler.
+To build Nu, you will need to use the **latest stable (1.59 or later)** version of the compiler.
 
 Required dependencies:
 
@@ -61,6 +57,8 @@ Optional dependencies:
 
 To install Nu via cargo (make sure you have installed [rustup](https://rustup.rs/) and the latest stable compiler via `rustup install stable`):
 
+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
 ```
@@ -68,7 +66,13 @@ cargo install nu
 To install Nu via the [Windows Package Manager](https://aka.ms/winget-cli):
 
 ```shell
-winget install nu
+winget install nushell
+```
+
+To install Nu via the [Chocolatey](https://chocolatey.org) package manager:
+
+```shell
+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:
@@ -76,53 +80,6 @@ You can also build Nu yourself with all the bells and whistles (be sure to have
 ```shell
 cargo build --workspace --features=extra
 ```
-
-### Docker
-
-#### Quickstart
-
-Want to try Nu right away? Execute the following to get started.
-
-```shell
-docker run -it quay.io/nushell/nu:latest
-```
-
-#### Guide
-
-If you want to pull a pre-built container, you can browse tags for the [nushell organization](https://quay.io/organization/nushell)
-on Quay.io. Pulling a container would come down to:
-
-```shell
-docker pull quay.io/nushell/nu
-docker pull quay.io/nushell/nu-base
-```
-
-Both "nu-base" and "nu" provide the nu binary, however, nu-base also includes the source code at `/code`
-in the container and all dependencies.
-
-Optionally, you can also build the containers locally using the [dockerfiles provided](docker):
-To build the base image:
-
-```shell
-docker build -f docker/Dockerfile.nu-base -t nushell/nu-base .
-```
-
-And then to build the smaller container (using a Multistage build):
-
-```shell
-docker build -f docker/Dockerfile -t nushell/nu .
-```
-
-Either way, you can run either container as follows:
-
-```shell
-docker run -it nushell/nu-base
-docker run -it nushell/nu
-/> exit
-```
-
-The second container is a bit smaller if the size is important to you.
-
 ### Packaging status
 
 [![Packaging status](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions)
@@ -160,12 +117,11 @@ Commands are separated by the pipe symbol (`|`) to denote a pipeline flowing lef
  0 │ assets │ Dir  │ 128 B │ 5 months ago
  1 │ crates │ Dir  │ 704 B │ 50 mins ago
  2 │ debian │ Dir  │ 352 B │ 5 months ago
- 3 │ docker │ Dir  │ 288 B │ 3 months ago
- 4 │ docs   │ Dir  │ 192 B │ 50 mins ago
- 5 │ images │ Dir  │ 160 B │ 5 months ago
- 6 │ src    │ Dir  │ 128 B │ 1 day ago
- 7 │ target │ Dir  │ 160 B │ 5 days ago
- 8 │ tests  │ Dir  │ 192 B │ 3 months ago
+ 3 │ docs   │ Dir  │ 192 B │ 50 mins ago
+ 4 │ images │ Dir  │ 160 B │ 5 months ago
+ 5 │ src    │ Dir  │ 128 B │ 1 day ago
+ 6 │ target │ Dir  │ 160 B │ 5 days ago
+ 7 │ tests  │ Dir  │ 192 B │ 3 months ago
 ───┴────────┴──────┴───────┴──────────────
 ```
 
@@ -295,24 +251,32 @@ Nu is in heavy development and will naturally change as it matures and people us
 
 | Features      | Not started | Prototype | MVP | Preview | Mature | Notes                                                                |
 | ------------- | :---------: | :-------: | :-: | :-----: | :----: | -------------------------------------------------------------------- |
-| Aliases       |             |           |  X  |         |        | Aliases allow for shortening large commands, while passing flags     |
+| Aliases       |             |           |     |    X    |        | Aliases allow for shortening large commands, while passing flags     |
 | Notebook      |             |     X     |     |         |        | Initial jupyter support, but it loses state and lacks features       |
-| File ops      |             |           |  X  |         |        | cp, mv, rm, mkdir have some support, but lacking others              |
-| Environment   |             |           |  X  |         |        | Temporary environment and scoped environment variables               |
-| Shells        |             |     X     |     |         |        | Basic value and file shells, but no opt-in/opt-out for commands      |
-| Protocol      |             |           |  X  |         |        | Streaming protocol is serviceable                                    |
-| Plugins       |             |     X     |     |         |        | Plugins work on one row at a time, lack batching and expression eval |
-| Errors        |             |           |  X  |         |        | Error reporting works, but could use usability polish                |
+| File ops      |             |           |     |    X    |        | cp, mv, rm, mkdir have some support, but lacking others              |
+| Environment   |             |           |     |    X    |        | Temporary environment and scoped environment variables               |
+| Shells        |             |           |     |    X    |        | Basic value and file shells, but no opt-in/opt-out for commands      |
+| Protocol      |             |           |     |    X    |        | Streaming protocol is serviceable                                    |
+| Plugins       |             |           |  X  |         |        | Plugins work on one row at a time, lack batching and expression eval |
+| Errors        |             |           |     |    X    |        | Error reporting works, but could use usability polish                |
 | Documentation |             |           |  X  |         |        | Book updated to latest release, including usage examples             |
-| Paging        |             |     X     |     |         |        | Textview has paging, but we'd like paging for tables                 |
-| Functions     |             |           |  X  |         |        | Functions and aliases are supported                                  |
-| Variables     |             |           |  X  |         |        | Nu supports variables and environment variables                      |
-| Completions   |             |           |  X  |         |        | Completions for filepaths                                            |
+| Paging        |             |           |     |    X    |        | Textview has paging, but we'd like paging for tables                 |
+| Functions     |             |           |     |    X    |        | Functions and aliases are supported                                  |
+| Variables     |             |           |     |    X    |        | Nu supports variables and environment variables                      |
+| Completions   |             |           |     |    X    |        | Completions for filepaths                                            |
 | Type-checking |             |           |  X  |         |        | Commands check basic types, but input/output isn't checked           |
 
-## Current Roadmap
+## Officially Supported By
 
-We've added a `Roadmap Board` to help collaboratively capture the direction we're going for the current release and capture some important issues we'd like to see in Nushell. You can find the Roadmap [here](https://github.com/nushell/nushell/projects/2).
+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)
+###   Mentions
+-   [The Python Launcher for Unix](https://github.com/brettcannon/python-launcher#how-do-i-get-a-table-of-python-executables-in-nushell)
 
 ## Contributing
 

assets/nushell.rc

@@ -0,0 +1,49 @@
+#include <winver.h>
+
+#define VER_FILEVERSION 0,59,1,0
+#define VER_FILEVERSION_STR "0.59.1"
+
+#define VER_PRODUCTVERSION 0,59,1,0
+#define VER_PRODUCTVERSION_STR "0.59.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-all-maclin.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+echo "---------------------------------------------------------------"
+echo "Building nushell (nu) with --features=extra and all the plugins"
+echo "---------------------------------------------------------------"
+echo ""
+
+NU_PLUGINS=(
+    'nu_plugin_example'
+    'nu_plugin_gstat'
+    'nu_plugin_inc'
+    'nu_plugin_query'
+)
+
+echo "Building nushell"
+cargo build --features=extra
+for plugin in "${NU_PLUGINS[@]}"
+do
+    echo '' && cd crates/$plugin
+    echo "Building $plugin..."
+    echo "-----------------------------"
+    cargo build && cd ../..
+done

build-all-windows.cmd

@@ -0,0 +1,32 @@
+@echo off
+@echo -------------------------------------------------------------------
+@echo Building nushell (nu.exe) with --features=extra and all the plugins
+@echo -------------------------------------------------------------------
+@echo.
+
+echo Building nushell.exe
+cargo build --features=extra
+@echo.
+
+@cd crates\nu_plugin_example
+echo Building nu_plugin_example.exe
+cargo build
+@echo.
+
+@cd ..\..\crates\nu_plugin_gstat
+echo Building nu_plugin_gstat.exe
+cargo build
+@echo.
+
+@cd ..\..\crates\nu_plugin_inc
+echo Building nu_plugin_inc.exe
+cargo build
+@echo.
+
+@cd ..\..\crates\nu_plugin_query
+
+echo Building nu_plugin_query.exe
+cargo build
+@echo.
+
+@cd ..\..

build-all.nu

@@ -0,0 +1,22 @@
+echo '-------------------------------------------------------------------'
+echo 'Building nushell (nu) with --features=extra and all the plugins'
+echo '-------------------------------------------------------------------'
+
+echo $'(char nl)Building nushell'
+echo '----------------------------'
+cargo build --features=extra
+
+let plugins = [
+    nu_plugin_inc,
+    nu_plugin_gstat,
+    nu_plugin_query,
+    nu_plugin_example,
+]
+
+for plugin in $plugins {
+    $'(char nl)Building ($plugin)'
+    '----------------------------'
+    cd $'crates/($plugin)'
+    cargo build
+    ignore
+}

build.rs

@@ -0,0 +1,7 @@
+#[cfg(windows)]
+fn main() {
+    embed_resource::compile_for("assets/nushell.rc", &["nu"])
+}
+
+#[cfg(not(windows))]
+fn main() {}

crates/README.md

@@ -10,4 +10,4 @@ Foundational libraries are split into two kinds of crates:
 Plugins are likewise also split into two types:
 
 * Core plugins - plugins that provide part of the default experience of Nu, including access to the system properties, processes, and web-connectivity features.
-* Extra plugins - these plugins run a wide range of differnt capabilities like working with different file types, charting, viewing binary data, and more.
+* Extra plugins - these plugins run a wide range of different capabilities like working with different file types, charting, viewing binary data, and more.

crates/nu-ansi-term/.gitignore

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

crates/nu-ansi-term/Cargo.toml

@@ -1,40 +0,0 @@
-[package]
-authors = [
-    "ogham@bsago.me",
-    "Ryan Scheel (Havvy) <ryan.havvy@gmail.com>",
-    "Josh Triplett <josh@joshtriplett.org>",
-    "The Nu Project Contributors",
-]
-description = "Library for ANSI terminal colors and styles (bold, underline)"
-edition = "2018"
-license = "MIT"
-name = "nu-ansi-term"
-version = "0.35.0"
-
-[lib]
-doctest = false
-# name = "nu-ansi-term"
-
-[features]
-derive_serde_style = ["serde"]
-
-[dependencies]
-overload = "0.1.1"
-serde = { version="1.0.90", features=["derive"], optional=true }
-itertools = "0.10.0"
-
-# [dependencies.serde]
-# version = "1.0.90"
-# features = ["derive"]
-# optional = true
-
-[target.'cfg(target_os="windows")'.dependencies.winapi]
-version = "0.3.4"
-features = ["consoleapi", "errhandlingapi", "fileapi", "handleapi", "processenv"]
-
-[dev-dependencies]
-doc-comment = "0.3"
-regex = "1.1.9"
-
-[dev-dependencies.serde_json]
-version = "1.0.39"

crates/nu-ansi-term/README.md

@@ -1,182 +0,0 @@
-# nu-ansi-term
-
-> This is a copy of rust-ansi-term but with Color change to Color and light foreground colors added (90-97) as well as light background colors added (100-107).
-
-This is a library for controlling colors and formatting, such as red bold text or blue underlined text, on ANSI terminals.
-
-### [View the Rustdoc](https://docs.rs/nu_ansi_term/)
-
-# Installation
-
-This crate works with [Cargo](http://crates.io). Add the following to your `Cargo.toml` dependencies section:
-
-```toml
-[dependencies]
-nu_ansi_term = "0.13"
-```
-
-## Basic usage
-
-There are three main types in this crate that you need to be concerned with: `ANSIString`, `Style`, and `Color`.
-
-A `Style` holds stylistic information: foreground and background colors, whether the text should be bold, or blinking, or other properties.
-The `Color` enum represents the available colors.
-And an `ANSIString` is a string paired with a `Style`.
-
-`Color` is also available as an alias to `Color`.
-
-To format a string, call the `paint` method on a `Style` or a `Color`, passing in the string you want to format as the argument.
-For example, here’s how to get some red text:
-
-```rust
-use nu_ansi_term::Color::Red;
-
-println!("This is in red: {}", Red.paint("a red string"));
-```
-
-It’s important to note that the `paint` method does _not_ actually return a string with the ANSI control characters surrounding it.
-Instead, it returns an `ANSIString` value that has a `Display` implementation that, when formatted, returns the characters.
-This allows strings to be printed with a minimum of `String` allocations being performed behind the scenes.
-
-If you _do_ want to get at the escape codes, then you can convert the `ANSIString` to a string as you would any other `Display` value:
-
-```rust
-use nu_ansi_term::Color::Red;
-
-let red_string = Red.paint("a red string").to_string();
-```
-
-**Note for Windows 10 users:** On Windows 10, the application must enable ANSI support first:
-
-```rust,ignore
-let enabled = nu_ansi_term::enable_ansi_support();
-```
-
-## Bold, underline, background, and other styles
-
-For anything more complex than plain foreground color changes, you need to construct `Style` values themselves, rather than beginning with a `Color`.
-You can do this by chaining methods based on a new `Style`, created with `Style::new()`.
-Each method creates a new style that has that specific property set.
-For example:
-
-```rust
-use nu_ansi_term::Style;
-
-println!("How about some {} and {}?",
-         Style::new().bold().paint("bold"),
-         Style::new().underline().paint("underline"));
-```
-
-For brevity, these methods have also been implemented for `Color` values, so you can give your styles a foreground color without having to begin with an empty `Style` value:
-
-```rust
-use nu_ansi_term::Color::{Blue, Yellow};
-
-println!("Demonstrating {} and {}!",
-         Blue.bold().paint("blue bold"),
-         Yellow.underline().paint("yellow underline"));
-
-println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
-```
-
-The complete list of styles you can use are:
-`bold`, `dimmed`, `italic`, `underline`, `blink`, `reverse`, `hidden`, and `on` for background colors.
-
-In some cases, you may find it easier to change the foreground on an existing `Style` rather than starting from the appropriate `Color`.
-You can do this using the `fg` method:
-
-```rust
-use nu_ansi_term::Style;
-use nu_ansi_term::Color::{Blue, Cyan, Yellow};
-
-println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
-println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
-```
-
-You can turn a `Color` into a `Style` with the `normal` method.
-This will produce the exact same `ANSIString` as if you just used the `paint` method on the `Color` directly, but it’s useful in certain cases: for example, you may have a method that returns `Styles`, and need to represent both the “red bold” and “red, but not bold” styles with values of the same type. The `Style` struct also has a `Default` implementation if you want to have a style with _nothing_ set.
-
-```rust
-use nu_ansi_term::Style;
-use nu_ansi_term::Color::Red;
-
-Red.normal().paint("yet another red string");
-Style::default().paint("a completely regular string");
-```
-
-## Extended colors
-
-You can access the extended range of 256 colors by using the `Color::Fixed` variant, which takes an argument of the color number to use.
-This can be included wherever you would use a `Color`:
-
-```rust
-use nu_ansi_term::Color::Fixed;
-
-Fixed(134).paint("A sort of light purple");
-Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
-```
-
-The first sixteen of these values are the same as the normal and bold standard color variants.
-There’s nothing stopping you from using these as `Fixed` colors instead, but there’s nothing to be gained by doing so either.
-
-You can also access full 24-bit color by using the `Color::RGB` variant, which takes separate `u8` arguments for red, green, and blue:
-
-```rust
-use nu_ansi_term::Color::RGB;
-
-RGB(70, 130, 180).paint("Steel blue");
-```
-
-## Combining successive coloured strings
-
-The benefit of writing ANSI escape codes to the terminal is that they _stack_: you do not need to end every coloured string with a reset code if the text that follows it is of a similar style.
-For example, if you want to have some blue text followed by some blue bold text, it’s possible to send the ANSI code for blue, followed by the ANSI code for bold, and finishing with a reset code without having to have an extra one between the two strings.
-
-This crate can optimise the ANSI codes that get printed in situations like this, making life easier for your terminal renderer.
-The `ANSIStrings` struct takes a slice of several `ANSIString` values, and will iterate over each of them, printing only the codes for the styles that need to be updated as part of its formatting routine.
-
-The following code snippet uses this to enclose a binary number displayed in red bold text inside some red, but not bold, brackets:
-
-```rust
-use nu_ansi_term::Color::Red;
-use nu_ansi_term::{ANSIString, ANSIStrings};
-
-let some_value = format!("{:b}", 42);
-let strings: &[ANSIString<'static>] = &[
-    Red.paint("["),
-    Red.bold().paint(some_value),
-    Red.paint("]"),
-];
-
-println!("Value: {}", ANSIStrings(strings));
-```
-
-There are several things to note here.
-Firstly, the `paint` method can take _either_ an owned `String` or a borrowed `&str`.
-Internally, an `ANSIString` holds a copy-on-write (`Cow`) string value to deal with both owned and borrowed strings at the same time.
-This is used here to display a `String`, the result of the `format!` call, using the same mechanism as some statically-available `&str` slices.
-Secondly, that the `ANSIStrings` value works in the same way as its singular counterpart, with a `Display` implementation that only performs the formatting when required.
-
-## Byte strings
-
-This library also supports formatting `[u8]` byte strings; this supports applications working with text in an unknown encoding.
-`Style` and `Color` support painting `[u8]` values, resulting in an `ANSIByteString`.
-This type does not implement `Display`, as it may not contain UTF-8, but it does provide a method `write_to` to write the result to any value that implements `Write`:
-
-```rust
-use nu_ansi_term::Color::Green;
-
-Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
-```
-
-Similarly, the type `ANSIByteStrings` supports writing a list of `ANSIByteString` values with minimal escape sequences:
-
-```rust
-use nu_ansi_term::Color::Green;
-use nu_ansi_term::ANSIByteStrings;
-
-ANSIByteStrings(&[
-    Green.paint("user data 1\n".as_bytes()),
-    Green.bold().paint("user data 2\n".as_bytes()),
-]).write_to(&mut std::io::stdout()).unwrap();
-```

crates/nu-ansi-term/examples/256_colors.rs

@@ -1,72 +0,0 @@
-extern crate nu_ansi_term;
-use nu_ansi_term::Color;
-
-// This example prints out the 256 colors.
-// They're arranged like this:
-//
-// - 0 to 8 are the eight standard colors.
-// - 9 to 15 are the eight bold colors.
-// - 16 to 231 are six blocks of six-by-six color squares.
-// - 232 to 255 are shades of grey.
-
-fn main() {
-    // First two lines
-    for c in 0..8 {
-        glow(c, c != 0);
-        print!(" ");
-    }
-    println!();
-    for c in 8..16 {
-        glow(c, c != 8);
-        print!(" ");
-    }
-    println!("\n");
-
-    // Six lines of the first three squares
-    for row in 0..6 {
-        for square in 0..3 {
-            for column in 0..6 {
-                glow(16 + square * 36 + row * 6 + column, row >= 3);
-                print!(" ");
-            }
-
-            print!("  ");
-        }
-
-        println!();
-    }
-    println!();
-
-    // Six more lines of the other three squares
-    for row in 0..6 {
-        for square in 0..3 {
-            for column in 0..6 {
-                glow(124 + square * 36 + row * 6 + column, row >= 3);
-                print!(" ");
-            }
-
-            print!("  ");
-        }
-
-        println!();
-    }
-    println!();
-
-    // The last greyscale lines
-    for c in 232..=243 {
-        glow(c, false);
-        print!(" ");
-    }
-    println!();
-    for c in 244..=255 {
-        glow(c, true);
-        print!(" ");
-    }
-    println!();
-}
-
-fn glow(c: u8, light_bg: bool) {
-    let base = if light_bg { Color::Black } else { Color::White };
-    let style = base.on(Color::Fixed(c));
-    print!("{}", style.paint(&format!(" {:3} ", c)));
-}

crates/nu-ansi-term/examples/basic_colors.rs

@@ -1,18 +0,0 @@
-extern crate nu_ansi_term;
-use nu_ansi_term::{Color::*, Style};
-
-// This example prints out the 16 basic colors.
-
-fn main() {
-    let normal = Style::default();
-
-    println!("{} {}", normal.paint("Normal"), normal.bold().paint("bold"));
-    println!("{} {}", Black.paint("Black"), Black.bold().paint("bold"));
-    println!("{} {}", Red.paint("Red"), Red.bold().paint("bold"));
-    println!("{} {}", Green.paint("Green"), Green.bold().paint("bold"));
-    println!("{} {}", Yellow.paint("Yellow"), Yellow.bold().paint("bold"));
-    println!("{} {}", Blue.paint("Blue"), Blue.bold().paint("bold"));
-    println!("{} {}", Purple.paint("Purple"), Purple.bold().paint("bold"));
-    println!("{} {}", Cyan.paint("Cyan"), Cyan.bold().paint("bold"));
-    println!("{} {}", White.paint("White"), White.bold().paint("bold"));
-}

crates/nu-ansi-term/examples/gradient_colors.rs

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

crates/nu-ansi-term/examples/rgb_colors.rs

@@ -1,23 +0,0 @@
-extern crate nu_ansi_term;
-use nu_ansi_term::{Color, Style};
-
-// This example prints out a color gradient in a grid by calculating each
-// character’s red, green, and blue components, and using 24-bit color codes
-// to display them.
-
-const WIDTH: i32 = 80;
-const HEIGHT: i32 = 24;
-
-fn main() {
-    for row in 0..HEIGHT {
-        for col in 0..WIDTH {
-            let r = (row * 255 / HEIGHT) as u8;
-            let g = (col * 255 / WIDTH) as u8;
-            let b = 128;
-
-            print!("{}", Style::default().on(Color::Rgb(r, g, b)).paint(" "));
-        }
-
-        println!();
-    }
-}

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

@@ -1,405 +0,0 @@
-#![allow(missing_docs)]
-use crate::style::{Color, Style};
-use crate::write::AnyWrite;
-use std::fmt;
-
-impl Style {
-    /// Write any bytes that go *before* a piece of text to the given writer.
-    fn write_prefix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        // If there are actually no styles here, then don’t write *any* codes
-        // as the prefix. An empty ANSI code may not affect the terminal
-        // output at all, but a user may just want a code-free string.
-        if self.is_plain() {
-            return Ok(());
-        }
-
-        // Write the codes’ prefix, then write numbers, separated by
-        // semicolons, for each text style we want to apply.
-        write!(f, "\x1B[")?;
-        let mut written_anything = false;
-
-        {
-            let mut write_char = |c| {
-                if written_anything {
-                    write!(f, ";")?;
-                }
-                written_anything = true;
-                write!(f, "{}", c)?;
-                Ok(())
-            };
-
-            if self.is_bold {
-                write_char('1')?
-            }
-            if self.is_dimmed {
-                write_char('2')?
-            }
-            if self.is_italic {
-                write_char('3')?
-            }
-            if self.is_underline {
-                write_char('4')?
-            }
-            if self.is_blink {
-                write_char('5')?
-            }
-            if self.is_reverse {
-                write_char('7')?
-            }
-            if self.is_hidden {
-                write_char('8')?
-            }
-            if self.is_strikethrough {
-                write_char('9')?
-            }
-        }
-
-        // The foreground and background colors, if specified, need to be
-        // handled specially because the number codes are more complicated.
-        // (see `write_background_code` and `write_foreground_code`)
-        if let Some(bg) = self.background {
-            if written_anything {
-                write!(f, ";")?;
-            }
-            written_anything = true;
-            bg.write_background_code(f)?;
-        }
-
-        if let Some(fg) = self.foreground {
-            if written_anything {
-                write!(f, ";")?;
-            }
-            fg.write_foreground_code(f)?;
-        }
-
-        // All the codes end with an `m`, because reasons.
-        write!(f, "m")?;
-
-        Ok(())
-    }
-
-    /// Write any bytes that go *after* a piece of text to the given writer.
-    fn write_suffix<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        if self.is_plain() {
-            Ok(())
-        } else {
-            write!(f, "{}", RESET)
-        }
-    }
-}
-
-/// The code to send to reset all styles and return to `Style::default()`.
-pub static RESET: &str = "\x1B[0m";
-
-impl Color {
-    fn write_foreground_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
-            Color::Black => write!(f, "30"),
-            Color::Red => write!(f, "31"),
-            Color::Green => write!(f, "32"),
-            Color::Yellow => write!(f, "33"),
-            Color::Blue => write!(f, "34"),
-            Color::Purple => write!(f, "35"),
-            Color::Magenta => write!(f, "35"),
-            Color::Cyan => write!(f, "36"),
-            Color::White => write!(f, "37"),
-            Color::Fixed(num) => write!(f, "38;5;{}", &num),
-            Color::Rgb(r, g, b) => write!(f, "38;2;{};{};{}", &r, &g, &b),
-            Color::DarkGray => write!(f, "90"),
-            Color::LightRed => write!(f, "91"),
-            Color::LightGreen => write!(f, "92"),
-            Color::LightYellow => write!(f, "93"),
-            Color::LightBlue => write!(f, "94"),
-            Color::LightPurple => write!(f, "95"),
-            Color::LightMagenta => write!(f, "95"),
-            Color::LightCyan => write!(f, "96"),
-            Color::LightGray => write!(f, "97"),
-        }
-    }
-
-    fn write_background_code<W: AnyWrite + ?Sized>(&self, f: &mut W) -> Result<(), W::Error> {
-        match *self {
-            Color::Black => write!(f, "40"),
-            Color::Red => write!(f, "41"),
-            Color::Green => write!(f, "42"),
-            Color::Yellow => write!(f, "43"),
-            Color::Blue => write!(f, "44"),
-            Color::Purple => write!(f, "45"),
-            Color::Magenta => write!(f, "45"),
-            Color::Cyan => write!(f, "46"),
-            Color::White => write!(f, "47"),
-            Color::Fixed(num) => write!(f, "48;5;{}", &num),
-            Color::Rgb(r, g, b) => write!(f, "48;2;{};{};{}", &r, &g, &b),
-            Color::DarkGray => write!(f, "100"),
-            Color::LightRed => write!(f, "101"),
-            Color::LightGreen => write!(f, "102"),
-            Color::LightYellow => write!(f, "103"),
-            Color::LightBlue => write!(f, "104"),
-            Color::LightPurple => write!(f, "105"),
-            Color::LightMagenta => write!(f, "105"),
-            Color::LightCyan => write!(f, "106"),
-            Color::LightGray => write!(f, "107"),
-        }
-    }
-}
-
-/// Like `ANSIString`, but only displays the style prefix.
-///
-/// This type implements the `Display` trait, meaning it can be written to a
-/// `std::fmt` formatting without doing any extra allocation, and written to a
-/// string with the `.to_string()` method. For examples, see
-/// [`Style::prefix`](struct.Style.html#method.prefix).
-#[derive(Clone, Copy, Debug)]
-pub struct Prefix(Style);
-
-/// Like `ANSIString`, but only displays the difference between two
-/// styles.
-///
-/// This type implements the `Display` trait, meaning it can be written to a
-/// `std::fmt` formatting without doing any extra allocation, and written to a
-/// string with the `.to_string()` method. For examples, see
-/// [`Style::infix`](struct.Style.html#method.infix).
-#[derive(Clone, Copy, Debug)]
-pub struct Infix(Style, Style);
-
-/// Like `ANSIString`, but only displays the style suffix.
-///
-/// This type implements the `Display` trait, meaning it can be written to a
-/// `std::fmt` formatting without doing any extra allocation, and written to a
-/// string with the `.to_string()` method. For examples, see
-/// [`Style::suffix`](struct.Style.html#method.suffix).
-#[derive(Clone, Copy, Debug)]
-pub struct Suffix(Style);
-
-impl Style {
-    /// The prefix bytes for this style. These are the bytes that tell the
-    /// terminal to use a different color or font style.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::{Style, Color::Blue};
-    ///
-    /// let style = Style::default().bold();
-    /// assert_eq!("\x1b[1m",
-    ///            style.prefix().to_string());
-    ///
-    /// let style = Blue.bold();
-    /// assert_eq!("\x1b[1;34m",
-    ///            style.prefix().to_string());
-    ///
-    /// let style = Style::default();
-    /// assert_eq!("",
-    ///            style.prefix().to_string());
-    /// ```
-    pub fn prefix(self) -> Prefix {
-        Prefix(self)
-    }
-
-    /// The infix bytes between this style and `next` style. These are the bytes
-    /// that tell the terminal to change the style to `next`. These may include
-    /// a reset followed by the next color and style, depending on the two styles.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::{Style, Color::Green};
-    ///
-    /// let style = Style::default().bold();
-    /// assert_eq!("\x1b[32m",
-    ///            style.infix(Green.bold()).to_string());
-    ///
-    /// let style = Green.normal();
-    /// assert_eq!("\x1b[1m",
-    ///            style.infix(Green.bold()).to_string());
-    ///
-    /// let style = Style::default();
-    /// assert_eq!("",
-    ///            style.infix(style).to_string());
-    /// ```
-    pub fn infix(self, next: Style) -> Infix {
-        Infix(self, next)
-    }
-
-    /// The suffix for this style. These are the bytes that tell the terminal
-    /// to reset back to its normal color and font style.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::{Style, Color::Green};
-    ///
-    /// let style = Style::default().bold();
-    /// assert_eq!("\x1b[0m",
-    ///            style.suffix().to_string());
-    ///
-    /// let style = Green.normal().bold();
-    /// assert_eq!("\x1b[0m",
-    ///            style.suffix().to_string());
-    ///
-    /// let style = Style::default();
-    /// assert_eq!("",
-    ///            style.suffix().to_string());
-    /// ```
-    pub fn suffix(self) -> Suffix {
-        Suffix(self)
-    }
-}
-
-impl Color {
-    /// The prefix bytes for this color as a `Style`. These are the bytes
-    /// that tell the terminal to use a different color or font style.
-    ///
-    /// See also [`Style::prefix`](struct.Style.html#method.prefix).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color::Green;
-    ///
-    /// assert_eq!("\x1b[0m",
-    ///            Green.suffix().to_string());
-    /// ```
-    pub fn prefix(self) -> Prefix {
-        Prefix(self.normal())
-    }
-
-    /// The infix bytes between this color and `next` color. These are the bytes
-    /// that tell the terminal to use the `next` color, or to do nothing if
-    /// the two colors are equal.
-    ///
-    /// See also [`Style::infix`](struct.Style.html#method.infix).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color::{Red, Yellow};
-    ///
-    /// assert_eq!("\x1b[33m",
-    ///            Red.infix(Yellow).to_string());
-    /// ```
-    pub fn infix(self, next: Color) -> Infix {
-        Infix(self.normal(), next.normal())
-    }
-
-    /// The suffix for this color as a `Style`. These are the bytes that
-    /// tell the terminal to reset back to its normal color and font style.
-    ///
-    /// See also [`Style::suffix`](struct.Style.html#method.suffix).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color::Purple;
-    ///
-    /// assert_eq!("\x1b[0m",
-    ///            Purple.suffix().to_string());
-    /// ```
-    pub fn suffix(self) -> Suffix {
-        Suffix(self.normal())
-    }
-}
-
-impl fmt::Display for Prefix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let f: &mut dyn fmt::Write = f;
-        self.0.write_prefix(f)
-    }
-}
-
-impl fmt::Display for Infix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use crate::difference::Difference;
-
-        match Difference::between(&self.0, &self.1) {
-            Difference::ExtraStyles(style) => {
-                let f: &mut dyn fmt::Write = f;
-                style.write_prefix(f)
-            }
-            Difference::Reset => {
-                let f: &mut dyn fmt::Write = f;
-                write!(f, "{}{}", RESET, self.1.prefix())
-            }
-            Difference::Empty => {
-                Ok(()) // nothing to write
-            }
-        }
-    }
-}
-
-impl fmt::Display for Suffix {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let f: &mut dyn fmt::Write = f;
-        self.0.write_suffix(f)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::style::Color::*;
-    use crate::style::Style;
-
-    macro_rules! test {
-        ($name: ident: $style: expr; $input: expr => $result: expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!($style.paint($input).to_string(), $result.to_string());
-
-                let mut v = Vec::new();
-                $style.paint($input.as_bytes()).write_to(&mut v).unwrap();
-                assert_eq!(v.as_slice(), $result.as_bytes());
-            }
-        };
-    }
-
-    test!(plain:                 Style::default();                  "text/plain" => "text/plain");
-    test!(red:                   Red;                               "hi" => "\x1B[31mhi\x1B[0m");
-    test!(black:                 Black.normal();                    "hi" => "\x1B[30mhi\x1B[0m");
-    test!(yellow_bold:           Yellow.bold();                     "hi" => "\x1B[1;33mhi\x1B[0m");
-    test!(yellow_bold_2:         Yellow.normal().bold();            "hi" => "\x1B[1;33mhi\x1B[0m");
-    test!(blue_underline:        Blue.underline();                  "hi" => "\x1B[4;34mhi\x1B[0m");
-    test!(green_bold_ul:         Green.bold().underline();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
-    test!(green_bold_ul_2:       Green.underline().bold();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
-    test!(purple_on_white:       Purple.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
-    test!(purple_on_white_2:     Purple.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
-    test!(yellow_on_blue:        Style::new().on(Blue).fg(Yellow);  "hi" => "\x1B[44;33mhi\x1B[0m");
-    test!(magenta_on_white:      Magenta.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
-    test!(magenta_on_white_2:    Magenta.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
-    test!(yellow_on_blue_2:      Cyan.on(Blue).fg(Yellow);          "hi" => "\x1B[44;33mhi\x1B[0m");
-    test!(cyan_bold_on_white:    Cyan.bold().on(White);             "hi" => "\x1B[1;47;36mhi\x1B[0m");
-    test!(cyan_ul_on_white:      Cyan.underline().on(White);        "hi" => "\x1B[4;47;36mhi\x1B[0m");
-    test!(cyan_bold_ul_on_white: Cyan.bold().underline().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
-    test!(cyan_ul_bold_on_white: Cyan.underline().bold().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
-    test!(fixed:                 Fixed(100);                        "hi" => "\x1B[38;5;100mhi\x1B[0m");
-    test!(fixed_on_purple:       Fixed(100).on(Purple);             "hi" => "\x1B[45;38;5;100mhi\x1B[0m");
-    test!(fixed_on_fixed:        Fixed(100).on(Fixed(200));         "hi" => "\x1B[48;5;200;38;5;100mhi\x1B[0m");
-    test!(rgb:                   Rgb(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
-    test!(rgb_on_blue:           Rgb(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
-    test!(blue_on_rgb:           Blue.on(Rgb(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
-    test!(rgb_on_rgb:            Rgb(70,130,180).on(Rgb(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
-    test!(bold:                  Style::new().bold();               "hi" => "\x1B[1mhi\x1B[0m");
-    test!(underline:             Style::new().underline();          "hi" => "\x1B[4mhi\x1B[0m");
-    test!(bunderline:            Style::new().bold().underline();   "hi" => "\x1B[1;4mhi\x1B[0m");
-    test!(dimmed:                Style::new().dimmed();             "hi" => "\x1B[2mhi\x1B[0m");
-    test!(italic:                Style::new().italic();             "hi" => "\x1B[3mhi\x1B[0m");
-    test!(blink:                 Style::new().blink();              "hi" => "\x1B[5mhi\x1B[0m");
-    test!(reverse:               Style::new().reverse();            "hi" => "\x1B[7mhi\x1B[0m");
-    test!(hidden:                Style::new().hidden();             "hi" => "\x1B[8mhi\x1B[0m");
-    test!(stricken:              Style::new().strikethrough();      "hi" => "\x1B[9mhi\x1B[0m");
-    test!(lr_on_lr:              LightRed.on(LightRed);             "hi" => "\x1B[101;91mhi\x1B[0m");
-
-    #[test]
-    fn test_infix() {
-        assert_eq!(
-            Style::new().dimmed().infix(Style::new()).to_string(),
-            "\x1B[0m"
-        );
-        assert_eq!(
-            White.dimmed().infix(White.normal()).to_string(),
-            "\x1B[0m\x1B[37m"
-        );
-        assert_eq!(White.normal().infix(White.bold()).to_string(), "\x1B[1m");
-        assert_eq!(White.normal().infix(Blue.normal()).to_string(), "\x1B[34m");
-        assert_eq!(Blue.bold().infix(Blue.bold()).to_string(), "");
-    }
-}

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

@@ -1,152 +0,0 @@
-use crate::style::Style;
-use std::fmt;
-
-/// Styles have a special `Debug` implementation that only shows the fields that
-/// are set. Fields that haven’t been touched aren’t included in the output.
-///
-/// This behaviour gets bypassed when using the alternate formatting mode
-/// `format!("{:#?}")`.
-///
-///     use nu_ansi_term::Color::{Red, Blue};
-///     assert_eq!("Style { fg(Red), on(Blue), bold, italic }",
-///                format!("{:?}", Red.on(Blue).bold().italic()));
-impl fmt::Debug for Style {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        if fmt.alternate() {
-            fmt.debug_struct("Style")
-                .field("foreground", &self.foreground)
-                .field("background", &self.background)
-                .field("blink", &self.is_blink)
-                .field("bold", &self.is_bold)
-                .field("dimmed", &self.is_dimmed)
-                .field("hidden", &self.is_hidden)
-                .field("italic", &self.is_italic)
-                .field("reverse", &self.is_reverse)
-                .field("strikethrough", &self.is_strikethrough)
-                .field("underline", &self.is_underline)
-                .finish()
-        } else if self.is_plain() {
-            fmt.write_str("Style {}")
-        } else {
-            fmt.write_str("Style { ")?;
-
-            let mut written_anything = false;
-
-            if let Some(fg) = self.foreground {
-                if written_anything {
-                    fmt.write_str(", ")?
-                }
-                written_anything = true;
-                write!(fmt, "fg({:?})", fg)?
-            }
-
-            if let Some(bg) = self.background {
-                if written_anything {
-                    fmt.write_str(", ")?
-                }
-                written_anything = true;
-                write!(fmt, "on({:?})", bg)?
-            }
-
-            {
-                let mut write_flag = |name| {
-                    if written_anything {
-                        fmt.write_str(", ")?
-                    }
-                    written_anything = true;
-                    fmt.write_str(name)
-                };
-
-                if self.is_blink {
-                    write_flag("blink")?
-                }
-                if self.is_bold {
-                    write_flag("bold")?
-                }
-                if self.is_dimmed {
-                    write_flag("dimmed")?
-                }
-                if self.is_hidden {
-                    write_flag("hidden")?
-                }
-                if self.is_italic {
-                    write_flag("italic")?
-                }
-                if self.is_reverse {
-                    write_flag("reverse")?
-                }
-                if self.is_strikethrough {
-                    write_flag("strikethrough")?
-                }
-                if self.is_underline {
-                    write_flag("underline")?
-                }
-            }
-
-            write!(fmt, " }}")
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::style::Color::*;
-    use crate::style::Style;
-
-    fn style() -> Style {
-        Style::new()
-    }
-
-    macro_rules! test {
-        ($name: ident: $obj: expr => $result: expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!($result, format!("{:?}", $obj));
-            }
-        };
-    }
-
-    test!(empty:   style()                  => "Style {}");
-    test!(bold:    style().bold()           => "Style { bold }");
-    test!(italic:  style().italic()         => "Style { italic }");
-    test!(both:    style().bold().italic()  => "Style { bold, italic }");
-
-    test!(red:     Red.normal()                     => "Style { fg(Red) }");
-    test!(redblue: Red.normal().on(Rgb(3, 2, 4))    => "Style { fg(Red), on(Rgb(3, 2, 4)) }");
-
-    test!(everything:
-            Red.on(Blue).blink().bold().dimmed().hidden().italic().reverse().strikethrough().underline() =>
-            "Style { fg(Red), on(Blue), blink, bold, dimmed, hidden, italic, reverse, strikethrough, underline }");
-
-    #[test]
-    fn long_and_detailed() {
-        extern crate regex;
-        let expected_debug = "Style { fg(Blue), bold }";
-        let expected_pretty_repat = r##"(?x)
-        Style\s+\{\s+
-            foreground:\s+Some\(\s+
-                Blue,?\s+
-            \),\s+
-            background:\s+None,\s+
-            blink:\s+false,\s+
-            bold:\s+true,\s+
-            dimmed:\s+false,\s+
-            hidden:\s+false,\s+
-            italic:\s+false,\s+
-            reverse:\s+false,\s+
-            strikethrough:\s+
-            false,\s+
-            underline:\s+false,?\s+
-            \}"##;
-        let re = regex::Regex::new(expected_pretty_repat).unwrap();
-
-        let style = Blue.bold();
-        let style_fmt_debug = format!("{:?}", style);
-        let style_fmt_pretty = format!("{:#?}", style);
-        println!("style_fmt_debug:\n{}", style_fmt_debug);
-        println!("style_fmt_pretty:\n{}", style_fmt_pretty);
-
-        assert_eq!(expected_debug, style_fmt_debug);
-        assert!(re.is_match(&style_fmt_pretty));
-    }
-}

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

@@ -1,174 +0,0 @@
-use super::Style;
-
-/// When printing out one colored string followed by another, use one of
-/// these rules to figure out which *extra* control codes need to be sent.
-#[derive(PartialEq, Clone, Copy, Debug)]
-pub enum Difference {
-    /// Print out the control codes specified by this style to end up looking
-    /// like the second string's styles.
-    ExtraStyles(Style),
-
-    /// Converting between these two is impossible, so just send a reset
-    /// command and then the second string's styles.
-    Reset,
-
-    /// The before style is exactly the same as the after style, so no further
-    /// control codes need to be printed.
-    Empty,
-}
-
-impl Difference {
-    /// Compute the 'style difference' required to turn an existing style into
-    /// the given, second style.
-    ///
-    /// For example, to turn green text into green bold text, it's redundant
-    /// to write a reset command then a second green+bold command, instead of
-    /// just writing one bold command. This method should see that both styles
-    /// use the foreground color green, and reduce it to a single command.
-    ///
-    /// This method returns an enum value because it's not actually always
-    /// possible to turn one style into another: for example, text could be
-    /// made bold and underlined, but you can't remove the bold property
-    /// without also removing the underline property. So when this has to
-    /// happen, this function returns None, meaning that the entire set of
-    /// styles should be reset and begun again.
-    pub fn between(first: &Style, next: &Style) -> Difference {
-        use self::Difference::*;
-
-        // XXX(Havvy): This algorithm is kind of hard to replicate without
-        // having the Plain/Foreground enum variants, so I'm just leaving
-        // it commented out for now, and defaulting to Reset.
-
-        if first == next {
-            return Empty;
-        }
-
-        // Cannot un-bold, so must Reset.
-        if first.is_bold && !next.is_bold {
-            return Reset;
-        }
-
-        if first.is_dimmed && !next.is_dimmed {
-            return Reset;
-        }
-
-        if first.is_italic && !next.is_italic {
-            return Reset;
-        }
-
-        // Cannot un-underline, so must Reset.
-        if first.is_underline && !next.is_underline {
-            return Reset;
-        }
-
-        if first.is_blink && !next.is_blink {
-            return Reset;
-        }
-
-        if first.is_reverse && !next.is_reverse {
-            return Reset;
-        }
-
-        if first.is_hidden && !next.is_hidden {
-            return Reset;
-        }
-
-        if first.is_strikethrough && !next.is_strikethrough {
-            return Reset;
-        }
-
-        // Cannot go from foreground to no foreground, so must Reset.
-        if first.foreground.is_some() && next.foreground.is_none() {
-            return Reset;
-        }
-
-        // Cannot go from background to no background, so must Reset.
-        if first.background.is_some() && next.background.is_none() {
-            return Reset;
-        }
-
-        let mut extra_styles = Style::default();
-
-        if first.is_bold != next.is_bold {
-            extra_styles.is_bold = true;
-        }
-
-        if first.is_dimmed != next.is_dimmed {
-            extra_styles.is_dimmed = true;
-        }
-
-        if first.is_italic != next.is_italic {
-            extra_styles.is_italic = true;
-        }
-
-        if first.is_underline != next.is_underline {
-            extra_styles.is_underline = true;
-        }
-
-        if first.is_blink != next.is_blink {
-            extra_styles.is_blink = true;
-        }
-
-        if first.is_reverse != next.is_reverse {
-            extra_styles.is_reverse = true;
-        }
-
-        if first.is_hidden != next.is_hidden {
-            extra_styles.is_hidden = true;
-        }
-
-        if first.is_strikethrough != next.is_strikethrough {
-            extra_styles.is_strikethrough = true;
-        }
-
-        if first.foreground != next.foreground {
-            extra_styles.foreground = next.foreground;
-        }
-
-        if first.background != next.background {
-            extra_styles.background = next.background;
-        }
-
-        ExtraStyles(extra_styles)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Difference::*;
-    use super::*;
-    use crate::style::Color::*;
-    use crate::style::Style;
-
-    fn style() -> Style {
-        Style::new()
-    }
-
-    macro_rules! test {
-        ($name: ident: $first: expr; $next: expr => $result: expr) => {
-            #[test]
-            fn $name() {
-                assert_eq!($result, Difference::between(&$first, &$next));
-            }
-        };
-    }
-
-    test!(nothing:    Green.normal(); Green.normal()  => Empty);
-    test!(uppercase:  Green.normal(); Green.bold()    => ExtraStyles(style().bold()));
-    test!(lowercase:  Green.bold();   Green.normal()  => Reset);
-    test!(nothing2:   Green.bold();   Green.bold()    => Empty);
-
-    test!(color_change: Red.normal(); Blue.normal() => ExtraStyles(Blue.normal()));
-
-    test!(addition_of_blink:          style(); style().blink()          => ExtraStyles(style().blink()));
-    test!(addition_of_dimmed:         style(); style().dimmed()         => ExtraStyles(style().dimmed()));
-    test!(addition_of_hidden:         style(); style().hidden()         => ExtraStyles(style().hidden()));
-    test!(addition_of_reverse:        style(); style().reverse()        => ExtraStyles(style().reverse()));
-    test!(addition_of_strikethrough:  style(); style().strikethrough()  => ExtraStyles(style().strikethrough()));
-
-    test!(removal_of_strikethrough:   style().strikethrough(); style()  => Reset);
-    test!(removal_of_reverse:         style().reverse();       style()  => Reset);
-    test!(removal_of_hidden:          style().hidden();        style()  => Reset);
-    test!(removal_of_dimmed:          style().dimmed();        style()  => Reset);
-    test!(removal_of_blink:           style().blink();         style()  => Reset);
-}

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

@@ -1,303 +0,0 @@
-use crate::ansi::RESET;
-use crate::difference::Difference;
-use crate::style::{Color, Style};
-use crate::write::AnyWrite;
-use std::borrow::Cow;
-use std::fmt;
-use std::io;
-use std::ops::Deref;
-
-/// An `ANSIGenericString` includes a generic string type and a `Style` to
-/// display that string.  `ANSIString` and `ANSIByteString` are aliases for
-/// this type on `str` and `\[u8]`, respectively.
-#[derive(PartialEq, Debug)]
-pub struct AnsiGenericString<'a, S: 'a + ToOwned + ?Sized>
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-{
-    style: Style,
-    string: Cow<'a, S>,
-}
-
-/// Cloning an `ANSIGenericString` will clone its underlying string.
-///
-/// # Examples
-///
-/// ```
-/// use nu_ansi_term::ANSIString;
-///
-/// let plain_string = ANSIString::from("a plain string");
-/// let clone_string = plain_string.clone();
-/// assert_eq!(clone_string, plain_string);
-/// ```
-impl<'a, S: 'a + ToOwned + ?Sized> Clone for AnsiGenericString<'a, S>
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-{
-    fn clone(&self) -> AnsiGenericString<'a, S> {
-        AnsiGenericString {
-            style: self.style,
-            string: self.string.clone(),
-        }
-    }
-}
-
-// You might think that the hand-written Clone impl above is the same as the
-// one that gets generated with #[derive]. But it’s not *quite* the same!
-//
-// `str` is not Clone, and the derived Clone implementation puts a Clone
-// constraint on the S type parameter (generated using --pretty=expanded):
-//
-//                  ↓_________________↓
-//     impl <'a, S: ::std::clone::Clone + 'a + ToOwned + ?Sized> ::std::clone::Clone
-//     for ANSIGenericString<'a, S> where
-//     <S as ToOwned>::Owned: fmt::Debug { ... }
-//
-// This resulted in compile errors when you tried to derive Clone on a type
-// that used it:
-//
-//     #[derive(PartialEq, Debug, Clone, Default)]
-//     pub struct TextCellContents(Vec<ANSIString<'static>>);
-//                                 ^^^^^^^^^^^^^^^^^^^^^^^^^
-//     error[E0277]: the trait `std::clone::Clone` is not implemented for `str`
-//
-// The hand-written impl above can ignore that constraint and still compile.
-
-/// An ANSI String is a string coupled with the `Style` to display it
-/// in a terminal.
-///
-/// Although not technically a string itself, it can be turned into
-/// one with the `to_string` method.
-///
-/// # Examples
-///
-/// ```
-/// use nu_ansi_term::ANSIString;
-/// use nu_ansi_term::Color::Red;
-///
-/// let red_string = Red.paint("a red string");
-/// println!("{}", red_string);
-/// ```
-///
-/// ```
-/// use nu_ansi_term::ANSIString;
-///
-/// let plain_string = ANSIString::from("a plain string");
-/// assert_eq!(&*plain_string, "a plain string");
-/// ```
-pub type AnsiString<'a> = AnsiGenericString<'a, str>;
-
-/// An `AnsiByteString` represents a formatted series of bytes.  Use
-/// `AnsiByteString` when styling text with an unknown encoding.
-pub type AnsiByteString<'a> = AnsiGenericString<'a, [u8]>;
-
-impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for AnsiGenericString<'a, S>
-where
-    I: Into<Cow<'a, S>>,
-    <S as ToOwned>::Owned: fmt::Debug,
-{
-    fn from(input: I) -> AnsiGenericString<'a, S> {
-        AnsiGenericString {
-            string: input.into(),
-            style: Style::default(),
-        }
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S>
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-{
-    /// Directly access the style
-    pub fn style_ref(&self) -> &Style {
-        &self.style
-    }
-
-    /// Directly access the style mutably
-    pub fn style_ref_mut(&mut self) -> &mut Style {
-        &mut self.style
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized> Deref for AnsiGenericString<'a, S>
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-{
-    type Target = S;
-
-    fn deref(&self) -> &S {
-        self.string.deref()
-    }
-}
-
-/// A set of `AnsiGenericStrings`s collected together, in order to be
-/// written with a minimum of control characters.
-#[derive(Debug, PartialEq)]
-pub struct AnsiGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [AnsiGenericString<'a, S>])
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-    S: PartialEq;
-
-/// A set of `AnsiString`s collected together, in order to be written with a
-/// minimum of control characters.
-pub type AnsiStrings<'a> = AnsiGenericStrings<'a, str>;
-
-/// A function to construct an `AnsiStrings` instance.
-#[allow(non_snake_case)]
-pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
-    AnsiGenericStrings(arg)
-}
-
-/// A set of `AnsiByteString`s collected together, in order to be
-/// written with a minimum of control characters.
-pub type AnsiByteStrings<'a> = AnsiGenericStrings<'a, [u8]>;
-
-/// A function to construct an `ANSIByteStrings` instance.
-#[allow(non_snake_case)]
-pub fn ANSIByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
-    AnsiGenericStrings(arg)
-}
-
-// ---- paint functions ----
-
-impl Style {
-    /// Paints the given text with this color, returning an ANSI string.
-    #[must_use]
-    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S>
-    where
-        I: Into<Cow<'a, S>>,
-        <S as ToOwned>::Owned: fmt::Debug,
-    {
-        AnsiGenericString {
-            string: input.into(),
-            style: self,
-        }
-    }
-}
-
-impl Color {
-    /// Paints the given text with this color, returning an ANSI string.
-    /// This is a short-cut so you don’t have to use `Blue.normal()` just
-    /// to get blue text.
-    ///
-    /// ```
-    /// use nu_ansi_term::Color::Blue;
-    /// println!("{}", Blue.paint("da ba dee"));
-    /// ```
-    #[must_use]
-    pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S>
-    where
-        I: Into<Cow<'a, S>>,
-        <S as ToOwned>::Owned: fmt::Debug,
-    {
-        AnsiGenericString {
-            string: input.into(),
-            style: self.normal(),
-        }
-    }
-}
-
-// ---- writers for individual ANSI strings ----
-
-impl<'a> fmt::Display for AnsiString<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let w: &mut dyn fmt::Write = f;
-        self.write_to_any(w)
-    }
-}
-
-impl<'a> AnsiByteString<'a> {
-    /// Write an `ANSIByteString` to an `io::Write`.  This writes the escape
-    /// sequences for the associated `Style` around the bytes.
-    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-        let w: &mut dyn io::Write = w;
-        self.write_to_any(w)
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S>
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-    &'a S: AsRef<[u8]>,
-{
-    fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
-        write!(w, "{}", self.style.prefix())?;
-        w.write_str(self.string.as_ref())?;
-        write!(w, "{}", self.style.suffix())
-    }
-}
-
-// ---- writers for combined ANSI strings ----
-
-impl<'a> fmt::Display for AnsiStrings<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let f: &mut dyn fmt::Write = f;
-        self.write_to_any(f)
-    }
-}
-
-impl<'a> AnsiByteStrings<'a> {
-    /// Write `ANSIByteStrings` to an `io::Write`.  This writes the minimal
-    /// escape sequences for the associated `Style`s around each set of
-    /// bytes.
-    pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
-        let w: &mut dyn io::Write = w;
-        self.write_to_any(w)
-    }
-}
-
-impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> AnsiGenericStrings<'a, S>
-where
-    <S as ToOwned>::Owned: fmt::Debug,
-    &'a S: AsRef<[u8]>,
-{
-    fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> {
-        use self::Difference::*;
-
-        let first = match self.0.first() {
-            None => return Ok(()),
-            Some(f) => f,
-        };
-
-        write!(w, "{}", first.style.prefix())?;
-        w.write_str(first.string.as_ref())?;
-
-        for window in self.0.windows(2) {
-            match Difference::between(&window[0].style, &window[1].style) {
-                ExtraStyles(style) => write!(w, "{}", style.prefix())?,
-                Reset => write!(w, "{}{}", RESET, window[1].style.prefix())?,
-                Empty => { /* Do nothing! */ }
-            }
-
-            w.write_str(&window[1].string)?;
-        }
-
-        // Write the final reset string after all of the ANSIStrings have been
-        // written, *except* if the last one has no styles, because it would
-        // have already been written by this point.
-        if let Some(last) = self.0.last() {
-            if !last.style.is_plain() {
-                write!(w, "{}", RESET)?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-// ---- tests ----
-
-#[cfg(test)]
-mod tests {
-    pub use super::super::AnsiStrings;
-    pub use crate::style::Color::*;
-    pub use crate::style::Style;
-
-    #[test]
-    fn no_control_codes_for_plain() {
-        let one = Style::default().paint("one");
-        let two = Style::default().paint("two");
-        let output = format!("{}", AnsiStrings(&[one, two]));
-        assert_eq!(&*output, "onetwo");
-    }
-}

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

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

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

@@ -1,273 +0,0 @@
-//! This is a library for controlling colors and formatting, such as
-//! red bold text or blue underlined text, on ANSI terminals.
-//!
-//!
-//! ## Basic usage
-//!
-//! There are three main types in this crate that you need to be
-//! concerned with: [`ANSIString`], [`Style`], and [`Color`].
-//!
-//! A `Style` holds stylistic information: foreground and background colors,
-//! whether the text should be bold, or blinking, or other properties. The
-//! [`Color`] enum represents the available colors. And an [`ANSIString`] is a
-//! string paired with a [`Style`].
-//!
-//! [`Color`] is also available as an alias to `Color`.
-//!
-//! To format a string, call the `paint` method on a `Style` or a `Color`,
-//! passing in the string you want to format as the argument. For example,
-//! here’s how to get some red text:
-//!
-//! ```
-//! use nu_ansi_term::Color::Red;
-//!
-//! println!("This is in red: {}", Red.paint("a red string"));
-//! ```
-//!
-//! It’s important to note that the `paint` method does *not* actually return a
-//! string with the ANSI control characters surrounding it. Instead, it returns
-//! an [`ANSIString`] value that has a [`Display`] implementation that, when
-//! formatted, returns the characters. This allows strings to be printed with a
-//! minimum of [`String`] allocations being performed behind the scenes.
-//!
-//! If you *do* want to get at the escape codes, then you can convert the
-//! [`ANSIString`] to a string as you would any other `Display` value:
-//!
-//! ```
-//! use nu_ansi_term::Color::Red;
-//!
-//! let red_string = Red.paint("a red string").to_string();
-//! ```
-//!
-//!
-//! ## Bold, underline, background, and other styles
-//!
-//! For anything more complex than plain foreground color changes, you need to
-//! construct `Style` values themselves, rather than beginning with a `Color`.
-//! You can do this by chaining methods based on a new `Style`, created with
-//! [`Style::new()`]. Each method creates a new style that has that specific
-//! property set. For example:
-//!
-//! ```
-//! use nu_ansi_term::Style;
-//!
-//! println!("How about some {} and {}?",
-//!          Style::new().bold().paint("bold"),
-//!          Style::new().underline().paint("underline"));
-//! ```
-//!
-//! For brevity, these methods have also been implemented for `Color` values,
-//! so you can give your styles a foreground color without having to begin with
-//! an empty `Style` value:
-//!
-//! ```
-//! use nu_ansi_term::Color::{Blue, Yellow};
-//!
-//! println!("Demonstrating {} and {}!",
-//!          Blue.bold().paint("blue bold"),
-//!          Yellow.underline().paint("yellow underline"));
-//!
-//! println!("Yellow on blue: {}", Yellow.on(Blue).paint("wow!"));
-//! ```
-//!
-//! The complete list of styles you can use are: [`bold`], [`dimmed`], [`italic`],
-//! [`underline`], [`blink`], [`reverse`], [`hidden`], [`strikethrough`], and [`on`] for
-//! background colors.
-//!
-//! In some cases, you may find it easier to change the foreground on an
-//! existing `Style` rather than starting from the appropriate `Color`.
-//! You can do this using the [`fg`] method:
-//!
-//! ```
-//! use nu_ansi_term::Style;
-//! use nu_ansi_term::Color::{Blue, Cyan, Yellow};
-//!
-//! println!("Yellow on blue: {}", Style::new().on(Blue).fg(Yellow).paint("yow!"));
-//! println!("Also yellow on blue: {}", Cyan.on(Blue).fg(Yellow).paint("zow!"));
-//! ```
-//!
-//! You can turn a `Color` into a `Style` with the [`normal`] method.
-//! This will produce the exact same `ANSIString` as if you just used the
-//! `paint` method on the `Color` directly, but it’s useful in certain cases:
-//! for example, you may have a method that returns `Styles`, and need to
-//! represent both the “red bold” and “red, but not bold” styles with values of
-//! the same type. The `Style` struct also has a [`Default`] implementation if you
-//! want to have a style with *nothing* set.
-//!
-//! ```
-//! use nu_ansi_term::Style;
-//! use nu_ansi_term::Color::Red;
-//!
-//! Red.normal().paint("yet another red string");
-//! Style::default().paint("a completely regular string");
-//! ```
-//!
-//!
-//! ## Extended colors
-//!
-//! You can access the extended range of 256 colors by using the `Color::Fixed`
-//! variant, which takes an argument of the color number to use. This can be
-//! included wherever you would use a `Color`:
-//!
-//! ```
-//! use nu_ansi_term::Color::Fixed;
-//!
-//! Fixed(134).paint("A sort of light purple");
-//! Fixed(221).on(Fixed(124)).paint("Mustard in the ketchup");
-//! ```
-//!
-//! The first sixteen of these values are the same as the normal and bold
-//! standard color variants. There’s nothing stopping you from using these as
-//! `Fixed` colors instead, but there’s nothing to be gained by doing so
-//! either.
-//!
-//! You can also access full 24-bit color by using the `Color::Rgb` variant,
-//! which takes separate `u8` arguments for red, green, and blue:
-//!
-//! ```
-//! use nu_ansi_term::Color::Rgb;
-//!
-//! Rgb(70, 130, 180).paint("Steel blue");
-//! ```
-//!
-//! ## Combining successive colored strings
-//!
-//! The benefit of writing ANSI escape codes to the terminal is that they
-//! *stack*: you do not need to end every colored string with a reset code if
-//! the text that follows it is of a similar style. For example, if you want to
-//! have some blue text followed by some blue bold text, it’s possible to send
-//! the ANSI code for blue, followed by the ANSI code for bold, and finishing
-//! with a reset code without having to have an extra one between the two
-//! strings.
-//!
-//! This crate can optimise the ANSI codes that get printed in situations like
-//! this, making life easier for your terminal renderer. The [`ANSIStrings`]
-//! type takes a slice of several [`ANSIString`] values, and will iterate over
-//! each of them, printing only the codes for the styles that need to be updated
-//! as part of its formatting routine.
-//!
-//! The following code snippet uses this to enclose a binary number displayed in
-//! red bold text inside some red, but not bold, brackets:
-//!
-//! ```
-//! use nu_ansi_term::Color::Red;
-//! use nu_ansi_term::{ANSIString, ANSIStrings};
-//!
-//! let some_value = format!("{:b}", 42);
-//! let strings: &[ANSIString<'static>] = &[
-//!     Red.paint("["),
-//!     Red.bold().paint(some_value),
-//!     Red.paint("]"),
-//! ];
-//!
-//! println!("Value: {}", ANSIStrings(strings));
-//! ```
-//!
-//! There are several things to note here. Firstly, the [`paint`] method can take
-//! *either* an owned [`String`] or a borrowed [`&str`]. Internally, an [`ANSIString`]
-//! holds a copy-on-write ([`Cow`]) string value to deal with both owned and
-//! borrowed strings at the same time. This is used here to display a `String`,
-//! the result of the `format!` call, using the same mechanism as some
-//! statically-available `&str` slices. Secondly, that the [`ANSIStrings`] value
-//! works in the same way as its singular counterpart, with a [`Display`]
-//! implementation that only performs the formatting when required.
-//!
-//! ## Byte strings
-//!
-//! This library also supports formatting `\[u8]` byte strings; this supports
-//! applications working with text in an unknown encoding.  [`Style`] and
-//! [`Color`] support painting `\[u8]` values, resulting in an [`ANSIByteString`].
-//! This type does not implement [`Display`], as it may not contain UTF-8, but
-//! it does provide a method [`write_to`] to write the result to any value that
-//! implements [`Write`]:
-//!
-//! ```
-//! use nu_ansi_term::Color::Green;
-//!
-//! Green.paint("user data".as_bytes()).write_to(&mut std::io::stdout()).unwrap();
-//! ```
-//!
-//! Similarly, the type [`ANSIByteStrings`] supports writing a list of
-//! [`ANSIByteString`] values with minimal escape sequences:
-//!
-//! ```
-//! use nu_ansi_term::Color::Green;
-//! use nu_ansi_term::ANSIByteStrings;
-//!
-//! ANSIByteStrings(&[
-//!     Green.paint("user data 1\n".as_bytes()),
-//!     Green.bold().paint("user data 2\n".as_bytes()),
-//! ]).write_to(&mut std::io::stdout()).unwrap();
-//! ```
-//!
-//! [`Cow`]: https://doc.rust-lang.org/std/borrow/enum.Cow.html
-//! [`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
-//! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html
-//! [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
-//! [`&str`]: https://doc.rust-lang.org/std/primitive.str.html
-//! [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
-//! [`Style`]: struct.Style.html
-//! [`Style::new()`]: struct.Style.html#method.new
-//! [`Color`]: enum.Color.html
-//! [`Color`]: enum.Color.html
-//! [`ANSIString`]: type.ANSIString.html
-//! [`ANSIStrings`]: type.ANSIStrings.html
-//! [`ANSIByteString`]: type.ANSIByteString.html
-//! [`ANSIByteStrings`]: type.ANSIByteStrings.html
-//! [`write_to`]: type.ANSIByteString.html#method.write_to
-//! [`paint`]: type.ANSIByteString.html#method.write_to
-//! [`normal`]: enum.Color.html#method.normal
-//!
-//! [`bold`]: struct.Style.html#method.bold
-//! [`dimmed`]: struct.Style.html#method.dimmed
-//! [`italic`]: struct.Style.html#method.italic
-//! [`underline`]: struct.Style.html#method.underline
-//! [`blink`]: struct.Style.html#method.blink
-//! [`reverse`]: struct.Style.html#method.reverse
-//! [`hidden`]: struct.Style.html#method.hidden
-//! [`strikethrough`]: struct.Style.html#method.strikethrough
-//! [`fg`]: struct.Style.html#method.fg
-//! [`on`]: struct.Style.html#method.on
-
-#![crate_name = "nu_ansi_term"]
-#![crate_type = "rlib"]
-#![crate_type = "dylib"]
-#![warn(missing_copy_implementations)]
-// #![warn(missing_docs)]
-#![warn(trivial_casts, trivial_numeric_casts)]
-// #![warn(unused_extern_crates, unused_qualifications)]
-
-#[cfg(target_os = "windows")]
-extern crate winapi;
-#[cfg(test)]
-#[macro_use]
-extern crate doc_comment;
-
-#[cfg(test)]
-doctest!("../README.md");
-
-pub mod ansi;
-pub use ansi::{Infix, Prefix, Suffix};
-
-mod style;
-pub use style::{Color, Style};
-
-mod difference;
-mod display;
-pub use display::*;
-
-mod write;
-
-mod windows;
-pub use windows::*;
-
-mod util;
-pub use util::*;
-
-mod debug;
-
-pub mod gradient;
-pub use gradient::*;
-
-mod rgb;
-pub use rgb::*;

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

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

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

@@ -1,626 +0,0 @@
-/// A style is a collection of properties that can format a string
-/// using ANSI escape codes.
-///
-/// # Examples
-///
-/// ```
-/// use nu_ansi_term::{Style, Color};
-///
-/// let style = Style::new().bold().on(Color::Black);
-/// println!("{}", style.paint("Bold on black"));
-/// ```
-#[derive(PartialEq, Clone, Copy)]
-#[cfg_attr(
-    feature = "derive_serde_style",
-    derive(serde::Deserialize, serde::Serialize)
-)]
-pub struct Style {
-    /// The style's foreground color, if it has one.
-    pub foreground: Option<Color>,
-
-    /// The style's background color, if it has one.
-    pub background: Option<Color>,
-
-    /// Whether this style is bold.
-    pub is_bold: bool,
-
-    /// Whether this style is dimmed.
-    pub is_dimmed: bool,
-
-    /// Whether this style is italic.
-    pub is_italic: bool,
-
-    /// Whether this style is underlined.
-    pub is_underline: bool,
-
-    /// Whether this style is blinking.
-    pub is_blink: bool,
-
-    /// Whether this style has reverse colors.
-    pub is_reverse: bool,
-
-    /// Whether this style is hidden.
-    pub is_hidden: bool,
-
-    /// Whether this style is struckthrough.
-    pub is_strikethrough: bool,
-}
-
-impl Style {
-    /// Creates a new Style with no properties set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new();
-    /// println!("{}", style.paint("hi"));
-    /// ```
-    pub fn new() -> Style {
-        Style::default()
-    }
-
-    /// Returns a `Style` with the bold property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().bold();
-    /// println!("{}", style.paint("hey"));
-    /// ```
-    pub fn bold(&self) -> Style {
-        Style {
-            is_bold: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the dimmed property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().dimmed();
-    /// println!("{}", style.paint("sup"));
-    /// ```
-    pub fn dimmed(&self) -> Style {
-        Style {
-            is_dimmed: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the italic property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().italic();
-    /// println!("{}", style.paint("greetings"));
-    /// ```
-    pub fn italic(&self) -> Style {
-        Style {
-            is_italic: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the underline property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().underline();
-    /// println!("{}", style.paint("salutations"));
-    /// ```
-    pub fn underline(&self) -> Style {
-        Style {
-            is_underline: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the blink property set.
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().blink();
-    /// println!("{}", style.paint("wazzup"));
-    /// ```
-    pub fn blink(&self) -> Style {
-        Style {
-            is_blink: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the reverse property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().reverse();
-    /// println!("{}", style.paint("aloha"));
-    /// ```
-    pub fn reverse(&self) -> Style {
-        Style {
-            is_reverse: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the hidden property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().hidden();
-    /// println!("{}", style.paint("ahoy"));
-    /// ```
-    pub fn hidden(&self) -> Style {
-        Style {
-            is_hidden: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the strikethrough property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// let style = Style::new().strikethrough();
-    /// println!("{}", style.paint("yo"));
-    /// ```
-    pub fn strikethrough(&self) -> Style {
-        Style {
-            is_strikethrough: true,
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the foreground color property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::{Style, Color};
-    ///
-    /// let style = Style::new().fg(Color::Yellow);
-    /// println!("{}", style.paint("hi"));
-    /// ```
-    pub fn fg(&self, foreground: Color) -> Style {
-        Style {
-            foreground: Some(foreground),
-            ..*self
-        }
-    }
-
-    /// Returns a `Style` with the background color property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::{Style, Color};
-    ///
-    /// let style = Style::new().on(Color::Blue);
-    /// println!("{}", style.paint("eyyyy"));
-    /// ```
-    pub fn on(&self, background: Color) -> Style {
-        Style {
-            background: Some(background),
-            ..*self
-        }
-    }
-
-    /// Return true if this `Style` has no actual styles, and can be written
-    /// without any control characters.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    ///
-    /// assert_eq!(true,  Style::default().is_plain());
-    /// assert_eq!(false, Style::default().bold().is_plain());
-    /// ```
-    pub fn is_plain(self) -> bool {
-        self == Style::default()
-    }
-}
-
-impl Default for Style {
-    /// Returns a style with *no* properties set. Formatting text using this
-    /// style returns the exact same text.
-    ///
-    /// ```
-    /// use nu_ansi_term::Style;
-    /// assert_eq!(None,  Style::default().foreground);
-    /// assert_eq!(None,  Style::default().background);
-    /// assert_eq!(false, Style::default().is_bold);
-    /// assert_eq!("txt", Style::default().paint("txt").to_string());
-    /// ```
-    fn default() -> Style {
-        Style {
-            foreground: None,
-            background: None,
-            is_bold: false,
-            is_dimmed: false,
-            is_italic: false,
-            is_underline: false,
-            is_blink: false,
-            is_reverse: false,
-            is_hidden: false,
-            is_strikethrough: false,
-        }
-    }
-}
-
-// ---- colors ----
-
-/// A color is one specific type of ANSI escape code, and can refer
-/// to either the foreground or background color.
-///
-/// These use the standard numeric sequences.
-/// See <http://invisible-island.net/xterm/ctlseqs/ctlseqs.html>
-#[derive(PartialEq, Clone, Copy, Debug)]
-#[cfg_attr(
-    feature = "derive_serde_style",
-    derive(serde::Deserialize, serde::Serialize)
-)]
-pub enum Color {
-    /// Color #0 (foreground code `30`, background code `40`).
-    ///
-    /// This is not necessarily the background color, and using it as one may
-    /// render the text hard to read on terminals with dark backgrounds.
-    Black,
-
-    /// Color #0 (foreground code `90`, background code `100`).
-    DarkGray,
-
-    /// Color #1 (foreground code `31`, background code `41`).
-    Red,
-
-    /// Color #1 (foreground code `91`, background code `101`).
-    LightRed,
-
-    /// Color #2 (foreground code `32`, background code `42`).
-    Green,
-
-    /// Color #2 (foreground code `92`, background code `102`).
-    LightGreen,
-
-    /// Color #3 (foreground code `33`, background code `43`).
-    Yellow,
-
-    /// Color #3 (foreground code `93`, background code `103`).
-    LightYellow,
-
-    /// Color #4 (foreground code `34`, background code `44`).
-    Blue,
-
-    /// Color #4 (foreground code `94`, background code `104`).
-    LightBlue,
-
-    /// Color #5 (foreground code `35`, background code `45`).
-    Purple,
-
-    /// Color #5 (foreground code `95`, background code `105`).
-    LightPurple,
-
-    /// Color #5 (foreground code `35`, background code `45`).
-    Magenta,
-
-    /// Color #5 (foreground code `95`, background code `105`).
-    LightMagenta,
-
-    /// Color #6 (foreground code `36`, background code `46`).
-    Cyan,
-
-    /// Color #6 (foreground code `96`, background code `106`).
-    LightCyan,
-
-    /// Color #7 (foreground code `37`, background code `47`).
-    ///
-    /// As above, this is not necessarily the foreground color, and may be
-    /// hard to read on terminals with light backgrounds.
-    White,
-
-    /// Color #7 (foreground code `97`, background code `107`).
-    LightGray,
-
-    /// A color number from 0 to 255, for use in 256-color terminal
-    /// environments.
-    ///
-    /// - colors 0 to 7 are the `Black` to `White` variants respectively.
-    ///   These colors can usually be changed in the terminal emulator.
-    /// - colors 8 to 15 are brighter versions of the eight colors above.
-    ///   These can also usually be changed in the terminal emulator, or it
-    ///   could be configured to use the original colors and show the text in
-    ///   bold instead. It varies depending on the program.
-    /// - colors 16 to 231 contain several palettes of bright colors,
-    ///   arranged in six squares measuring six by six each.
-    /// - colors 232 to 255 are shades of grey from black to white.
-    ///
-    /// It might make more sense to look at a [color chart][cc].
-    ///
-    /// [cc]: https://upload.wikimedia.org/wikipedia/commons/1/15/Xterm_256color_chart.svg
-    Fixed(u8),
-
-    /// A 24-bit Rgb color, as specified by ISO-8613-3.
-    Rgb(u8, u8, u8),
-}
-
-impl Default for Color {
-    fn default() -> Self {
-        Color::White
-    }
-}
-
-impl Color {
-    /// Returns a `Style` with the foreground color set to this color.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Red.normal();
-    /// println!("{}", style.paint("hi"));
-    /// ```
-    pub fn normal(self) -> Style {
-        Style {
-            foreground: Some(self),
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// bold property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Green.bold();
-    /// println!("{}", style.paint("hey"));
-    /// ```
-    pub fn bold(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_bold: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// dimmed property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Yellow.dimmed();
-    /// println!("{}", style.paint("sup"));
-    /// ```
-    pub fn dimmed(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_dimmed: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// italic property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Blue.italic();
-    /// println!("{}", style.paint("greetings"));
-    /// ```
-    pub fn italic(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_italic: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// underline property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Purple.underline();
-    /// println!("{}", style.paint("salutations"));
-    /// ```
-    pub fn underline(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_underline: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// blink property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Cyan.blink();
-    /// println!("{}", style.paint("wazzup"));
-    /// ```
-    pub fn blink(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_blink: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// reverse property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Black.reverse();
-    /// println!("{}", style.paint("aloha"));
-    /// ```
-    pub fn reverse(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_reverse: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// hidden property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::White.hidden();
-    /// println!("{}", style.paint("ahoy"));
-    /// ```
-    pub fn hidden(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_hidden: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// strikethrough property set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Fixed(244).strikethrough();
-    /// println!("{}", style.paint("yo"));
-    /// ```
-    pub fn strikethrough(self) -> Style {
-        Style {
-            foreground: Some(self),
-            is_strikethrough: true,
-            ..Style::default()
-        }
-    }
-
-    /// Returns a `Style` with the foreground color set to this color and the
-    /// background color property set to the given color.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use nu_ansi_term::Color;
-    ///
-    /// let style = Color::Rgb(31, 31, 31).on(Color::White);
-    /// println!("{}", style.paint("eyyyy"));
-    /// ```
-    pub fn on(self, background: Color) -> Style {
-        Style {
-            foreground: Some(self),
-            background: Some(background),
-            ..Style::default()
-        }
-    }
-}
-
-impl From<Color> for Style {
-    /// You can turn a `Color` into a `Style` with the foreground color set
-    /// with the `From` trait.
-    ///
-    /// ```
-    /// use nu_ansi_term::{Style, Color};
-    /// let green_foreground = Style::default().fg(Color::Green);
-    /// assert_eq!(green_foreground, Color::Green.normal());
-    /// assert_eq!(green_foreground, Color::Green.into());
-    /// assert_eq!(green_foreground, Style::from(Color::Green));
-    /// ```
-    fn from(color: Color) -> Style {
-        color.normal()
-    }
-}
-
-#[cfg(test)]
-#[cfg(feature = "derive_serde_style")]
-mod serde_json_tests {
-    use super::{Color, Style};
-
-    #[test]
-    fn color_serialization() {
-        let colors = &[
-            Color::Red,
-            Color::Blue,
-            Color::Rgb(123, 123, 123),
-            Color::Fixed(255),
-        ];
-
-        assert_eq!(
-            serde_json::to_string(&colors).unwrap(),
-            String::from("[\"Red\",\"Blue\",{\"Rgb\":[123,123,123]},{\"Fixed\":255}]")
-        );
-    }
-
-    #[test]
-    fn color_deserialization() {
-        let colors = &[
-            Color::Red,
-            Color::Blue,
-            Color::Rgb(123, 123, 123),
-            Color::Fixed(255),
-        ];
-
-        for color in colors.iter() {
-            let serialized = serde_json::to_string(&color).unwrap();
-            let deserialized: Color = serde_json::from_str(&serialized).unwrap();
-
-            assert_eq!(color, &deserialized);
-        }
-    }
-
-    #[test]
-    fn style_serialization() {
-        let style = Style::default();
-
-        assert_eq!(serde_json::to_string(&style).unwrap(), "{\"foreground\":null,\"background\":null,\"is_bold\":false,\"is_dimmed\":false,\"is_italic\":false,\"is_underline\":false,\"is_blink\":false,\"is_reverse\":false,\"is_hidden\":false,\"is_strikethrough\":false}".to_string());
-    }
-}

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

@@ -1,80 +0,0 @@
-use crate::display::{AnsiString, AnsiStrings};
-use std::ops::Deref;
-
-/// Return a substring of the given ANSIStrings sequence, while keeping the formatting.
-pub fn sub_string<'a>(
-    start: usize,
-    len: usize,
-    strs: &AnsiStrings<'a>,
-) -> Vec<AnsiString<'static>> {
-    let mut vec = Vec::new();
-    let mut pos = start;
-    let mut len_rem = len;
-
-    for i in strs.0.iter() {
-        let fragment = i.deref();
-        let frag_len = fragment.len();
-        if pos >= frag_len {
-            pos -= frag_len;
-            continue;
-        }
-        if len_rem == 0 {
-            break;
-        }
-
-        let end = pos + len_rem;
-        let pos_end = if end >= frag_len { frag_len } else { end };
-
-        vec.push(i.style_ref().paint(String::from(&fragment[pos..pos_end])));
-
-        if end <= frag_len {
-            break;
-        }
-
-        len_rem -= pos_end - pos;
-        pos = 0;
-    }
-
-    vec
-}
-
-/// Return a concatenated copy of `strs` without the formatting, as an allocated `String`.
-pub fn unstyle(strs: &AnsiStrings) -> String {
-    let mut s = String::new();
-
-    for i in strs.0.iter() {
-        s += i.deref();
-    }
-
-    s
-}
-
-/// Return the unstyled length of ANSIStrings. This is equaivalent to `unstyle(strs).len()`.
-pub fn unstyled_len(strs: &AnsiStrings) -> usize {
-    let mut l = 0;
-    for i in strs.0.iter() {
-        l += i.deref().len();
-    }
-    l
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::Color::*;
-
-    #[test]
-    fn test() {
-        let l = [
-            Black.paint("first"),
-            Red.paint("-second"),
-            White.paint("-third"),
-        ];
-        let a = AnsiStrings(&l);
-        assert_eq!(unstyle(&a), "first-second-third");
-        assert_eq!(unstyled_len(&a), 18);
-
-        let l2 = [Black.paint("st"), Red.paint("-second"), White.paint("-t")];
-        assert_eq!(sub_string(3, 11, &a).as_slice(), &l2);
-    }
-}

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

@@ -1,62 +0,0 @@
-/// Enables ANSI code support on Windows 10.
-///
-/// This uses Windows API calls to alter the properties of the console that
-/// the program is running in.
-///
-/// https://msdn.microsoft.com/en-us/library/windows/desktop/mt638032(v=vs.85).aspx
-///
-/// Returns a `Result` with the Windows error code if unsuccessful.
-#[cfg(windows)]
-pub fn enable_ansi_support() -> Result<(), u32> {
-    // ref: https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#EXAMPLE_OF_ENABLING_VIRTUAL_TERMINAL_PROCESSING @@ https://archive.is/L7wRJ#76%
-
-    use std::ffi::OsStr;
-    use std::iter::once;
-    use std::os::windows::ffi::OsStrExt;
-    use std::ptr::null_mut;
-    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
-    use winapi::um::errhandlingapi::GetLastError;
-    use winapi::um::fileapi::{CreateFileW, OPEN_EXISTING};
-    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
-    use winapi::um::winnt::{FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE};
-
-    const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
-
-    unsafe {
-        // ref: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
-        // Using `CreateFileW("CONOUT$", ...)` to retrieve the console handle works correctly even if STDOUT and/or STDERR are redirected
-        let console_out_name: Vec<u16> =
-            OsStr::new("CONOUT$").encode_wide().chain(once(0)).collect();
-        let console_handle = CreateFileW(
-            console_out_name.as_ptr(),
-            GENERIC_READ | GENERIC_WRITE,
-            FILE_SHARE_WRITE,
-            null_mut(),
-            OPEN_EXISTING,
-            0,
-            null_mut(),
-        );
-        if console_handle == INVALID_HANDLE_VALUE {
-            return Err(GetLastError());
-        }
-
-        // ref: https://docs.microsoft.com/en-us/windows/console/getconsolemode
-        let mut console_mode: u32 = 0;
-        if 0 == GetConsoleMode(console_handle, &mut console_mode) {
-            return Err(GetLastError());
-        }
-
-        // VT processing not already enabled?
-        if console_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING == 0 {
-            // https://docs.microsoft.com/en-us/windows/console/setconsolemode
-            if 0 == SetConsoleMode(
-                console_handle,
-                console_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING,
-            ) {
-                return Err(GetLastError());
-            }
-        }
-    }
-
-    Ok(())
-}

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

@@ -1,37 +0,0 @@
-use std::fmt;
-use std::io;
-
-pub trait AnyWrite {
-    type Wstr: ?Sized;
-    type Error;
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error>;
-
-    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error>;
-}
-
-impl<'a> AnyWrite for dyn fmt::Write + 'a {
-    type Wstr = str;
-    type Error = fmt::Error;
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
-        fmt::Write::write_fmt(self, fmt)
-    }
-
-    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error> {
-        fmt::Write::write_str(self, s)
-    }
-}
-
-impl<'a> AnyWrite for dyn io::Write + 'a {
-    type Wstr = [u8];
-    type Error = io::Error;
-
-    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Self::Error> {
-        io::Write::write_fmt(self, fmt)
-    }
-
-    fn write_str(&mut self, s: &Self::Wstr) -> Result<(), Self::Error> {
-        io::Write::write_all(self, s)
-    }
-}

crates/nu-cli/Cargo.toml

@@ -1,42 +1,27 @@
 [package]
-authors = ["The Nu Project Contributors"]
-description = "CLI for nushell"
-edition = "2018"
+authors = ["The Nushell Project Developers"]
+description = "CLI-related functionality for Nushell"
+edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.35.0"
-build = "build.rs"
-
-[lib]
-doctest = false
+version = "0.61.0"
 
 [dependencies]
-nu-completion = { version = "0.35.0", path="../nu-completion" }
-nu-command = { version = "0.35.0", path="../nu-command" }
-nu-data = { version = "0.35.0", path="../nu-data" }
-nu-engine = { version = "0.35.0", path="../nu-engine" }
-nu-errors = { version = "0.35.0", path="../nu-errors" }
-nu-parser = { version = "0.35.0", path="../nu-parser" }
-nu-protocol = { version = "0.35.0", path="../nu-protocol" }
-nu-source = { version = "0.35.0", path="../nu-source" }
-nu-stream = { version = "0.35.0", path="../nu-stream" }
-nu-ansi-term = { version = "0.35.0", path="../nu-ansi-term" }
+nu-engine = { path = "../nu-engine", version = "0.61.0"  }
+nu-path = { path = "../nu-path", version = "0.61.0"  }
+nu-parser = { path = "../nu-parser", version = "0.61.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.61.0"  }
+nu-utils = { path = "../nu-utils", version = "0.61.0"  }
+nu-ansi-term = "0.45.1"
+nu-color-config = { path = "../nu-color-config", version = "0.61.0"  }
 
-indexmap ="1.6.1"
-log = "0.4.14"
-pretty_env_logger = "0.4.0"
-strip-ansi-escapes = "0.1.0"
-rustyline = { version="8.1.0", optional=true }
-ctrlc = { version="3.1.7", optional=true }
-shadow-rs = { version="0.6", default-features=false, optional=true }
-serde = { version="1.0.123", features=["derive"] }
-serde_yaml = "0.8.16"
-lazy_static = "1.4.0"
+crossterm = "0.23.0"
+miette = { version = "4.4.0", features = ["fancy"] }
+thiserror = "1.0.29"
+reedline = { version = "0.4.0", features = ["bashisms"]}
 
-[build-dependencies]
-shadow-rs = "0.6"
+log = "0.4"
+is_executable = "1.0.1"
 
 [features]
-default = ["shadow-rs"]
-rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
-stable = []
+plugin = []

crates/nu-cli/LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2014 Benjamin Sago
+Copyright (c) 2019 - 2022 The Nushell Project Developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

crates/nu-cli/README.md

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

crates/nu-cli/build.rs

@@ -1,3 +0,0 @@
-fn main() -> shadow_rs::SdResult<()> {
-    shadow_rs::new()
-}

crates/nu-cli/src/app.rs

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

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

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

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

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

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

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

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

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

crates/nu-cli/src/cli.rs

@@ -1,526 +0,0 @@
-use crate::app::STOPWATCH;
-use crate::line_editor::configure_ctrl_c;
-use nu_ansi_term::Color;
-use nu_engine::{maybe_print_errors, run_block, script::run_script_standalone, EvaluationContext};
-
-#[allow(unused_imports)]
-pub(crate) use nu_engine::script::{process_script, LineResult};
-
-#[cfg(feature = "rustyline-support")]
-use crate::line_editor::{
-    configure_rustyline_editor, convert_rustyline_result_to_string,
-    default_rustyline_editor_configuration, nu_line_editor_helper,
-};
-
-#[allow(unused_imports)]
-use nu_data::config;
-use nu_source::{Tag, Text};
-use nu_stream::InputStream;
-#[allow(unused_imports)]
-use std::sync::atomic::Ordering;
-
-#[cfg(feature = "rustyline-support")]
-use rustyline::{self, error::ReadlineError};
-
-use nu_errors::ShellError;
-use nu_parser::ParserScope;
-use nu_protocol::{hir::ExternalRedirection, ConfigPath, UntaggedValue, Value};
-
-use log::trace;
-use std::error::Error;
-use std::iter::Iterator;
-use std::path::PathBuf;
-
-pub fn search_paths() -> Vec<std::path::PathBuf> {
-    use std::env;
-
-    let mut search_paths = Vec::new();
-
-    // Automatically add path `nu` is in as a search path
-    if let Ok(exe_path) = env::current_exe() {
-        if let Some(exe_dir) = exe_path.parent() {
-            search_paths.push(exe_dir.to_path_buf());
-        }
-    }
-
-    if let Ok(config) = nu_data::config::config(Tag::unknown()) {
-        if let Some(Value {
-            value: UntaggedValue::Table(pipelines),
-            ..
-        }) = config.get("plugin_dirs")
-        {
-            for pipeline in pipelines {
-                if let Ok(plugin_dir) = pipeline.as_string() {
-                    search_paths.push(PathBuf::from(plugin_dir));
-                }
-            }
-        }
-    }
-
-    search_paths
-}
-
-pub fn run_script_file(
-    context: EvaluationContext,
-    options: super::app::CliOptions,
-) -> Result<(), ShellError> {
-    if let Some(cfg) = options.config {
-        load_cfg_as_global_cfg(&context, PathBuf::from(cfg));
-    } else {
-        load_global_cfg(&context);
-    }
-
-    let _ = register_plugins(&context);
-    let _ = configure_ctrl_c(&context);
-
-    let script = options
-        .scripts
-        .get(0)
-        .ok_or_else(|| ShellError::unexpected("Nu source code not available"))?;
-
-    run_script_standalone(script.get_code().to_string(), options.stdin, &context, true)?;
-
-    Ok(())
-}
-
-#[cfg(feature = "rustyline-support")]
-pub fn cli(
-    context: EvaluationContext,
-    options: super::app::CliOptions,
-) -> Result<(), Box<dyn Error>> {
-    let _ = configure_ctrl_c(&context);
-
-    // start time for running startup scripts (this metric includes loading of the cfg, but w/e)
-    let startup_commands_start_time = std::time::Instant::now();
-
-    if let Some(cfg) = options.config {
-        load_cfg_as_global_cfg(&context, PathBuf::from(cfg));
-    } else {
-        load_global_cfg(&context);
-    }
-
-    // Store cmd duration in an env var
-    context.scope.add_env_var(
-        "CMD_DURATION_MS",
-        format!("{}", startup_commands_start_time.elapsed().as_millis()),
-    );
-
-    if options.perf {
-        eprintln!(
-            "config loaded: {:?}",
-            STOPWATCH
-                .lock()
-                .expect("unable to lock the stopwatch")
-                .elapsed_split()
-        );
-        STOPWATCH
-            .lock()
-            .expect("unable to lock the stopwatch")
-            .start();
-    }
-
-    //Configure rustyline
-    let mut rl = default_rustyline_editor_configuration();
-    let history_path = if let Some(cfg) = &context.configs().lock().global_config {
-        let _ = configure_rustyline_editor(&mut rl, cfg);
-        let helper = Some(nu_line_editor_helper(&context, cfg));
-        rl.set_helper(helper);
-        nu_data::config::path::history_path_or_default(cfg)
-    } else {
-        nu_data::config::path::default_history_path()
-    };
-
-    if options.perf {
-        eprintln!(
-            "rustyline configuration: {:?}",
-            STOPWATCH
-                .lock()
-                .expect("unable to lock the stopwatch")
-                .elapsed_split()
-        );
-        STOPWATCH
-            .lock()
-            .expect("unable to lock the stopwatch")
-            .start();
-    }
-
-    // Don't load history if it's not necessary
-    if options.save_history {
-        let _ = rl.load_history(&history_path);
-    }
-
-    if options.perf {
-        eprintln!(
-            "history load: {:?}",
-            STOPWATCH
-                .lock()
-                .expect("unable to lock the stopwatch")
-                .elapsed_split()
-        );
-        STOPWATCH
-            .lock()
-            .expect("unable to lock the stopwatch")
-            .start();
-    }
-
-    //set vars from cfg if present
-    let (skip_welcome_message, prompt) = if let Some(cfg) = &context.configs().lock().global_config
-    {
-        (
-            cfg.var("skip_welcome_message")
-                .map(|x| x.is_true())
-                .unwrap_or(false),
-            cfg.var("prompt"),
-        )
-    } else {
-        (false, None)
-    };
-
-    if options.perf {
-        eprintln!(
-            "load custom prompt: {:?}",
-            STOPWATCH
-                .lock()
-                .expect("unable to lock the stopwatch")
-                .elapsed_split()
-        );
-        STOPWATCH
-            .lock()
-            .expect("unable to lock the stopwatch")
-            .start();
-    }
-
-    //Check whether dir we start in contains local cfg file and if so load it.
-    load_local_cfg_if_present(&context);
-
-    // Give ourselves a scope to work in
-    context.scope.enter_scope();
-
-    let mut session_text = String::new();
-    let mut line_start: usize = 0;
-
-    if !skip_welcome_message {
-        println!(
-            "Welcome to Nushell {} (type 'help' for more info)",
-            nu_command::commands::core_version()
-        );
-    }
-
-    #[cfg(windows)]
-    {
-        let _ = nu_ansi_term::enable_ansi_support();
-    }
-
-    let mut ctrlcbreak = false;
-
-    if options.perf {
-        eprintln!(
-            "timing stopped. starting run loop: {:?}",
-            STOPWATCH
-                .lock()
-                .expect("unable to lock the stopwatch")
-                .elapsed_split()
-        );
-        STOPWATCH
-            .lock()
-            .expect("unable to lock the stopwatch")
-            .stop();
-    }
-
-    loop {
-        if context.ctrl_c().load(Ordering::SeqCst) {
-            context.ctrl_c().store(false, Ordering::SeqCst);
-            continue;
-        }
-
-        let cwd = context.shell_manager().path();
-
-        let colored_prompt = {
-            if let Some(prompt) = &prompt {
-                let prompt_line = prompt.as_string()?;
-
-                context.scope.enter_scope();
-                let (prompt_block, err) = nu_parser::parse(&prompt_line, 0, &context.scope);
-
-                if err.is_some() {
-                    context.scope.exit_scope();
-
-                    format!(
-                        "{}{}{}{}{}{}> ",
-                        Color::Green.bold().prefix().to_string(),
-                        cwd,
-                        nu_ansi_term::ansi::RESET,
-                        Color::Cyan.bold().prefix().to_string(),
-                        current_branch(),
-                        nu_ansi_term::ansi::RESET
-                    )
-                } else {
-                    let run_result = run_block(
-                        &prompt_block,
-                        &context,
-                        InputStream::empty(),
-                        ExternalRedirection::Stdout,
-                    );
-                    context.scope.exit_scope();
-
-                    match run_result {
-                        Ok(result) => match result.collect_string(Tag::unknown()) {
-                            Ok(string_result) => {
-                                let errors = context.get_errors();
-                                maybe_print_errors(&context, Text::from(prompt_line));
-                                context.clear_errors();
-
-                                if !errors.is_empty() {
-                                    "> ".to_string()
-                                } else {
-                                    string_result.item
-                                }
-                            }
-                            Err(e) => {
-                                context.host().lock().print_err(e, &Text::from(prompt_line));
-                                context.clear_errors();
-
-                                "> ".to_string()
-                            }
-                        },
-                        Err(e) => {
-                            context.host().lock().print_err(e, &Text::from(prompt_line));
-                            context.clear_errors();
-
-                            "> ".to_string()
-                        }
-                    }
-                }
-            } else {
-                format!(
-                    "{}{}{}{}{}{}> ",
-                    Color::Green.bold().prefix().to_string(),
-                    cwd,
-                    nu_ansi_term::ansi::RESET,
-                    Color::Cyan.bold().prefix().to_string(),
-                    current_branch(),
-                    nu_ansi_term::ansi::RESET
-                )
-            }
-        };
-
-        let prompt = {
-            if let Ok(bytes) = strip_ansi_escapes::strip(&colored_prompt) {
-                String::from_utf8_lossy(&bytes).to_string()
-            } else {
-                "> ".to_string()
-            }
-        };
-
-        if let Some(helper) = rl.helper_mut() {
-            helper.colored_prompt = colored_prompt;
-        }
-        let mut initial_command = Some(String::new());
-        let mut readline = Err(ReadlineError::Eof);
-        while let Some(ref cmd) = initial_command {
-            readline = rl.readline_with_initial(&prompt, (cmd, ""));
-            initial_command = None;
-        }
-
-        if let Ok(line) = &readline {
-            line_start = session_text.len();
-            session_text.push_str(line);
-            session_text.push('\n');
-        }
-
-        // start time for command duration
-        let cmd_start_time = std::time::Instant::now();
-
-        let line = match convert_rustyline_result_to_string(readline) {
-            LineResult::Success(_) => process_script(
-                &session_text[line_start..],
-                &context,
-                false,
-                line_start,
-                true,
-            ),
-            x => x,
-        };
-
-        // Store cmd duration in an env var
-        context.scope.add_env_var(
-            "CMD_DURATION_MS",
-            format!("{}", cmd_start_time.elapsed().as_millis()),
-        );
-
-        match line {
-            LineResult::Success(line) => {
-                if options.save_history && !line.trim().is_empty() {
-                    rl.add_history_entry(&line);
-                    let _ = rl.append_history(&history_path);
-                }
-                maybe_print_errors(&context, Text::from(session_text.clone()));
-            }
-
-            LineResult::ClearHistory => {
-                if options.save_history {
-                    rl.clear_history();
-                    let _ = rl.append_history(&history_path);
-                }
-            }
-
-            LineResult::Error(line, err) => {
-                if options.save_history && !line.trim().is_empty() {
-                    rl.add_history_entry(&line);
-                    let _ = rl.append_history(&history_path);
-                }
-
-                context
-                    .host()
-                    .lock()
-                    .print_err(err, &Text::from(session_text.clone()));
-
-                // I am not so sure, we don't need maybe_print_errors here (as we printed an err
-                // above), because maybe_print_errors also clears the errors.
-                // TODO Analyze where above err comes from, and whether we need to clear
-                // context.errors here
-                // Or just be consistent and return errors always in context.errors...
-                maybe_print_errors(&context, Text::from(session_text.clone()));
-            }
-
-            LineResult::CtrlC => {
-                let config_ctrlc_exit = context
-                    .configs()
-                    .lock()
-                    .global_config
-                    .as_ref()
-                    .map(|cfg| cfg.var("ctrlc_exit"))
-                    .flatten()
-                    .map(|ctrl_c| ctrl_c.is_true())
-                    .unwrap_or(false); // default behavior is to allow CTRL-C spamming similar to other shells
-
-                if !config_ctrlc_exit {
-                    continue;
-                }
-
-                if ctrlcbreak {
-                    if options.save_history {
-                        let _ = rl.append_history(&history_path);
-                    }
-                    std::process::exit(0);
-                } else {
-                    context.with_host(|host| host.stdout("CTRL-C pressed (again to quit)"));
-                    ctrlcbreak = true;
-                    continue;
-                }
-            }
-
-            LineResult::CtrlD => {
-                context.shell_manager().remove_at_current();
-                if context.shell_manager().is_empty() {
-                    break;
-                }
-            }
-
-            LineResult::Break => {
-                break;
-            }
-        }
-        ctrlcbreak = false;
-    }
-
-    // we are ok if we can not save history
-    if options.save_history {
-        let _ = rl.append_history(&history_path);
-    }
-
-    Ok(())
-}
-
-pub fn load_local_cfg_if_present(context: &EvaluationContext) {
-    trace!("Loading local cfg if present");
-    match config::loadable_cfg_exists_in_dir(PathBuf::from(context.shell_manager().path())) {
-        Ok(Some(cfg_path)) => {
-            if let Err(err) = context.load_config(&ConfigPath::Local(cfg_path)) {
-                context.host().lock().print_err(err, &Text::from(""))
-            }
-        }
-        Err(e) => {
-            //Report error while checking for local cfg file
-            context.host().lock().print_err(e, &Text::from(""))
-        }
-        Ok(None) => {
-            //No local cfg file present in start dir
-        }
-    }
-}
-
-fn load_cfg_as_global_cfg(context: &EvaluationContext, path: PathBuf) {
-    if let Err(err) = context.load_config(&ConfigPath::Global(path)) {
-        context.host().lock().print_err(err, &Text::from(""));
-    }
-}
-
-pub fn load_global_cfg(context: &EvaluationContext) {
-    match config::default_path() {
-        Ok(path) => {
-            load_cfg_as_global_cfg(context, path);
-        }
-        Err(e) => {
-            context.host().lock().print_err(e, &Text::from(""));
-        }
-    }
-}
-
-pub fn register_plugins(context: &EvaluationContext) -> Result<(), ShellError> {
-    if let Ok(plugins) = nu_engine::plugin::build_plugin::scan(search_paths()) {
-        context.add_commands(
-            plugins
-                .into_iter()
-                .filter(|p| !context.is_command_registered(p.name()))
-                .collect(),
-        );
-    }
-
-    Ok(())
-}
-
-pub fn parse_and_eval(line: &str, ctx: &EvaluationContext) -> Result<String, ShellError> {
-    // FIXME: do we still need this?
-    let line = if let Some(s) = line.strip_suffix('\n') {
-        s
-    } else {
-        line
-    };
-
-    // TODO ensure the command whose examples we're testing is actually in the pipeline
-    ctx.scope.enter_scope();
-    let (classified_block, err) = nu_parser::parse(line, 0, &ctx.scope);
-    if let Some(err) = err {
-        ctx.scope.exit_scope();
-        return Err(err.into());
-    }
-
-    let input_stream = InputStream::empty();
-
-    let result = run_block(
-        &classified_block,
-        ctx,
-        input_stream,
-        ExternalRedirection::Stdout,
-    );
-    ctx.scope.exit_scope();
-
-    result?.collect_string(Tag::unknown()).map(|x| x.item)
-}
-
-#[allow(dead_code)]
-fn current_branch() -> String {
-    #[cfg(feature = "shadow-rs")]
-    {
-        Some(shadow_rs::branch())
-            .map(|x| x.trim().to_string())
-            .filter(|x| !x.is_empty())
-            .map(|x| format!("({})", x))
-            .unwrap_or_default()
-    }
-    #[cfg(not(feature = "shadow-rs"))]
-    {
-        "".to_string()
-    }
-}

crates/nu-cli/src/commands.rs

@@ -0,0 +1,99 @@
+use crate::util::report_error;
+use log::info;
+use miette::Result;
+use nu_engine::{convert_env_values, eval_block};
+use nu_parser::{parse, trim_quotes};
+use nu_protocol::engine::Stack;
+use nu_protocol::{
+    engine::{EngineState, StateDelta, StateWorkingSet},
+    Config, PipelineData, Spanned,
+};
+use std::path::Path;
+
+pub fn evaluate_commands(
+    commands: &Spanned<String>,
+    init_cwd: &Path,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    is_perf_true: bool,
+) -> Result<()> {
+    // Run a command (or commands) given to us by the user
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+
+        let (input, _) = if commands.item.starts_with('\'') || commands.item.starts_with('"') {
+            (
+                trim_quotes(commands.item.as_bytes()),
+                commands.span.start + 1,
+            )
+        } else {
+            (commands.item.as_bytes(), commands.span.start)
+        };
+
+        let (output, err) = parse(&mut working_set, None, input, false, &[]);
+        if let Some(err) = err {
+            report_error(&working_set, &err);
+
+            std::process::exit(1);
+        }
+
+        (output, working_set.render())
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta, None, init_cwd) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    let config = match stack.get_config() {
+        Ok(config) => config,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &e);
+            Config::default()
+        }
+    };
+
+    // 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(), 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) => {
+            crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &config)
+        }
+        Err(err) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+            std::process::exit(1);
+        }
+    }
+
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
+
+    Ok(())
+}

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

@@ -0,0 +1,74 @@
+use crate::completions::{CompletionOptions, SortBy};
+use nu_protocol::{engine::StateWorkingSet, levenshtein_distance, Span};
+use reedline::Suggestion;
+
+// Completer trait represents the three stages of the completion
+// fetch, filter and sort
+pub trait Completer {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        pos: usize,
+    ) -> (Vec<Suggestion>, CompletionOptions);
+
+    // Filter results using the completion options
+    fn filter(
+        &self,
+        prefix: Vec<u8>,
+        items: Vec<Suggestion>,
+        options: CompletionOptions,
+    ) -> Vec<Suggestion> {
+        items
+            .into_iter()
+            .filter(|it| {
+                // Minimise clones for new functionality
+                match (options.case_sensitive, options.positional) {
+                    (true, true) => it.value.as_bytes().starts_with(&prefix),
+                    (true, false) => it
+                        .value
+                        .contains(std::str::from_utf8(&prefix).unwrap_or("")),
+                    (false, positional) => {
+                        let value = it.value.to_lowercase();
+                        let prefix = std::str::from_utf8(&prefix).unwrap_or("").to_lowercase();
+                        if positional {
+                            value.starts_with(&prefix)
+                        } else {
+                            value.contains(&prefix)
+                        }
+                    }
+                }
+            })
+            .collect()
+    }
+
+    // Sort results using the completion options
+    fn sort(
+        &self,
+        items: Vec<Suggestion>,
+        prefix: Vec<u8>,
+        options: CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+        let mut filtered_items = items;
+
+        // Sort items
+        match options.sort_by {
+            SortBy::LevenshteinDistance => {
+                filtered_items.sort_by(|a, b| {
+                    let a_distance = levenshtein_distance(&prefix_str, &a.value);
+                    let b_distance = levenshtein_distance(&prefix_str, &b.value);
+                    a_distance.cmp(&b_distance)
+                });
+            }
+            SortBy::Ascending => {
+                filtered_items.sort_by(|a, b| a.value.cmp(&b.value));
+            }
+            SortBy::None => {}
+        };
+
+        filtered_items
+    }
+}

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

@@ -0,0 +1,274 @@
+use crate::completions::{
+    file_completions::file_path_completion, Completer, CompletionOptions, SortBy,
+};
+use nu_parser::{trim_quotes, FlatShape};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Span,
+};
+use reedline::Suggestion;
+use std::sync::Arc;
+
+pub struct CommandCompletion {
+    engine_state: Arc<EngineState>,
+    flattened: Vec<(Span, FlatShape)>,
+    flat_idx: usize,
+    flat_shape: FlatShape,
+}
+
+impl CommandCompletion {
+    pub fn new(
+        engine_state: Arc<EngineState>,
+        _: &StateWorkingSet,
+        flattened: Vec<(Span, FlatShape)>,
+        flat_idx: usize,
+        flat_shape: FlatShape,
+    ) -> Self {
+        Self {
+            engine_state,
+            flattened,
+            flat_idx,
+            flat_shape,
+        }
+    }
+
+    fn external_command_completion(&self, prefix: &str) -> Vec<String> {
+        let mut executables = vec![];
+
+        let paths = self.engine_state.env_vars.get("PATH");
+
+        if let Some(paths) = paths {
+            if let Ok(paths) = paths.as_list() {
+                for path in paths {
+                    let path = path.as_string().unwrap_or_default();
+
+                    if let Ok(mut contents) = std::fs::read_dir(path) {
+                        while let Some(Ok(item)) = contents.next() {
+                            if !executables.contains(
+                                &item
+                                    .path()
+                                    .file_name()
+                                    .map(|x| x.to_string_lossy().to_string())
+                                    .unwrap_or_default(),
+                            ) && matches!(
+                                item.path()
+                                    .file_name()
+                                    .map(|x| x.to_string_lossy().starts_with(prefix)),
+                                Some(true)
+                            ) && is_executable::is_executable(&item.path())
+                            {
+                                if let Ok(name) = item.file_name().into_string() {
+                                    executables.push(name);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        executables
+    }
+
+    fn complete_commands(
+        &self,
+        working_set: &StateWorkingSet,
+        span: Span,
+        offset: usize,
+        find_externals: bool,
+    ) -> Vec<Suggestion> {
+        let prefix = working_set.get_span_contents(span);
+
+        let results = working_set
+            .find_commands_by_prefix(prefix)
+            .into_iter()
+            .map(move |x| Suggestion {
+                value: String::from_utf8_lossy(&x.0).to_string(),
+                description: x.1,
+                extra: None,
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
+            });
+
+        let results_aliases =
+            working_set
+                .find_aliases_by_prefix(prefix)
+                .into_iter()
+                .map(move |x| Suggestion {
+                    value: String::from_utf8_lossy(&x).to_string(),
+                    description: None,
+                    extra: None,
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                });
+
+        let mut results = results.chain(results_aliases).collect::<Vec<_>>();
+
+        let prefix = working_set.get_span_contents(span);
+        let prefix = String::from_utf8_lossy(prefix).to_string();
+        let results = if find_externals {
+            let results_external =
+                self.external_command_completion(&prefix)
+                    .into_iter()
+                    .map(move |x| Suggestion {
+                        value: x,
+                        description: None,
+                        extra: None,
+                        span: reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                    });
+
+            for external in results_external {
+                if results.contains(&external) {
+                    results.push(Suggestion {
+                        value: format!("^{}", external.value),
+                        description: None,
+                        extra: None,
+                        span: external.span,
+                    })
+                } else {
+                    results.push(external)
+                }
+            }
+
+            results
+        } else {
+            results
+        };
+
+        results
+    }
+}
+
+impl Completer for CommandCompletion {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        pos: usize,
+    ) -> (Vec<Suggestion>, CompletionOptions) {
+        let last = self
+            .flattened
+            .iter()
+            .rev()
+            .skip_while(|x| x.0.end > pos)
+            .take_while(|x| {
+                matches!(
+                    x.1,
+                    FlatShape::InternalCall
+                        | FlatShape::External
+                        | FlatShape::ExternalArg
+                        | FlatShape::Literal
+                        | FlatShape::String
+                )
+            })
+            .last();
+
+        // Options
+        let options = CompletionOptions::new(true, true, SortBy::LevenshteinDistance);
+
+        // The last item here would be the earliest shape that could possible by part of this subcommand
+        let subcommands = if let Some(last) = last {
+            self.complete_commands(
+                working_set,
+                Span {
+                    start: last.0.start,
+                    end: pos,
+                },
+                offset,
+                false,
+            )
+        } else {
+            vec![]
+        };
+
+        if !subcommands.is_empty() {
+            return (subcommands, options);
+        }
+
+        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)
+        } else {
+            vec![]
+        };
+
+        let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
+            match d.as_string() {
+                Ok(s) => s,
+                Err(_) => "".to_string(),
+            }
+        } else {
+            "".to_string()
+        };
+
+        let preceding_byte = if span.start > offset {
+            working_set
+                .get_span_contents(Span {
+                    start: span.start - 1,
+                    end: span.start,
+                })
+                .to_vec()
+        } else {
+            vec![]
+        };
+        // let prefix = working_set.get_span_contents(flat.0);
+        let prefix = String::from_utf8_lossy(&prefix).to_string();
+        let output = file_path_completion(span, &prefix, &cwd)
+            .into_iter()
+            .map(move |x| {
+                if self.flat_idx == 0 {
+                    // We're in the command position
+                    if x.1.starts_with('"') && !matches!(preceding_byte.get(0), Some(b'^')) {
+                        let trimmed = trim_quotes(x.1.as_bytes());
+                        let trimmed = String::from_utf8_lossy(trimmed).to_string();
+                        let expanded = nu_path::canonicalize_with(trimmed, &cwd);
+
+                        if let Ok(expanded) = expanded {
+                            if is_executable::is_executable(expanded) {
+                                (x.0, format!("^{}", x.1))
+                            } else {
+                                (x.0, x.1)
+                            }
+                        } else {
+                            (x.0, x.1)
+                        }
+                    } else {
+                        (x.0, x.1)
+                    }
+                } else {
+                    (x.0, x.1)
+                }
+            })
+            .map(move |x| Suggestion {
+                value: x.1,
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: x.0.start - offset,
+                    end: x.0.end - offset,
+                },
+            })
+            .chain(subcommands.into_iter())
+            .chain(commands.into_iter())
+            .collect::<Vec<_>>();
+
+        (output, options)
+    }
+
+    // Replace base filter with no filter once all the results are already based in the current path
+    fn filter(&self, _: Vec<u8>, items: Vec<Suggestion>, _: CompletionOptions) -> Vec<Suggestion> {
+        items
+    }
+}

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

@@ -0,0 +1,174 @@
+use crate::completions::{
+    CommandCompletion, Completer, CustomCompletion, FileCompletion, FlagCompletion,
+    VariableCompletion,
+};
+use nu_parser::{flatten_expression, parse, FlatShape};
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    Span, Value,
+};
+use reedline::{Completer as ReedlineCompleter, Suggestion};
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct NuCompleter {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+    config: Option<Value>,
+}
+
+impl NuCompleter {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack, config: Option<Value>) -> Self {
+        Self {
+            engine_state,
+            stack,
+            config,
+        }
+    }
+
+    // Process the completion for a given completer
+    fn process_completion<T: Completer>(
+        &self,
+        completer: &mut T,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        new_span: Span,
+        offset: usize,
+        pos: usize,
+    ) -> Vec<Suggestion> {
+        // Fetch
+        let (mut suggestions, options) =
+            completer.fetch(working_set, prefix.clone(), new_span, offset, pos);
+
+        // Filter
+        suggestions = completer.filter(prefix.clone(), suggestions, options.clone());
+
+        // Sort
+        suggestions = completer.sort(suggestions, prefix, options);
+
+        suggestions
+    }
+
+    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 line = line.to_string();
+        line.insert(pos, 'a');
+        let pos = offset + pos;
+        let (output, _err) = parse(
+            &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);
+
+                for (flat_idx, flat) in flattened.iter().enumerate() {
+                    if pos >= flat.0.start && pos < flat.0.end {
+                        // Create a new span
+                        let new_span = Span {
+                            start: flat.0.start,
+                            end: flat.0.end - 1,
+                        };
+
+                        // Parses the prefix
+                        let mut prefix = working_set.get_span_contents(flat.0).to_vec();
+                        prefix.remove(pos - flat.0.start);
+
+                        // Variables completion
+                        if prefix.starts_with(b"$") {
+                            let mut completer = VariableCompletion::new(self.engine_state.clone());
+
+                            return self.process_completion(
+                                &mut completer,
+                                &working_set,
+                                prefix,
+                                new_span,
+                                offset,
+                                pos,
+                            );
+                        }
+
+                        // Flags completion
+                        if prefix.starts_with(b"-") {
+                            let mut completer = FlagCompletion::new(expr);
+
+                            return self.process_completion(
+                                &mut completer,
+                                &working_set,
+                                prefix,
+                                new_span,
+                                offset,
+                                pos,
+                            );
+                        }
+
+                        // Match other types
+                        match &flat.1 {
+                            FlatShape::Custom(decl_id) => {
+                                let mut completer = CustomCompletion::new(
+                                    self.engine_state.clone(),
+                                    self.stack.clone(),
+                                    self.config.clone(),
+                                    *decl_id,
+                                    line,
+                                );
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
+                            FlatShape::Filepath | FlatShape::GlobPattern => {
+                                let mut completer = FileCompletion::new(self.engine_state.clone());
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
+                            flat_shape => {
+                                let mut completer = CommandCompletion::new(
+                                    self.engine_state.clone(),
+                                    &working_set,
+                                    flattened.clone(),
+                                    flat_idx,
+                                    flat_shape.clone(),
+                                );
+
+                                return self.process_completion(
+                                    &mut completer,
+                                    &working_set,
+                                    prefix,
+                                    new_span,
+                                    offset,
+                                    pos,
+                                );
+                            }
+                        };
+                    }
+                }
+            }
+        }
+
+        return vec![];
+    }
+}
+
+impl ReedlineCompleter for NuCompleter {
+    fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+        self.completion_helper(line, pos)
+    }
+}

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

@@ -0,0 +1,33 @@
+#[derive(Clone)]
+pub enum SortBy {
+    LevenshteinDistance,
+    Ascending,
+    None,
+}
+
+#[derive(Clone)]
+pub struct CompletionOptions {
+    pub case_sensitive: bool,
+    pub positional: bool,
+    pub sort_by: SortBy,
+}
+
+impl CompletionOptions {
+    pub fn new(case_sensitive: bool, positional: bool, sort_by: SortBy) -> Self {
+        Self {
+            case_sensitive,
+            positional,
+            sort_by,
+        }
+    }
+}
+
+impl Default for CompletionOptions {
+    fn default() -> Self {
+        Self {
+            case_sensitive: true,
+            positional: true,
+            sort_by: SortBy::Ascending,
+        }
+    }
+}

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

@@ -0,0 +1,171 @@
+use crate::completions::{Completer, CompletionOptions, SortBy};
+use nu_engine::eval_call;
+use nu_protocol::{
+    ast::{Argument, Call, Expr, Expression},
+    engine::{EngineState, Stack, StateWorkingSet},
+    PipelineData, Span, Type, Value, CONFIG_VARIABLE_ID,
+};
+use reedline::Suggestion;
+use std::sync::Arc;
+
+pub struct CustomCompletion {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+    config: Option<Value>,
+    decl_id: usize,
+    line: String,
+}
+
+impl CustomCompletion {
+    pub fn new(
+        engine_state: Arc<EngineState>,
+        stack: Stack,
+        config: Option<Value>,
+        decl_id: usize,
+        line: String,
+    ) -> Self {
+        Self {
+            engine_state,
+            stack,
+            config,
+            decl_id,
+            line,
+        }
+    }
+
+    fn map_completions<'a>(
+        &self,
+        list: impl Iterator<Item = &'a Value>,
+        span: Span,
+        offset: usize,
+    ) -> Vec<Suggestion> {
+        list.filter_map(move |x| {
+            let s = x.as_string();
+
+            match s {
+                Ok(s) => Some(Suggestion {
+                    value: s,
+                    description: None,
+                    extra: None,
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                }),
+                Err(_) => None,
+            }
+        })
+        .collect()
+    }
+}
+
+impl Completer for CustomCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        _: Vec<u8>,
+        span: Span,
+        offset: usize,
+        pos: usize,
+    ) -> (Vec<Suggestion>, CompletionOptions) {
+        // Line position
+        let line_pos = pos - offset;
+
+        // Set up our initial config to start from
+        if let Some(conf) = &self.config {
+            self.stack.vars.insert(CONFIG_VARIABLE_ID, conf.clone());
+        } else {
+            self.stack.vars.insert(
+                CONFIG_VARIABLE_ID,
+                Value::Record {
+                    cols: vec![],
+                    vals: vec![],
+                    span: Span { start: 0, end: 0 },
+                },
+            );
+        }
+
+        // Call custom declaration
+        let result = eval_call(
+            &self.engine_state,
+            &mut self.stack,
+            &Call {
+                decl_id: self.decl_id,
+                head: span,
+                arguments: vec![
+                    Argument::Positional(Expression {
+                        span: Span { start: 0, end: 0 },
+                        ty: Type::String,
+                        expr: Expr::String(self.line.clone()),
+                        custom_completion: None,
+                    }),
+                    Argument::Positional(Expression {
+                        span: Span { start: 0, end: 0 },
+                        ty: Type::Int,
+                        expr: Expr::Int(line_pos as i64),
+                        custom_completion: None,
+                    }),
+                ],
+                redirect_stdout: true,
+                redirect_stderr: true,
+            },
+            PipelineData::new(span),
+        );
+
+        // Parse result
+        let (suggestions, options) = match result {
+            Ok(pd) => {
+                let value = pd.into_value(span);
+                match &value {
+                    Value::Record { .. } => {
+                        let completions = value
+                            .get_data_by_key("completions")
+                            .and_then(|val| {
+                                val.as_list()
+                                    .ok()
+                                    .map(|it| self.map_completions(it.iter(), span, offset))
+                            })
+                            .unwrap_or_default();
+                        let options = value.get_data_by_key("options");
+
+                        let options = if let Some(Value::Record { .. }) = &options {
+                            let options = options.unwrap_or_default();
+                            let should_sort = options
+                                .get_data_by_key("sort")
+                                .and_then(|val| val.as_bool().ok())
+                                .unwrap_or(false);
+
+                            CompletionOptions {
+                                case_sensitive: options
+                                    .get_data_by_key("case_sensitive")
+                                    .and_then(|val| val.as_bool().ok())
+                                    .unwrap_or(true),
+                                positional: options
+                                    .get_data_by_key("positional")
+                                    .and_then(|val| val.as_bool().ok())
+                                    .unwrap_or(true),
+                                sort_by: if should_sort {
+                                    SortBy::Ascending
+                                } else {
+                                    SortBy::None
+                                },
+                            }
+                        } else {
+                            CompletionOptions::default()
+                        };
+
+                        (completions, options)
+                    }
+                    Value::List { vals, .. } => {
+                        let completions = self.map_completions(vals.iter(), span, offset);
+                        (completions, CompletionOptions::default())
+                    }
+                    _ => (vec![], CompletionOptions::default()),
+                }
+            }
+            _ => (vec![], CompletionOptions::default()),
+        };
+
+        (suggestions, options)
+    }
+}

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

@@ -0,0 +1,163 @@
+use crate::completions::{Completer, CompletionOptions};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    levenshtein_distance, Span,
+};
+use reedline::Suggestion;
+use std::path::{is_separator, Path};
+use std::sync::Arc;
+
+const SEP: char = std::path::MAIN_SEPARATOR;
+
+#[derive(Clone)]
+pub struct FileCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl FileCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for FileCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+    ) -> (Vec<Suggestion>, CompletionOptions) {
+        let cwd = if let Some(d) = self.engine_state.env_vars.get("PWD") {
+            match d.as_string() {
+                Ok(s) => s,
+                Err(_) => "".to_string(),
+            }
+        } else {
+            "".to_string()
+        };
+        let prefix = String::from_utf8_lossy(&prefix).to_string();
+        let output: Vec<_> = file_path_completion(span, &prefix, &cwd)
+            .into_iter()
+            .map(move |x| Suggestion {
+                value: x.1,
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: x.0.start - offset,
+                    end: x.0.end - offset,
+                },
+            })
+            .collect();
+
+        // Options
+        let options = CompletionOptions::default();
+
+        (output, options)
+    }
+
+    // Sort results prioritizing the non hidden folders
+    fn sort(
+        &self,
+        items: Vec<Suggestion>,
+        prefix: Vec<u8>,
+        _: CompletionOptions, // Ignore the given options, once it's a custom sorting
+    ) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+
+        // Sort items
+        let mut sorted_items = items;
+        sorted_items.sort_by(|a, b| {
+            let a_distance = levenshtein_distance(&prefix_str, &a.value);
+            let b_distance = levenshtein_distance(&prefix_str, &b.value);
+            a_distance.cmp(&b_distance)
+        });
+
+        // Separate the results between hidden and non hidden
+        let mut hidden: Vec<Suggestion> = vec![];
+        let mut non_hidden: Vec<Suggestion> = vec![];
+
+        for item in sorted_items.into_iter() {
+            let item_path = Path::new(&item.value);
+
+            if let Some(value) = item_path.file_name() {
+                if let Some(value) = value.to_str() {
+                    if value.starts_with('.') {
+                        hidden.push(item);
+                    } else {
+                        non_hidden.push(item);
+                    }
+                }
+            }
+        }
+
+        // Append the hidden folders to the non hidden vec to avoid creating a new vec
+        non_hidden.append(&mut hidden);
+
+        non_hidden
+    }
+
+    // Replace base filter with no filter once all the results are already based in the current path
+    fn filter(&self, _: Vec<u8>, items: Vec<Suggestion>, _: CompletionOptions) -> Vec<Suggestion> {
+        items
+    }
+}
+
+pub fn file_path_completion(
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+) -> Vec<(nu_protocol::Span, String)> {
+    let partial = partial.replace('\'', "");
+
+    let (base_dir_name, partial) = {
+        // If partial is only a word we want to search in the current dir
+        let (base, rest) = partial.rsplit_once(is_separator).unwrap_or((".", &partial));
+        // On windows, this standardizes paths to use \
+        let mut base = base.replace(is_separator, &SEP.to_string());
+
+        // rsplit_once removes the separator
+        base.push(SEP);
+        (base, rest)
+    };
+
+    let base_dir = nu_path::expand_path_with(&base_dir_name, cwd);
+    // This check is here as base_dir.read_dir() with base_dir == "" will open the current dir
+    // which we don't want in this case (if we did, base_dir would already be ".")
+    if base_dir == Path::new("") {
+        return Vec::new();
+    }
+
+    if let Ok(result) = base_dir.read_dir() {
+        return result
+            .filter_map(|entry| {
+                entry.ok().and_then(|entry| {
+                    let mut file_name = entry.file_name().to_string_lossy().into_owned();
+                    if matches(partial, &file_name) {
+                        let mut path = format!("{}{}", base_dir_name, file_name);
+                        if entry.path().is_dir() {
+                            path.push(SEP);
+                            file_name.push(SEP);
+                        }
+
+                        if path.contains(' ') {
+                            path = format!("\'{}\'", path);
+                        }
+
+                        Some((span, path))
+                    } else {
+                        None
+                    }
+                })
+            })
+            .collect();
+    }
+
+    Vec::new()
+}
+
+pub fn matches(partial: &str, from: &str) -> bool {
+    from.to_ascii_lowercase()
+        .starts_with(&partial.to_ascii_lowercase())
+}

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

@@ -0,0 +1,81 @@
+use crate::completions::{Completer, CompletionOptions};
+use nu_protocol::{
+    ast::{Expr, Expression},
+    engine::StateWorkingSet,
+    Span,
+};
+
+use reedline::Suggestion;
+
+#[derive(Clone)]
+pub struct FlagCompletion {
+    expression: Expression,
+}
+
+impl FlagCompletion {
+    pub fn new(expression: Expression) -> Self {
+        Self { expression }
+    }
+}
+
+impl Completer for FlagCompletion {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+    ) -> (Vec<Suggestion>, CompletionOptions) {
+        // Check if it's a flag
+        if let Expr::Call(call) = &self.expression.expr {
+            let decl = working_set.get_decl(call.decl_id);
+            let sig = decl.signature();
+
+            let mut output = vec![];
+
+            for named in &sig.named {
+                let flag_desc = &named.desc;
+                if let Some(short) = named.short {
+                    let mut named = vec![0; short.len_utf8()];
+                    short.encode_utf8(&mut named);
+                    named.insert(0, b'-');
+                    if named.starts_with(&prefix) {
+                        output.push(Suggestion {
+                            value: String::from_utf8_lossy(&named).to_string(),
+                            description: Some(flag_desc.to_string()),
+                            extra: None,
+                            span: reedline::Span {
+                                start: span.start - offset,
+                                end: span.end - offset,
+                            },
+                        });
+                    }
+                }
+
+                if named.long.is_empty() {
+                    continue;
+                }
+
+                let mut named = named.long.as_bytes().to_vec();
+                named.insert(0, b'-');
+                named.insert(0, b'-');
+                if named.starts_with(&prefix) {
+                    output.push(Suggestion {
+                        value: String::from_utf8_lossy(&named).to_string(),
+                        description: Some(flag_desc.to_string()),
+                        extra: None,
+                        span: reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                    });
+                }
+            }
+
+            return (output, CompletionOptions::default());
+        }
+
+        (vec![], CompletionOptions::default())
+    }
+}

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

@@ -0,0 +1,17 @@
+mod base;
+mod command_completions;
+mod completer;
+mod completion_options;
+mod custom_completions;
+mod file_completions;
+mod flag_completions;
+mod variable_completions;
+
+pub use base::Completer;
+pub use command_completions::CommandCompletion;
+pub use completer::NuCompleter;
+pub use completion_options::{CompletionOptions, SortBy};
+pub use custom_completions::CustomCompletion;
+pub use file_completions::{file_path_completion, FileCompletion};
+pub use flag_completions::FlagCompletion;
+pub use variable_completions::VariableCompletion;

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

@@ -0,0 +1,82 @@
+use crate::completions::{Completer, CompletionOptions};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Span,
+};
+use reedline::Suggestion;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct VariableCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl VariableCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for VariableCompletion {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+    ) -> (Vec<Suggestion>, CompletionOptions) {
+        let mut output = vec![];
+
+        let builtins = ["$nu", "$in", "$config", "$env", "$nothing"];
+
+        for builtin in builtins {
+            if builtin.as_bytes().starts_with(&prefix) {
+                output.push(Suggestion {
+                    value: builtin.to_string(),
+                    description: None,
+                    extra: None,
+                    span: reedline::Span {
+                        start: span.start - offset,
+                        end: span.end - offset,
+                    },
+                });
+            }
+        }
+
+        for scope in &working_set.delta.scope {
+            for v in &scope.vars {
+                if v.0.starts_with(&prefix) {
+                    output.push(Suggestion {
+                        value: String::from_utf8_lossy(v.0).to_string(),
+                        description: None,
+                        extra: None,
+                        span: reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                    });
+                }
+            }
+        }
+        for scope in &self.engine_state.scope {
+            for v in &scope.vars {
+                if v.0.starts_with(&prefix) {
+                    output.push(Suggestion {
+                        value: String::from_utf8_lossy(v.0).to_string(),
+                        description: None,
+                        extra: None,
+                        span: reedline::Span {
+                            start: span.start - offset,
+                            end: span.end - offset,
+                        },
+                    });
+                }
+            }
+        }
+
+        output.dedup();
+
+        (output, CompletionOptions::default())
+    }
+}

crates/nu-cli/src/config_files.rs

@@ -0,0 +1,84 @@
+use crate::util::{eval_source, report_error};
+#[cfg(feature = "plugin")]
+use log::info;
+use nu_protocol::engine::{EngineState, Stack, StateDelta, StateWorkingSet};
+use nu_protocol::{PipelineData, Span};
+use std::path::PathBuf;
+
+#[cfg(feature = "plugin")]
+const PLUGIN_FILE: &str = "plugin.nu";
+
+#[cfg(feature = "plugin")]
+pub fn read_plugin_file(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    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);
+
+    let plugin_path = engine_state.plugin_signatures.clone();
+    if let Some(plugin_path) = plugin_path {
+        let plugin_filename = plugin_path.to_string_lossy().to_owned();
+
+        if let Ok(contents) = std::fs::read(&plugin_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &plugin_filename,
+                PipelineData::new(Span::new(0, 0)),
+            );
+        }
+    }
+
+    if is_perf_true {
+        info!("read_plugin_file {}:{}:{}", file!(), line!(), column!());
+    }
+}
+
+#[cfg(feature = "plugin")]
+pub fn add_plugin_file(engine_state: &mut EngineState, storage_path: &str) {
+    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);
+        engine_state.plugin_signatures = Some(plugin_path.clone());
+    }
+}
+
+pub fn eval_config_contents(
+    config_path: PathBuf,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+) {
+    if config_path.exists() & config_path.is_file() {
+        let config_filename = config_path.to_string_lossy().to_owned();
+
+        if let Ok(contents) = std::fs::read(&config_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &config_filename,
+                PipelineData::new(Span::new(0, 0)),
+            );
+
+            // 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(), Some(stack), cwd) {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &e);
+                    }
+                }
+                Err(e) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+                    report_error(&working_set, &e);
+                }
+            }
+        }
+    }
+}

crates/nu-cli/src/errors.rs

@@ -0,0 +1,54 @@
+use miette::{LabeledSpan, MietteHandler, ReportHandler, Severity, SourceCode};
+use nu_protocol::engine::StateWorkingSet;
+use thiserror::Error;
+
+/// This error exists so that we can defer SourceCode handling. It simply
+/// forwards most methods, except for `.source_code()`, which we provide.
+#[derive(Error)]
+#[error("{0}")]
+pub struct CliError<'src>(
+    pub &'src (dyn miette::Diagnostic + Send + Sync + 'static),
+    pub &'src StateWorkingSet<'src>,
+);
+
+impl std::fmt::Debug for CliError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        MietteHandler::default().debug(self, f)?;
+        Ok(())
+    }
+}
+
+impl<'src> miette::Diagnostic for CliError<'src> {
+    fn code<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.0.code()
+    }
+
+    fn severity(&self) -> Option<Severity> {
+        self.0.severity()
+    }
+
+    fn help<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.0.help()
+    }
+
+    fn url<'a>(&'a self) -> Option<Box<dyn std::fmt::Display + 'a>> {
+        self.0.url()
+    }
+
+    fn labels<'a>(&'a self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + 'a>> {
+        self.0.labels()
+    }
+
+    // Finally, we redirect the source_code method to our own source.
+    fn source_code(&self) -> Option<&dyn SourceCode> {
+        if let Some(source_code) = self.0.source_code() {
+            Some(source_code)
+        } else {
+            Some(&self.1)
+        }
+    }
+
+    fn related<'a>(&'a self) -> Option<Box<dyn Iterator<Item = &'a dyn miette::Diagnostic> + 'a>> {
+        self.0.related()
+    }
+}

crates/nu-cli/src/eval_file.rs

@@ -0,0 +1,141 @@
+use crate::util::{eval_source, report_error};
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_engine::convert_env_values;
+use nu_parser::parse;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, Span, Value,
+};
+use std::io::Write;
+
+/// Main function used when a file path is found as argument for nu
+pub fn evaluate_file(
+    path: String,
+    args: &[String],
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    is_perf_true: bool,
+) -> Result<()> {
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    let file = std::fs::read(&path).into_diagnostic()?;
+
+    let mut working_set = StateWorkingSet::new(engine_state);
+    trace!("parsing file: {}", path);
+
+    let _ = parse(&mut working_set, Some(&path), &file, false, &[]);
+
+    if working_set.find_decl(b"main").is_some() {
+        let args = format!("main {}", args.join(" "));
+
+        if !eval_source(
+            engine_state,
+            stack,
+            &file,
+            &path,
+            PipelineData::new(Span::new(0, 0)),
+        ) {
+            std::process::exit(1);
+        }
+        if !eval_source(engine_state, stack, args.as_bytes(), "<commandline>", input) {
+            std::process::exit(1);
+        }
+    } else if !eval_source(engine_state, stack, &file, &path, input) {
+        std::process::exit(1);
+    }
+
+    if is_perf_true {
+        info!("evaluate {}:{}:{}", file!(), line!(), column!());
+    }
+
+    Ok(())
+}
+
+pub fn print_table_or_error(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    mut pipeline_data: PipelineData,
+    config: &Config,
+) {
+    let exit_code = match &mut pipeline_data {
+        PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
+        _ => None,
+    };
+
+    match engine_state.find_decl("table".as_bytes()) {
+        Some(decl_id) => {
+            let table = engine_state.get_decl(decl_id).run(
+                engine_state,
+                stack,
+                &Call::new(Span::new(0, 0)),
+                pipeline_data,
+            );
+
+            match table {
+                Ok(table) => {
+                    for item in table {
+                        let stdout = std::io::stdout();
+
+                        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');
+
+                        match stdout.lock().write_all(out.as_bytes()) {
+                            Ok(_) => (),
+                            Err(err) => eprintln!("{}", err),
+                        };
+                    }
+                }
+                Err(error) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+
+                    report_error(&working_set, &error);
+
+                    std::process::exit(1);
+                }
+            }
+        }
+        None => {
+            for item in pipeline_data {
+                let stdout = std::io::stdout();
+
+                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');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+    };
+
+    // Make sure everything has finished
+    if let Some(exit_code) = exit_code {
+        let _: Vec<_> = exit_code.into_iter().collect();
+    }
+}

crates/nu-cli/src/keybinding.rs

@@ -1,473 +0,0 @@
-use rustyline::{KeyCode as RustyKeyCode, Modifiers};
-use serde::{Deserialize, Serialize};
-
-pub fn convert_keyevent(key_event: KeyCode, modifiers: Option<Modifiers>) -> rustyline::KeyEvent {
-    match key_event {
-        KeyCode::UnknownEscSeq => convert_to_rl_keyevent(RustyKeyCode::UnknownEscSeq, modifiers),
-        KeyCode::Backspace => convert_to_rl_keyevent(RustyKeyCode::Backspace, modifiers),
-        KeyCode::BackTab => convert_to_rl_keyevent(RustyKeyCode::BackTab, modifiers),
-        KeyCode::BracketedPasteStart => {
-            convert_to_rl_keyevent(RustyKeyCode::BracketedPasteStart, modifiers)
-        }
-        KeyCode::BracketedPasteEnd => {
-            convert_to_rl_keyevent(RustyKeyCode::BracketedPasteEnd, modifiers)
-        }
-        KeyCode::Char(c) => convert_to_rl_keyevent(RustyKeyCode::Char(c), modifiers),
-        KeyCode::Delete => convert_to_rl_keyevent(RustyKeyCode::Delete, modifiers),
-        KeyCode::Down => convert_to_rl_keyevent(RustyKeyCode::Down, modifiers),
-        KeyCode::End => convert_to_rl_keyevent(RustyKeyCode::End, modifiers),
-        KeyCode::Enter => convert_to_rl_keyevent(RustyKeyCode::Enter, modifiers),
-        KeyCode::Esc => convert_to_rl_keyevent(RustyKeyCode::Esc, modifiers),
-        KeyCode::F(u) => convert_to_rl_keyevent(RustyKeyCode::F(u), modifiers),
-        KeyCode::Home => convert_to_rl_keyevent(RustyKeyCode::Home, modifiers),
-        KeyCode::Insert => convert_to_rl_keyevent(RustyKeyCode::Insert, modifiers),
-        KeyCode::Left => convert_to_rl_keyevent(RustyKeyCode::Left, modifiers),
-        KeyCode::Null => convert_to_rl_keyevent(RustyKeyCode::Null, modifiers),
-        KeyCode::PageDown => convert_to_rl_keyevent(RustyKeyCode::PageDown, modifiers),
-        KeyCode::PageUp => convert_to_rl_keyevent(RustyKeyCode::PageUp, modifiers),
-        KeyCode::Right => convert_to_rl_keyevent(RustyKeyCode::Right, modifiers),
-        KeyCode::Tab => convert_to_rl_keyevent(RustyKeyCode::Tab, modifiers),
-        KeyCode::Up => convert_to_rl_keyevent(RustyKeyCode::Up, modifiers),
-    }
-}
-
-fn convert_to_rl_keyevent(
-    key_code: RustyKeyCode,
-    modifier: Option<Modifiers>,
-) -> rustyline::KeyEvent {
-    rustyline::KeyEvent {
-        0: key_code,
-        1: modifier.unwrap_or(Modifiers::NONE),
-    }
-}
-
-fn convert_word(word: Word) -> rustyline::Word {
-    match word {
-        Word::Big => rustyline::Word::Big,
-        Word::Emacs => rustyline::Word::Emacs,
-        Word::Vi => rustyline::Word::Vi,
-    }
-}
-
-fn convert_at(at: At) -> rustyline::At {
-    match at {
-        At::AfterEnd => rustyline::At::AfterEnd,
-        At::BeforeEnd => rustyline::At::BeforeEnd,
-        At::Start => rustyline::At::Start,
-    }
-}
-
-fn convert_char_search(search: CharSearch) -> rustyline::CharSearch {
-    match search {
-        CharSearch::Backward(c) => rustyline::CharSearch::Backward(c),
-        CharSearch::BackwardAfter(c) => rustyline::CharSearch::BackwardAfter(c),
-        CharSearch::Forward(c) => rustyline::CharSearch::Forward(c),
-        CharSearch::ForwardBefore(c) => rustyline::CharSearch::ForwardBefore(c),
-    }
-}
-
-fn convert_movement(movement: Movement) -> rustyline::Movement {
-    match movement {
-        Movement::BackwardChar(u) => rustyline::Movement::BackwardChar(u),
-        Movement::BackwardWord { repeat, word } => {
-            rustyline::Movement::BackwardWord(repeat, convert_word(word))
-        }
-        Movement::BeginningOfBuffer => rustyline::Movement::BeginningOfBuffer,
-        Movement::BeginningOfLine => rustyline::Movement::BeginningOfLine,
-        Movement::EndOfBuffer => rustyline::Movement::EndOfBuffer,
-        Movement::EndOfLine => rustyline::Movement::EndOfLine,
-        Movement::ForwardChar(u) => rustyline::Movement::ForwardChar(u),
-        Movement::ForwardWord { repeat, at, word } => {
-            rustyline::Movement::ForwardWord(repeat, convert_at(at), convert_word(word))
-        }
-        Movement::LineDown(u) => rustyline::Movement::LineDown(u),
-        Movement::LineUp(u) => rustyline::Movement::LineUp(u),
-        Movement::ViCharSearch { repeat, search } => {
-            rustyline::Movement::ViCharSearch(repeat, convert_char_search(search))
-        }
-        Movement::ViFirstPrint => rustyline::Movement::ViFirstPrint,
-        Movement::WholeBuffer => rustyline::Movement::WholeBuffer,
-        Movement::WholeLine => rustyline::Movement::WholeLine,
-    }
-}
-
-fn convert_anchor(anchor: Anchor) -> rustyline::Anchor {
-    match anchor {
-        Anchor::After => rustyline::Anchor::After,
-        Anchor::Before => rustyline::Anchor::Before,
-    }
-}
-
-fn convert_cmd(cmd: Cmd) -> rustyline::Cmd {
-    match cmd {
-        Cmd::Abort => rustyline::Cmd::Abort,
-        Cmd::AcceptLine => rustyline::Cmd::AcceptLine,
-        Cmd::AcceptOrInsertLine => rustyline::Cmd::AcceptOrInsertLine {
-            accept_in_the_middle: false,
-        },
-        Cmd::BeginningOfHistory => rustyline::Cmd::BeginningOfHistory,
-        Cmd::CapitalizeWord => rustyline::Cmd::CapitalizeWord,
-        Cmd::ClearScreen => rustyline::Cmd::ClearScreen,
-        Cmd::Complete => rustyline::Cmd::Complete,
-        Cmd::CompleteBackward => rustyline::Cmd::CompleteBackward,
-        Cmd::CompleteHint => rustyline::Cmd::CompleteHint,
-        Cmd::Dedent(movement) => rustyline::Cmd::Dedent(convert_movement(movement)),
-        Cmd::DowncaseWord => rustyline::Cmd::DowncaseWord,
-        Cmd::EndOfFile => rustyline::Cmd::EndOfFile,
-        Cmd::EndOfHistory => rustyline::Cmd::EndOfHistory,
-        Cmd::ForwardSearchHistory => rustyline::Cmd::ForwardSearchHistory,
-        Cmd::HistorySearchBackward => rustyline::Cmd::HistorySearchBackward,
-        Cmd::HistorySearchForward => rustyline::Cmd::HistorySearchForward,
-        Cmd::Indent(movement) => rustyline::Cmd::Indent(convert_movement(movement)),
-        Cmd::Insert { repeat, string } => rustyline::Cmd::Insert(repeat, string),
-        Cmd::Interrupt => rustyline::Cmd::Interrupt,
-        Cmd::Kill(movement) => rustyline::Cmd::Kill(convert_movement(movement)),
-        Cmd::LineDownOrNextHistory(u) => rustyline::Cmd::LineDownOrNextHistory(u),
-        Cmd::LineUpOrPreviousHistory(u) => rustyline::Cmd::LineUpOrPreviousHistory(u),
-        Cmd::Move(movement) => rustyline::Cmd::Move(convert_movement(movement)),
-        Cmd::NextHistory => rustyline::Cmd::NextHistory,
-        Cmd::Newline => rustyline::Cmd::Newline,
-        Cmd::Noop => rustyline::Cmd::Noop,
-        Cmd::Overwrite(c) => rustyline::Cmd::Overwrite(c),
-        #[cfg(windows)]
-        Cmd::PasteFromClipboard => rustyline::Cmd::PasteFromClipboard,
-        Cmd::PreviousHistory => rustyline::Cmd::PreviousHistory,
-        Cmd::QuotedInsert => rustyline::Cmd::QuotedInsert,
-        Cmd::Replace {
-            movement,
-            replacement,
-        } => rustyline::Cmd::Replace(convert_movement(movement), replacement),
-        Cmd::ReplaceChar { repeat, ch } => rustyline::Cmd::ReplaceChar(repeat, ch),
-        Cmd::ReverseSearchHistory => rustyline::Cmd::ReverseSearchHistory,
-        Cmd::SelfInsert { repeat, ch } => rustyline::Cmd::SelfInsert(repeat, ch),
-        Cmd::Suspend => rustyline::Cmd::Suspend,
-        Cmd::TransposeChars => rustyline::Cmd::TransposeChars,
-        Cmd::TransposeWords(u) => rustyline::Cmd::TransposeWords(u),
-        Cmd::Undo(u) => rustyline::Cmd::Undo(u),
-        Cmd::Unknown => rustyline::Cmd::Unknown,
-        Cmd::UpcaseWord => rustyline::Cmd::UpcaseWord,
-        Cmd::ViYankTo(movement) => rustyline::Cmd::ViYankTo(convert_movement(movement)),
-        Cmd::Yank { repeat, anchor } => rustyline::Cmd::Yank(repeat, convert_anchor(anchor)),
-        Cmd::YankPop => rustyline::Cmd::YankPop,
-    }
-}
-
-fn convert_keybinding(keybinding: Keybinding) -> (rustyline::KeyEvent, rustyline::Cmd) {
-    let rusty_modifiers = match keybinding.modifiers {
-        Some(mods) => match mods {
-            NuModifiers::Ctrl => Some(Modifiers::CTRL),
-            NuModifiers::Alt => Some(Modifiers::ALT),
-            NuModifiers::Shift => Some(Modifiers::SHIFT),
-            NuModifiers::None => Some(Modifiers::NONE),
-            NuModifiers::CtrlShift => Some(Modifiers::CTRL_SHIFT),
-            NuModifiers::AltShift => Some(Modifiers::ALT_SHIFT),
-            NuModifiers::CtrlAlt => Some(Modifiers::CTRL_ALT),
-            NuModifiers::CtrlAltShift => Some(Modifiers::CTRL_ALT_SHIFT),
-            // _ => None,
-        },
-        None => None,
-    };
-    (
-        convert_keyevent(keybinding.key, rusty_modifiers),
-        convert_cmd(keybinding.binding),
-    )
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum KeyCode {
-    /// Unsupported escape sequence (on unix platform)
-    UnknownEscSeq,
-    /// ⌫ or `KeyEvent::Ctrl('H')`
-    Backspace,
-    /// ⇤ (usually Shift-Tab)
-    BackTab,
-    /// Paste (on unix platform)
-    BracketedPasteStart,
-    /// Paste (on unix platform)
-    BracketedPasteEnd,
-    /// Single char
-    Char(char),
-    /// ⌦
-    Delete,
-    /// ↓ arrow key
-    Down,
-    /// ⇲
-    End,
-    /// ↵ or `KeyEvent::Ctrl('M')`
-    Enter,
-    /// Escape or `KeyEvent::Ctrl('[')`
-    Esc,
-    /// Function key
-    F(u8),
-    /// ⇱
-    Home,
-    /// Insert key
-    Insert,
-    /// ← arrow key
-    Left,
-    // /// `KeyEvent::Char('\0')`
-    Null,
-    /// ⇟
-    PageDown,
-    /// ⇞
-    PageUp,
-    /// → arrow key
-    Right,
-    /// ⇥ or `KeyEvent::Ctrl('I')`
-    Tab,
-    /// ↑ arrow key
-    Up,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum Cmd {
-    /// abort
-    Abort, // Miscellaneous Command
-    /// accept-line
-    AcceptLine,
-    /// beginning-of-history
-    BeginningOfHistory,
-    /// capitalize-word
-    CapitalizeWord,
-    /// clear-screen
-    ClearScreen,
-    /// complete
-    Complete,
-    /// complete-backward
-    CompleteBackward,
-    /// complete-hint
-    CompleteHint,
-    /// Dedent current line
-    Dedent(Movement),
-    /// downcase-word
-    DowncaseWord,
-    /// vi-eof-maybe
-    EndOfFile,
-    /// end-of-history
-    EndOfHistory,
-    /// forward-search-history
-    ForwardSearchHistory,
-    /// history-search-backward
-    HistorySearchBackward,
-    /// history-search-forward
-    HistorySearchForward,
-    /// Indent current line
-    Indent(Movement),
-    /// Insert text
-    Insert { repeat: RepeatCount, string: String },
-    /// Interrupt signal (Ctrl-C)
-    Interrupt,
-    /// backward-delete-char, backward-kill-line, backward-kill-word
-    /// delete-char, kill-line, kill-word, unix-line-discard, unix-word-rubout,
-    /// vi-delete, vi-delete-to, vi-rubout
-    Kill(Movement),
-    /// backward-char, backward-word, beginning-of-line, end-of-line,
-    /// forward-char, forward-word, vi-char-search, vi-end-word, vi-next-word,
-    /// vi-prev-word
-    Move(Movement),
-    /// Inserts a newline
-    Newline,
-    /// next-history
-    NextHistory,
-    /// No action
-    Noop,
-    /// vi-replace
-    Overwrite(char),
-    /// Paste from the clipboard
-    #[cfg(windows)]
-    PasteFromClipboard,
-    /// previous-history
-    PreviousHistory,
-    /// quoted-insert
-    QuotedInsert,
-    /// vi-change-char
-    ReplaceChar { repeat: RepeatCount, ch: char },
-    /// vi-change-to, vi-substitute
-    Replace {
-        movement: Movement,
-        replacement: Option<String>,
-    },
-    /// reverse-search-history
-    ReverseSearchHistory,
-    /// self-insert
-    SelfInsert { repeat: RepeatCount, ch: char },
-    /// Suspend signal (Ctrl-Z on unix platform)
-    Suspend,
-    /// transpose-chars
-    TransposeChars,
-    /// transpose-words
-    TransposeWords(RepeatCount),
-    /// undo
-    Undo(RepeatCount),
-    /// Unsupported / unexpected
-    Unknown,
-    /// upcase-word
-    UpcaseWord,
-    /// vi-yank-to
-    ViYankTo(Movement),
-    /// yank, vi-put
-    Yank { repeat: RepeatCount, anchor: Anchor },
-    /// yank-pop
-    YankPop,
-    /// moves cursor to the line above or switches to prev history entry if
-    /// the cursor is already on the first line
-    LineUpOrPreviousHistory(RepeatCount),
-    /// moves cursor to the line below or switches to next history entry if
-    /// the cursor is already on the last line
-    LineDownOrNextHistory(RepeatCount),
-    /// accepts the line when cursor is at the end of the text (non including
-    /// trailing whitespace), inserts newline character otherwise
-    AcceptOrInsertLine,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum Movement {
-    /// Whole current line (not really a movement but a range)
-    WholeLine,
-    /// beginning-of-line
-    BeginningOfLine,
-    /// end-of-line
-    EndOfLine,
-    /// backward-word, vi-prev-word
-    BackwardWord { repeat: RepeatCount, word: Word }, // Backward until start of word
-    /// forward-word, vi-end-word, vi-next-word
-    ForwardWord {
-        repeat: RepeatCount,
-        at: At,
-        word: Word,
-    }, // Forward until start/end of word
-    /// vi-char-search
-    ViCharSearch {
-        repeat: RepeatCount,
-        search: CharSearch,
-    },
-    /// vi-first-print
-    ViFirstPrint,
-    /// backward-char
-    BackwardChar(RepeatCount),
-    /// forward-char
-    ForwardChar(RepeatCount),
-    /// move to the same column on the previous line
-    LineUp(RepeatCount),
-    /// move to the same column on the next line
-    LineDown(RepeatCount),
-    /// Whole user input (not really a movement but a range)
-    WholeBuffer,
-    /// beginning-of-buffer
-    BeginningOfBuffer,
-    /// end-of-buffer
-    EndOfBuffer,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-enum InputMode {
-    /// Vi Command/Alternate
-    Command,
-    /// Insert/Input mode
-    Insert,
-    /// Overwrite mode
-    Replace,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum Word {
-    /// non-blanks characters
-    Big,
-    /// alphanumeric characters
-    Emacs,
-    /// alphanumeric (and '_') characters
-    Vi,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum At {
-    /// Start of word.
-    Start,
-    /// Before end of word.
-    BeforeEnd,
-    /// After end of word.
-    AfterEnd,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum Anchor {
-    /// After cursor
-    After,
-    /// Before cursor
-    Before,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum CharSearch {
-    /// Forward search
-    Forward(char),
-    /// Forward search until
-    ForwardBefore(char),
-    /// Backward search
-    Backward(char),
-    /// Backward search until
-    BackwardAfter(char),
-}
-
-/// The set of modifier keys that were triggered along with a key press.
-#[derive(Debug, Serialize, Deserialize)]
-#[allow(non_camel_case_types)]
-pub enum NuModifiers {
-    /// Control modifier
-    #[serde(alias = "CTRL")]
-    Ctrl = 8,
-    /// Escape or Alt modifier
-    #[serde(alias = "ALT")]
-    Alt = 4,
-    /// Shift modifier
-    #[serde(alias = "SHIFT")]
-    Shift = 2,
-    /// No modifier
-    #[serde(alias = "NONE")]
-    None = 0,
-    /// Ctrl + Shift
-    #[serde(alias = "CTRL_SHIFT")]
-    CtrlShift = 10,
-    /// Alt + Shift
-    #[serde(alias = "ALT_SHIFT")]
-    AltShift = 6,
-    /// Ctrl + Alt
-    #[serde(alias = "CTRL_ALT")]
-    CtrlAlt = 12,
-    /// Ctrl + Alt + Shift
-    #[serde(alias = "CTRL_ALT_SHIFT")]
-    CtrlAltShift = 14,
-}
-
-/// The number of times one command should be repeated.
-pub type RepeatCount = usize;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Keybinding {
-    key: KeyCode,
-    modifiers: Option<NuModifiers>,
-    binding: Cmd,
-}
-
-type Keybindings = Vec<Keybinding>;
-
-pub(crate) fn load_keybindings(
-    rl: &mut rustyline::Editor<crate::shell::Helper>,
-) -> Result<(), nu_errors::ShellError> {
-    let filename = nu_data::keybinding::keybinding_path()?;
-    let contents = std::fs::read_to_string(filename);
-
-    // Silently fail if there is no file there
-    if let Ok(contents) = contents {
-        let keybindings: Keybindings = serde_yaml::from_str(&contents)?;
-        // eprintln!("{:#?}", keybindings);
-        for keybinding in keybindings.into_iter() {
-            let (k, b) = convert_keybinding(keybinding);
-            // eprintln!("{:?} {:?}", k, b);
-
-            rl.bind_sequence(k, b);
-        }
-    }
-
-    Ok(())
-}

crates/nu-cli/src/lib.rs

@@ -1,15 +1,35 @@
-pub mod app;
-mod cli;
-#[cfg(feature = "rustyline-support")]
-mod keybinding;
-mod line_editor;
-#[cfg(feature = "rustyline-support")]
-mod shell;
+mod commands;
+mod completions;
+mod config_files;
+mod errors;
+mod eval_file;
+mod menus;
+mod nu_highlight;
+mod print;
+mod prompt;
+mod prompt_update;
+mod reedline_config;
+mod repl;
+mod syntax_highlight;
+mod util;
+mod validation;
 
-#[cfg(feature = "rustyline-support")]
-pub use crate::cli::cli;
+pub use commands::evaluate_commands;
+pub use completions::NuCompleter;
+pub use config_files::eval_config_contents;
+pub use errors::CliError;
+pub use eval_file::evaluate_file;
+pub use menus::{DescriptionMenu, NuHelpCompleter};
+pub use nu_highlight::NuHighlight;
+pub use print::Print;
+pub use prompt::NushellPrompt;
+pub use repl::evaluate_repl;
+pub use syntax_highlight::NuHighlighter;
+pub use util::print_pipeline_data;
+pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error};
+pub use validation::NuValidator;
 
-pub use crate::app::App;
-pub use crate::cli::{parse_and_eval, register_plugins, run_script_file};
-
-pub use nu_command::create_default_context;
+#[cfg(feature = "plugin")]
+pub use config_files::add_plugin_file;
+#[cfg(feature = "plugin")]
+pub use config_files::read_plugin_file;

crates/nu-cli/src/line_editor.rs

@@ -1,274 +0,0 @@
-use nu_engine::EvaluationContext;
-use nu_errors::ShellError;
-use std::error::Error;
-
-#[allow(unused_imports)]
-use std::sync::atomic::Ordering;
-
-#[allow(unused_imports)]
-use nu_engine::script::LineResult;
-
-#[cfg(feature = "rustyline-support")]
-use crate::keybinding::{convert_keyevent, KeyCode};
-
-#[cfg(feature = "rustyline-support")]
-use crate::shell::Helper;
-
-#[cfg(feature = "rustyline-support")]
-use rustyline::{
-    self,
-    config::Configurer,
-    config::{ColorMode, CompletionType, Config},
-    error::ReadlineError,
-    line_buffer::LineBuffer,
-    At, Cmd, ConditionalEventHandler, Editor, EventHandler, Modifiers, Movement, Word,
-};
-
-#[cfg(feature = "rustyline-support")]
-pub fn convert_rustyline_result_to_string(input: Result<String, ReadlineError>) -> LineResult {
-    match input {
-        Ok(s) if s == "history -c" || s == "history --clear" => LineResult::ClearHistory,
-        Ok(s) => LineResult::Success(s),
-        Err(ReadlineError::Interrupted) => LineResult::CtrlC,
-        Err(ReadlineError::Eof) => LineResult::CtrlD,
-        Err(err) => {
-            eprintln!("Error: {:?}", err);
-            LineResult::Break
-        }
-    }
-}
-
-#[derive(Clone)]
-#[cfg(feature = "rustyline-support")]
-struct PartialCompleteHintHandler;
-
-#[cfg(feature = "rustyline-support")]
-impl ConditionalEventHandler for PartialCompleteHintHandler {
-    fn handle(
-        &self,
-        _evt: &rustyline::Event,
-        _n: rustyline::RepeatCount,
-        _positive: bool,
-        ctx: &rustyline::EventContext,
-    ) -> Option<Cmd> {
-        Some(match ctx.hint_text() {
-            Some(hint_text) if ctx.pos() == ctx.line().len() => {
-                let mut line_buffer = LineBuffer::with_capacity(hint_text.len());
-                line_buffer.update(hint_text, 0);
-                line_buffer.move_to_next_word(At::AfterEnd, Word::Vi, 1);
-
-                let text = hint_text[0..line_buffer.pos()].to_string();
-
-                Cmd::Insert(1, text)
-            }
-            _ => Cmd::Move(Movement::ForwardWord(1, At::AfterEnd, Word::Vi)),
-        })
-    }
-}
-
-#[cfg(feature = "rustyline-support")]
-pub fn default_rustyline_editor_configuration() -> Editor<Helper> {
-    #[cfg(windows)]
-    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::Circular;
-    #[cfg(not(windows))]
-    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::List;
-
-    let config = Config::builder()
-        .check_cursor_position(true)
-        .color_mode(ColorMode::Forced)
-        .build();
-    let mut rl: Editor<_> = Editor::with_config(config);
-
-    // add key bindings to move over a whole word with Ctrl+ArrowLeft and Ctrl+ArrowRight
-    //M modifier, E KeyEvent, K KeyCode
-    rl.bind_sequence(
-        convert_keyevent(KeyCode::Left, Some(Modifiers::CTRL)),
-        Cmd::Move(Movement::BackwardWord(1, Word::Vi)),
-    );
-
-    rl.bind_sequence(
-        convert_keyevent(KeyCode::Right, Some(Modifiers::CTRL)),
-        EventHandler::Conditional(Box::new(PartialCompleteHintHandler)),
-    );
-
-    // workaround for multiline-paste hang in rustyline (see https://github.com/kkawakam/rustyline/issues/202)
-    rl.bind_sequence(
-        convert_keyevent(KeyCode::BracketedPasteStart, None),
-        rustyline::Cmd::Noop,
-    );
-    // Let's set the defaults up front and then override them later if the user indicates
-    // defaults taken from here https://github.com/kkawakam/rustyline/blob/2fe886c9576c1ea13ca0e5808053ad491a6fe049/src/config.rs#L150-L167
-    rl.set_max_history_size(100);
-    rl.set_history_ignore_dups(true);
-    rl.set_history_ignore_space(false);
-    rl.set_completion_type(DEFAULT_COMPLETION_MODE);
-    rl.set_completion_prompt_limit(100);
-    rl.set_keyseq_timeout(-1);
-    rl.set_edit_mode(rustyline::config::EditMode::Emacs);
-    rl.set_auto_add_history(false);
-    rl.set_bell_style(rustyline::config::BellStyle::default());
-    rl.set_color_mode(rustyline::ColorMode::Enabled);
-    rl.set_tab_stop(8);
-
-    if let Err(e) = crate::keybinding::load_keybindings(&mut rl) {
-        println!("Error loading keybindings: {:?}", e);
-    }
-
-    rl
-}
-
-#[cfg(feature = "rustyline-support")]
-pub fn configure_rustyline_editor(
-    rl: &mut Editor<Helper>,
-    config: &dyn nu_data::config::Conf,
-) -> Result<(), ShellError> {
-    #[cfg(windows)]
-    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::Circular;
-    #[cfg(not(windows))]
-    const DEFAULT_COMPLETION_MODE: CompletionType = CompletionType::List;
-
-    if let Some(line_editor_vars) = config.var("line_editor") {
-        for (idx, value) in line_editor_vars.row_entries() {
-            match idx.as_ref() {
-                "max_history_size" => {
-                    if let Ok(max_history_size) = value.as_u64() {
-                        rl.set_max_history_size(max_history_size as usize);
-                    }
-                }
-                "history_duplicates" => {
-                    // history_duplicates = match value.as_string() {
-                    //     Ok(s) if s.to_lowercase() == "alwaysadd" => {
-                    //         rustyline::config::HistoryDuplicates::AlwaysAdd
-                    //     }
-                    //     Ok(s) if s.to_lowercase() == "ignoreconsecutive" => {
-                    //         rustyline::config::HistoryDuplicates::IgnoreConsecutive
-                    //     }
-                    //     _ => rustyline::config::HistoryDuplicates::AlwaysAdd,
-                    // };
-                    if let Ok(history_duplicates) = value.as_bool() {
-                        rl.set_history_ignore_dups(history_duplicates);
-                    }
-                }
-                "history_ignore_space" => {
-                    if let Ok(history_ignore_space) = value.as_bool() {
-                        rl.set_history_ignore_space(history_ignore_space);
-                    }
-                }
-                "completion_type" => {
-                    let completion_type = match value.as_string() {
-                        Ok(s) if s.to_lowercase() == "circular" => {
-                            rustyline::config::CompletionType::Circular
-                        }
-                        Ok(s) if s.to_lowercase() == "list" => {
-                            rustyline::config::CompletionType::List
-                        }
-                        #[cfg(all(unix, feature = "with-fuzzy"))]
-                        Ok(s) if s.to_lowercase() == "fuzzy" => {
-                            rustyline::config::CompletionType::Fuzzy
-                        }
-                        _ => DEFAULT_COMPLETION_MODE,
-                    };
-                    rl.set_completion_type(completion_type);
-                }
-                "completion_prompt_limit" => {
-                    if let Ok(completion_prompt_limit) = value.as_u64() {
-                        rl.set_completion_prompt_limit(completion_prompt_limit as usize);
-                    }
-                }
-                "keyseq_timeout_ms" => {
-                    if let Ok(keyseq_timeout_ms) = value.as_u64() {
-                        rl.set_keyseq_timeout(keyseq_timeout_ms as i32);
-                    }
-                }
-                "edit_mode" => {
-                    let edit_mode = match value.as_string() {
-                        Ok(s) if s.to_lowercase() == "vi" => rustyline::config::EditMode::Vi,
-                        Ok(s) if s.to_lowercase() == "emacs" => rustyline::config::EditMode::Emacs,
-                        _ => rustyline::config::EditMode::Emacs,
-                    };
-                    rl.set_edit_mode(edit_mode);
-                    // Note: When edit_mode is Emacs, the keyseq_timeout_ms is set to -1
-                    // no matter what you may have configured. This is so that key chords
-                    // can be applied without having to do them in a given timeout. So,
-                    // it essentially turns off the keyseq timeout.
-                }
-                "auto_add_history" => {
-                    if let Ok(auto_add_history) = value.as_bool() {
-                        rl.set_auto_add_history(auto_add_history);
-                    }
-                }
-                "bell_style" => {
-                    let bell_style = match value.as_string() {
-                        Ok(s) if s.to_lowercase() == "audible" => {
-                            rustyline::config::BellStyle::Audible
-                        }
-                        Ok(s) if s.to_lowercase() == "none" => rustyline::config::BellStyle::None,
-                        Ok(s) if s.to_lowercase() == "visible" => {
-                            rustyline::config::BellStyle::Visible
-                        }
-                        _ => rustyline::config::BellStyle::default(),
-                    };
-                    rl.set_bell_style(bell_style);
-                }
-                "color_mode" => {
-                    let color_mode = match value.as_string() {
-                        Ok(s) if s.to_lowercase() == "enabled" => rustyline::ColorMode::Enabled,
-                        Ok(s) if s.to_lowercase() == "forced" => rustyline::ColorMode::Forced,
-                        Ok(s) if s.to_lowercase() == "disabled" => rustyline::ColorMode::Disabled,
-                        _ => rustyline::ColorMode::Enabled,
-                    };
-                    rl.set_color_mode(color_mode);
-                }
-                "tab_stop" => {
-                    if let Ok(tab_stop) = value.as_u64() {
-                        rl.set_tab_stop(tab_stop as usize);
-                    }
-                }
-                _ => (),
-            }
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(feature = "rustyline-support")]
-pub fn nu_line_editor_helper(
-    context: &EvaluationContext,
-    config: &dyn nu_data::config::Conf,
-) -> crate::shell::Helper {
-    let hinter = rustyline_hinter(config);
-    crate::shell::Helper::new(context.clone(), hinter)
-}
-
-#[cfg(feature = "rustyline-support")]
-pub fn rustyline_hinter(
-    config: &dyn nu_data::config::Conf,
-) -> Option<rustyline::hint::HistoryHinter> {
-    if let Some(line_editor_vars) = config.var("line_editor") {
-        for (idx, value) in line_editor_vars.row_entries() {
-            if idx == "show_hints" && value.as_bool() == Ok(false) {
-                return None;
-            }
-        }
-    }
-
-    Some(rustyline::hint::HistoryHinter {})
-}
-
-pub fn configure_ctrl_c(_context: &EvaluationContext) -> Result<(), Box<dyn Error>> {
-    #[cfg(feature = "ctrlc")]
-    {
-        let cc = _context.ctrl_c().clone();
-
-        ctrlc::set_handler(move || {
-            cc.store(true, Ordering::SeqCst);
-        })?;
-
-        if _context.ctrl_c().load(Ordering::SeqCst) {
-            _context.ctrl_c().store(false, Ordering::SeqCst);
-        }
-    }
-
-    Ok(())
-}

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

@@ -0,0 +1,724 @@
+use {
+    nu_ansi_term::{ansi::RESET, Style},
+    reedline::{
+        menu_functions::string_difference, Completer, LineBuffer, Menu, MenuEvent, MenuTextStyle,
+        Painter, Suggestion,
+    },
+};
+
+/// Default values used as reference for the menu. These values are set during
+/// the initial declaration of the menu and are always kept as reference for the
+/// changeable [`WorkingDetails`]
+struct DefaultMenuDetails {
+    /// Number of columns that the menu will have
+    pub columns: u16,
+    /// Column width
+    pub col_width: Option<usize>,
+    /// Column padding
+    pub col_padding: usize,
+    /// Number of rows for commands
+    pub selection_rows: u16,
+    /// Number of rows allowed to display the description
+    pub description_rows: usize,
+}
+
+impl Default for DefaultMenuDetails {
+    fn default() -> Self {
+        Self {
+            columns: 4,
+            col_width: None,
+            col_padding: 2,
+            selection_rows: 4,
+            description_rows: 10,
+        }
+    }
+}
+
+/// Represents the actual column conditions of the menu. These conditions change
+/// since they need to accommodate possible different line sizes for the column values
+#[derive(Default)]
+struct WorkingDetails {
+    /// Number of columns that the menu will have
+    pub columns: u16,
+    /// Column width
+    pub col_width: usize,
+    /// Number of rows for description
+    pub description_rows: usize,
+}
+
+/// Completion menu definition
+pub struct DescriptionMenu {
+    /// Menu name
+    name: String,
+    /// Menu status
+    active: bool,
+    /// Menu coloring
+    color: MenuTextStyle,
+    /// Default column details that are set when creating the menu
+    /// These values are the reference for the working details
+    default_details: DefaultMenuDetails,
+    /// Number of minimum rows that are displayed when
+    /// the required lines is larger than the available lines
+    min_rows: u16,
+    /// Working column details keep changing based on the collected values
+    working_details: WorkingDetails,
+    /// Menu cached values
+    values: Vec<Suggestion>,
+    /// column position of the cursor. Starts from 0
+    col_pos: u16,
+    /// row position in the menu. Starts from 0
+    row_pos: u16,
+    /// Menu marker when active
+    marker: String,
+    /// Event sent to the menu
+    event: Option<MenuEvent>,
+    /// String collected after the menu is activated
+    input: Option<String>,
+    /// Examples to select
+    examples: Vec<String>,
+    /// Example index
+    example_index: Option<usize>,
+    /// Examples may not be shown if there is not enough space in the screen
+    show_examples: bool,
+    /// Skipped description rows
+    skipped_rows: usize,
+    /// Calls the completer using only the line buffer difference difference
+    /// after the menu was activated
+    only_buffer_difference: bool,
+}
+
+impl Default for DescriptionMenu {
+    fn default() -> Self {
+        Self {
+            name: "description_menu".to_string(),
+            active: false,
+            color: MenuTextStyle::default(),
+            default_details: DefaultMenuDetails::default(),
+            min_rows: 3,
+            working_details: WorkingDetails::default(),
+            values: Vec::new(),
+            col_pos: 0,
+            row_pos: 0,
+            marker: "? ".to_string(),
+            event: None,
+            input: None,
+            examples: Vec::new(),
+            example_index: None,
+            show_examples: true,
+            skipped_rows: 0,
+            only_buffer_difference: true,
+        }
+    }
+}
+
+// Menu configuration
+impl DescriptionMenu {
+    /// Menu builder with new name
+    pub fn with_name(mut self, name: &str) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// Menu builder with new value for text style
+    pub fn with_text_style(mut self, text_style: Style) -> Self {
+        self.color.text_style = text_style;
+        self
+    }
+
+    /// Menu builder with new value for text style
+    pub fn with_selected_text_style(mut self, selected_text_style: Style) -> Self {
+        self.color.selected_text_style = selected_text_style;
+        self
+    }
+
+    /// Menu builder with new value for text style
+    pub fn with_description_text_style(mut self, description_text_style: Style) -> Self {
+        self.color.description_style = description_text_style;
+        self
+    }
+
+    /// Menu builder with new columns value
+    pub fn with_columns(mut self, columns: u16) -> Self {
+        self.default_details.columns = columns;
+        self
+    }
+
+    /// Menu builder with new column width value
+    pub fn with_column_width(mut self, col_width: Option<usize>) -> Self {
+        self.default_details.col_width = col_width;
+        self
+    }
+
+    /// Menu builder with new column width value
+    pub fn with_column_padding(mut self, col_padding: usize) -> Self {
+        self.default_details.col_padding = col_padding;
+        self
+    }
+
+    /// Menu builder with new selection rows value
+    pub fn with_selection_rows(mut self, selection_rows: u16) -> Self {
+        self.default_details.selection_rows = selection_rows;
+        self
+    }
+
+    /// Menu builder with new description rows value
+    pub fn with_description_rows(mut self, description_rows: usize) -> Self {
+        self.default_details.description_rows = description_rows;
+        self
+    }
+
+    /// Menu builder with marker
+    pub fn with_marker(mut self, marker: String) -> Self {
+        self.marker = marker;
+        self
+    }
+
+    /// Menu builder with new only buffer difference
+    pub fn with_only_buffer_difference(mut self, only_buffer_difference: bool) -> Self {
+        self.only_buffer_difference = only_buffer_difference;
+        self
+    }
+}
+
+// Menu functionality
+impl DescriptionMenu {
+    /// Move menu cursor to the next element
+    fn move_next(&mut self) {
+        let mut new_col = self.col_pos + 1;
+        let mut new_row = self.row_pos;
+
+        if new_col >= self.get_cols() {
+            new_row += 1;
+            new_col = 0;
+        }
+
+        if new_row >= self.get_rows() {
+            new_row = 0;
+            new_col = 0;
+        }
+
+        let position = new_row * self.get_cols() + new_col;
+        if position >= self.get_values().len() as u16 {
+            self.reset_position();
+        } else {
+            self.col_pos = new_col;
+            self.row_pos = new_row;
+        }
+    }
+
+    /// Move menu cursor to the previous element
+    fn move_previous(&mut self) {
+        let new_col = self.col_pos.checked_sub(1);
+
+        let (new_col, new_row) = match new_col {
+            Some(col) => (col, self.row_pos),
+            None => match self.row_pos.checked_sub(1) {
+                Some(row) => (self.get_cols().saturating_sub(1), row),
+                None => (
+                    self.get_cols().saturating_sub(1),
+                    self.get_rows().saturating_sub(1),
+                ),
+            },
+        };
+
+        let position = new_row * self.get_cols() + new_col;
+        if position >= self.get_values().len() as u16 {
+            self.col_pos = (self.get_values().len() as u16 % self.get_cols()).saturating_sub(1);
+            self.row_pos = self.get_rows().saturating_sub(1);
+        } else {
+            self.col_pos = new_col;
+            self.row_pos = new_row;
+        }
+    }
+
+    /// Menu index based on column and row position
+    fn index(&self) -> usize {
+        let index = self.row_pos * self.get_cols() + self.col_pos;
+        index as usize
+    }
+
+    /// Get selected value from the menu
+    fn get_value(&self) -> Option<Suggestion> {
+        self.get_values().get(self.index()).cloned()
+    }
+
+    /// Calculates how many rows the Menu will use
+    fn get_rows(&self) -> u16 {
+        let values = self.get_values().len() as u16;
+
+        if values == 0 {
+            // When the values are empty the no_records_msg is shown, taking 1 line
+            return 1;
+        }
+
+        let rows = values / self.get_cols();
+        if values % self.get_cols() != 0 {
+            rows + 1
+        } else {
+            rows
+        }
+    }
+
+    /// Returns working details col width
+    fn get_width(&self) -> usize {
+        self.working_details.col_width
+    }
+
+    /// Reset menu position
+    fn reset_position(&mut self) {
+        self.col_pos = 0;
+        self.row_pos = 0;
+        self.skipped_rows = 0;
+    }
+
+    fn no_records_msg(&self, use_ansi_coloring: bool) -> String {
+        let msg = "TYPE TO START SEACH";
+        if use_ansi_coloring {
+            format!(
+                "{}{}{}",
+                self.color.selected_text_style.prefix(),
+                msg,
+                RESET
+            )
+        } else {
+            msg.to_string()
+        }
+    }
+
+    /// Returns working details columns
+    fn get_cols(&self) -> u16 {
+        self.working_details.columns.max(1)
+    }
+
+    /// End of line for menu
+    fn end_of_line(&self, column: u16, index: usize) -> &str {
+        let is_last = index == self.values.len().saturating_sub(1);
+        if column == self.get_cols().saturating_sub(1) || is_last {
+            "\r\n"
+        } else {
+            ""
+        }
+    }
+
+    /// Update list of examples from the actual value
+    fn update_examples(&mut self) {
+        self.examples = self
+            .get_value()
+            .and_then(|suggestion| suggestion.extra)
+            .unwrap_or_default();
+
+        self.example_index = None;
+    }
+
+    /// Creates default string that represents one suggestion from the menu
+    fn create_entry_string(
+        &self,
+        suggestion: &Suggestion,
+        index: usize,
+        column: u16,
+        empty_space: usize,
+        use_ansi_coloring: bool,
+    ) -> String {
+        if use_ansi_coloring {
+            if index == self.index() {
+                format!(
+                    "{}{}{}{:>empty$}{}",
+                    self.color.selected_text_style.prefix(),
+                    &suggestion.value,
+                    RESET,
+                    "",
+                    self.end_of_line(column, index),
+                    empty = empty_space,
+                )
+            } else {
+                format!(
+                    "{}{}{}{:>empty$}{}",
+                    self.color.text_style.prefix(),
+                    &suggestion.value,
+                    RESET,
+                    "",
+                    self.end_of_line(column, index),
+                    empty = empty_space,
+                )
+            }
+        } else {
+            // If no ansi coloring is found, then the selection word is
+            // the line in uppercase
+            let (marker, empty_space) = if index == self.index() {
+                (">", empty_space.saturating_sub(1))
+            } else {
+                ("", empty_space)
+            };
+
+            let line = format!(
+                "{}{}{:>empty$}{}",
+                marker,
+                &suggestion.value,
+                "",
+                self.end_of_line(column, index),
+                empty = empty_space,
+            );
+
+            if index == self.index() {
+                line.to_uppercase()
+            } else {
+                line
+            }
+        }
+    }
+
+    /// Description string with color
+    fn create_description_string(&self, use_ansi_coloring: bool) -> String {
+        let description = self
+            .get_value()
+            .and_then(|suggestion| suggestion.description)
+            .unwrap_or_else(|| "".to_string())
+            .lines()
+            .skip(self.skipped_rows)
+            .take(self.working_details.description_rows)
+            .collect::<Vec<&str>>()
+            .join("\r\n");
+
+        if use_ansi_coloring && !description.is_empty() {
+            format!(
+                "{}{}{}",
+                self.color.description_style.prefix(),
+                description,
+                RESET,
+            )
+        } else {
+            description
+        }
+    }
+
+    /// Selectable list of examples from the actual value
+    fn create_example_string(&self, use_ansi_coloring: bool) -> String {
+        if !self.show_examples {
+            return "".into();
+        }
+
+        let examples: String = self
+            .examples
+            .iter()
+            .enumerate()
+            .map(|(index, example)| {
+                if let Some(example_index) = self.example_index {
+                    if index == example_index {
+                        format!(
+                            "  {}{}{}\r\n",
+                            self.color.selected_text_style.prefix(),
+                            example,
+                            RESET
+                        )
+                    } else {
+                        format!("  {}\r\n", example)
+                    }
+                } else {
+                    format!("  {}\r\n", example)
+                }
+            })
+            .collect();
+
+        if examples.is_empty() {
+            "".into()
+        } else if use_ansi_coloring {
+            format!(
+                "{}\r\n\r\nExamples:\r\n{}{}",
+                self.color.description_style.prefix(),
+                RESET,
+                examples,
+            )
+        } else {
+            format!("\r\n\r\nExamples:\r\n{}", examples,)
+        }
+    }
+}
+
+impl Menu for DescriptionMenu {
+    /// Menu name
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    /// Menu indicator
+    fn indicator(&self) -> &str {
+        self.marker.as_str()
+    }
+
+    /// Deactivates context menu
+    fn is_active(&self) -> bool {
+        self.active
+    }
+
+    /// The menu stays active even with one record
+    fn can_quick_complete(&self) -> bool {
+        false
+    }
+
+    /// The menu does not need to partially complete
+    fn can_partially_complete(
+        &mut self,
+        _values_updated: bool,
+        _line_buffer: &mut LineBuffer,
+        _completer: &mut dyn Completer,
+    ) -> bool {
+        false
+    }
+
+    /// Selects what type of event happened with the menu
+    fn menu_event(&mut self, event: MenuEvent) {
+        match &event {
+            MenuEvent::Activate(_) => self.active = true,
+            MenuEvent::Deactivate => {
+                self.active = false;
+                self.input = None;
+                self.values = Vec::new();
+            }
+            _ => {}
+        };
+
+        self.event = Some(event);
+    }
+
+    /// Updates menu values
+    fn update_values(&mut self, line_buffer: &mut LineBuffer, completer: &mut dyn Completer) {
+        if self.only_buffer_difference {
+            if let Some(old_string) = &self.input {
+                let (start, input) = string_difference(line_buffer.get_buffer(), old_string);
+                if !input.is_empty() {
+                    self.reset_position();
+                    self.values = completer.complete(input, start);
+                }
+            }
+        } else {
+            let trimmed_buffer = line_buffer.get_buffer().replace('\n', " ");
+            self.values =
+                completer.complete(trimmed_buffer.as_str(), line_buffer.insertion_point());
+            self.reset_position();
+        }
+    }
+
+    /// The working details for the menu changes based on the size of the lines
+    /// collected from the completer
+    fn update_working_details(
+        &mut self,
+        line_buffer: &mut LineBuffer,
+        completer: &mut dyn Completer,
+        painter: &Painter,
+    ) {
+        if let Some(event) = self.event.take() {
+            // Updating all working parameters from the menu before executing any of the
+            // possible event
+            let max_width = self.get_values().iter().fold(0, |acc, suggestion| {
+                let str_len = suggestion.value.len() + self.default_details.col_padding;
+                if str_len > acc {
+                    str_len
+                } else {
+                    acc
+                }
+            });
+
+            // If no default width is found, then the total screen width is used to estimate
+            // the column width based on the default number of columns
+            let default_width = if let Some(col_width) = self.default_details.col_width {
+                col_width
+            } else {
+                let col_width = painter.screen_width() / self.default_details.columns;
+                col_width as usize
+            };
+
+            // Adjusting the working width of the column based the max line width found
+            // in the menu values
+            if max_width > default_width {
+                self.working_details.col_width = max_width;
+            } else {
+                self.working_details.col_width = default_width;
+            };
+
+            // The working columns is adjusted based on possible number of columns
+            // that could be fitted in the screen with the calculated column width
+            let possible_cols = painter.screen_width() / self.working_details.col_width as u16;
+            if possible_cols > self.default_details.columns {
+                self.working_details.columns = self.default_details.columns.max(1);
+            } else {
+                self.working_details.columns = possible_cols;
+            }
+
+            // Updating the working rows to display the description
+            if self.menu_required_lines(painter.screen_width()) <= painter.remaining_lines() {
+                self.working_details.description_rows = self.default_details.description_rows;
+                self.show_examples = true;
+            } else {
+                self.working_details.description_rows = painter
+                    .remaining_lines()
+                    .saturating_sub(self.default_details.selection_rows + 1)
+                    as usize;
+
+                self.show_examples = false;
+            }
+
+            match event {
+                MenuEvent::Activate(_) => {
+                    self.reset_position();
+                    self.input = Some(line_buffer.get_buffer().to_string());
+                    self.update_values(line_buffer, completer);
+                }
+                MenuEvent::Deactivate => self.active = false,
+                MenuEvent::Edit(_) => {
+                    self.reset_position();
+                    self.update_values(line_buffer, completer);
+                    self.update_examples()
+                }
+                MenuEvent::NextElement => {
+                    self.skipped_rows = 0;
+                    self.move_next();
+                    self.update_examples();
+                }
+                MenuEvent::PreviousElement => {
+                    self.skipped_rows = 0;
+                    self.move_previous();
+                    self.update_examples();
+                }
+                MenuEvent::MoveUp => {
+                    if let Some(example_index) = self.example_index {
+                        if let Some(index) = example_index.checked_sub(1) {
+                            self.example_index = Some(index);
+                        } else {
+                            self.example_index = Some(self.examples.len().saturating_sub(1));
+                        }
+                    } else {
+                        self.example_index = Some(0);
+                    }
+                }
+                MenuEvent::MoveDown => {
+                    if let Some(example_index) = self.example_index {
+                        let index = example_index + 1;
+                        if index < self.examples.len() {
+                            self.example_index = Some(index);
+                        } else {
+                            self.example_index = Some(0);
+                        }
+                    } else {
+                        self.example_index = Some(0);
+                    }
+                }
+                MenuEvent::MoveLeft => self.skipped_rows = self.skipped_rows.saturating_sub(1),
+                MenuEvent::MoveRight => {
+                    let skipped = self.skipped_rows + 1;
+                    let description_rows = self
+                        .get_value()
+                        .and_then(|suggestion| suggestion.description)
+                        .unwrap_or_else(|| "".to_string())
+                        .lines()
+                        .count();
+
+                    let allowed_skips =
+                        description_rows.saturating_sub(self.working_details.description_rows);
+
+                    if skipped < allowed_skips {
+                        self.skipped_rows = skipped;
+                    } else {
+                        self.skipped_rows = allowed_skips;
+                    }
+                }
+                MenuEvent::PreviousPage | MenuEvent::NextPage => {}
+            }
+        }
+    }
+
+    /// The buffer gets replaced in the Span location
+    fn replace_in_buffer(&self, line_buffer: &mut LineBuffer) {
+        if let Some(Suggestion { value, span, .. }) = self.get_value() {
+            let start = span.start.min(line_buffer.len());
+            let end = span.end.min(line_buffer.len());
+
+            let string_len = if let Some(example_index) = self.example_index {
+                let example = self
+                    .examples
+                    .get(example_index)
+                    .expect("the example index is always checked");
+
+                line_buffer.replace(start..end, example);
+                example.len()
+            } else {
+                line_buffer.replace(start..end, &value);
+                value.len()
+            };
+
+            let mut offset = line_buffer.insertion_point();
+            offset += string_len.saturating_sub(end.saturating_sub(start));
+            line_buffer.set_insertion_point(offset);
+        }
+    }
+
+    /// Minimum rows that should be displayed by the menu
+    fn min_rows(&self) -> u16 {
+        self.get_rows().min(self.min_rows)
+    }
+
+    /// Gets values from filler that will be displayed in the menu
+    fn get_values(&self) -> &[Suggestion] {
+        &self.values
+    }
+
+    fn menu_required_lines(&self, _terminal_columns: u16) -> u16 {
+        let example_lines = self
+            .examples
+            .iter()
+            .fold(0, |acc, example| example.lines().count() + acc);
+
+        self.default_details.selection_rows
+            + self.default_details.description_rows as u16
+            + example_lines as u16
+            + 3
+    }
+
+    fn menu_string(&self, _available_lines: u16, use_ansi_coloring: bool) -> String {
+        if self.get_values().is_empty() {
+            self.no_records_msg(use_ansi_coloring)
+        } else {
+            // The skip values represent the number of lines that should be skipped
+            // while printing the menu
+            let available_lines = self.default_details.selection_rows;
+            let skip_values = if self.row_pos >= available_lines {
+                let skip_lines = self.row_pos.saturating_sub(available_lines) + 1;
+                (skip_lines * self.get_cols()) as usize
+            } else {
+                0
+            };
+
+            // It seems that crossterm prefers to have a complete string ready to be printed
+            // rather than looping through the values and printing multiple things
+            // This reduces the flickering when printing the menu
+            let available_values = (available_lines * self.get_cols()) as usize;
+            let selection_values: String = self
+                .get_values()
+                .iter()
+                .skip(skip_values)
+                .take(available_values)
+                .enumerate()
+                .map(|(index, suggestion)| {
+                    // Correcting the enumerate index based on the number of skipped values
+                    let index = index + skip_values;
+                    let column = index as u16 % self.get_cols();
+                    let empty_space = self.get_width().saturating_sub(suggestion.value.len());
+
+                    self.create_entry_string(
+                        suggestion,
+                        index,
+                        column,
+                        empty_space,
+                        use_ansi_coloring,
+                    )
+                })
+                .collect();
+
+            format!(
+                "{}{}{}",
+                selection_values,
+                self.create_description_string(use_ansi_coloring),
+                self.create_example_string(use_ansi_coloring)
+            )
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+use nu_engine::documentation::get_flags_section;
+use nu_protocol::{engine::EngineState, levenshtein_distance};
+use reedline::{Completer, Suggestion};
+use std::sync::Arc;
+
+pub struct NuHelpCompleter(Arc<EngineState>);
+
+impl NuHelpCompleter {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self(engine_state)
+    }
+
+    fn completion_helper(&self, line: &str, pos: usize) -> Vec<Suggestion> {
+        let full_commands = self.0.get_signatures_with_examples(false);
+
+        //Vec<(Signature, Vec<Example>, bool, bool)> {
+        let mut commands = full_commands
+            .iter()
+            .filter(|(sig, _, _, _)| {
+                sig.name.to_lowercase().contains(&line.to_lowercase())
+                    || sig.usage.to_lowercase().contains(&line.to_lowercase())
+                    || sig
+                        .extra_usage
+                        .to_lowercase()
+                        .contains(&line.to_lowercase())
+            })
+            .collect::<Vec<_>>();
+
+        commands.sort_by(|(a, _, _, _), (b, _, _, _)| {
+            let a_distance = levenshtein_distance(line, &a.name);
+            let b_distance = levenshtein_distance(line, &b.name);
+            a_distance.cmp(&b_distance)
+        });
+
+        commands
+            .into_iter()
+            .map(|(sig, examples, _, _)| {
+                let mut long_desc = String::new();
+
+                let usage = &sig.usage;
+                if !usage.is_empty() {
+                    long_desc.push_str(usage);
+                    long_desc.push_str("\r\n\r\n");
+                }
+
+                let extra_usage = &sig.extra_usage;
+                if !extra_usage.is_empty() {
+                    long_desc.push_str(extra_usage);
+                    long_desc.push_str("\r\n\r\n");
+                }
+
+                long_desc.push_str(&format!("Usage:\r\n  > {}\r\n", sig.call_signature()));
+
+                if !sig.named.is_empty() {
+                    long_desc.push_str(&get_flags_section(sig))
+                }
+
+                if !sig.required_positional.is_empty()
+                    || !sig.optional_positional.is_empty()
+                    || sig.rest_positional.is_some()
+                {
+                    long_desc.push_str("\r\nParameters:\r\n");
+                    for positional in &sig.required_positional {
+                        long_desc
+                            .push_str(&format!("  {}: {}\r\n", positional.name, positional.desc));
+                    }
+                    for positional in &sig.optional_positional {
+                        long_desc.push_str(&format!(
+                            "  (optional) {}: {}\r\n",
+                            positional.name, positional.desc
+                        ));
+                    }
+
+                    if let Some(rest_positional) = &sig.rest_positional {
+                        long_desc.push_str(&format!(
+                            "  ...{}: {}\r\n",
+                            rest_positional.name, rest_positional.desc
+                        ));
+                    }
+                }
+
+                let extra: Vec<String> = examples
+                    .iter()
+                    .map(|example| example.example.to_string())
+                    .collect();
+
+                Suggestion {
+                    value: sig.name.clone(),
+                    description: Some(long_desc),
+                    extra: Some(extra),
+                    span: reedline::Span {
+                        start: pos,
+                        end: pos + line.len(),
+                    },
+                }
+            })
+            .collect()
+    }
+}
+
+impl Completer for NuHelpCompleter {
+    fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+        self.completion_helper(line, pos)
+    }
+}

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

@@ -0,0 +1,174 @@
+use nu_engine::eval_block;
+use nu_protocol::{
+    engine::{EngineState, Stack},
+    IntoPipelineData, Span, Value,
+};
+use reedline::{menu_functions::parse_selection_char, Completer, Suggestion};
+use std::sync::Arc;
+
+const SELECTION_CHAR: char = '!';
+
+pub struct NuMenuCompleter {
+    block_id: usize,
+    span: Span,
+    stack: Stack,
+    engine_state: Arc<EngineState>,
+    only_buffer_difference: bool,
+}
+
+impl NuMenuCompleter {
+    pub fn new(
+        block_id: usize,
+        span: Span,
+        stack: Stack,
+        engine_state: Arc<EngineState>,
+        only_buffer_difference: bool,
+    ) -> Self {
+        Self {
+            block_id,
+            span,
+            stack,
+            engine_state,
+            only_buffer_difference,
+        }
+    }
+}
+
+impl Completer for NuMenuCompleter {
+    fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+        let parsed = parse_selection_char(line, SELECTION_CHAR);
+
+        let block = self.engine_state.get_block(self.block_id);
+
+        if let Some(buffer) = block.signature.get_positional(0) {
+            if let Some(buffer_id) = &buffer.var_id {
+                let line_buffer = Value::String {
+                    val: parsed.remainder.to_string(),
+                    span: self.span,
+                };
+                self.stack.add_var(*buffer_id, line_buffer);
+            }
+        }
+
+        if let Some(position) = block.signature.get_positional(1) {
+            if let Some(position_id) = &position.var_id {
+                let line_buffer = Value::Int {
+                    val: pos as i64,
+                    span: self.span,
+                };
+                self.stack.add_var(*position_id, line_buffer);
+            }
+        }
+
+        let input = Value::nothing(self.span).into_pipeline_data();
+        let res = eval_block(
+            &self.engine_state,
+            &mut self.stack,
+            block,
+            input,
+            false,
+            false,
+        );
+
+        if let Ok(values) = res {
+            let values = values.into_value(self.span);
+            convert_to_suggestions(values, line, pos, self.only_buffer_difference)
+        } else {
+            Vec::new()
+        }
+    }
+}
+
+fn convert_to_suggestions(
+    value: Value,
+    line: &str,
+    pos: usize,
+    only_buffer_difference: bool,
+) -> Vec<Suggestion> {
+    match value {
+        Value::Record { .. } => {
+            let text = match value
+                .get_data_by_key("value")
+                .and_then(|val| val.as_string().ok())
+            {
+                Some(val) => val,
+                None => "No value key".to_string(),
+            };
+
+            let description = value
+                .get_data_by_key("description")
+                .and_then(|val| val.as_string().ok());
+
+            let span = match value.get_data_by_key("span") {
+                Some(span @ Value::Record { .. }) => {
+                    let start = span
+                        .get_data_by_key("start")
+                        .and_then(|val| val.as_integer().ok());
+                    let end = span
+                        .get_data_by_key("end")
+                        .and_then(|val| val.as_integer().ok());
+                    match (start, end) {
+                        (Some(start), Some(end)) => {
+                            let start = start.min(end);
+                            reedline::Span {
+                                start: start as usize,
+                                end: end as usize,
+                            }
+                        }
+                        _ => reedline::Span {
+                            start: if only_buffer_difference { pos } else { 0 },
+                            end: if only_buffer_difference {
+                                pos + line.len()
+                            } else {
+                                line.len()
+                            },
+                        },
+                    }
+                }
+                _ => reedline::Span {
+                    start: if only_buffer_difference { pos } else { 0 },
+                    end: if only_buffer_difference {
+                        pos + line.len()
+                    } else {
+                        line.len()
+                    },
+                },
+            };
+
+            let extra = match value.get_data_by_key("extra") {
+                Some(Value::List { vals, .. }) => {
+                    let extra: Vec<String> = vals
+                        .into_iter()
+                        .filter_map(|extra| match extra {
+                            Value::String { val, .. } => Some(val),
+                            _ => None,
+                        })
+                        .collect();
+
+                    Some(extra)
+                }
+                _ => None,
+            };
+
+            vec![Suggestion {
+                value: text,
+                description,
+                extra,
+                span,
+            }]
+        }
+        Value::List { vals, .. } => vals
+            .into_iter()
+            .flat_map(|val| convert_to_suggestions(val, line, pos, only_buffer_difference))
+            .collect(),
+        _ => vec![Suggestion {
+            value: format!("Not a record: {:?}", value),
+            description: None,
+            extra: None,
+            span: reedline::Span {
+                start: 0,
+                end: line.len(),
+            },
+        }],
+    }
+}

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

@@ -0,0 +1,7 @@
+mod description_menu;
+mod help_completions;
+mod menu_completions;
+
+pub use description_menu::DescriptionMenu;
+pub use help_completions::NuHelpCompleter;
+pub use menu_completions::NuMenuCompleter;

crates/nu-cli/src/nu_highlight.rs

@@ -0,0 +1,63 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Value};
+use reedline::Highlighter;
+
+#[derive(Clone)]
+pub struct NuHighlight;
+
+impl Command for NuHighlight {
+    fn name(&self) -> &str {
+        "nu-highlight"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("nu-highlight").category(Category::Strings)
+    }
+
+    fn usage(&self) -> &str {
+        "Syntax highlight the input string."
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+
+        let ctrlc = engine_state.ctrlc.clone();
+        let engine_state = engine_state.clone();
+        let config = stack.get_config()?;
+
+        let highlighter = crate::NuHighlighter {
+            engine_state,
+            config,
+        };
+
+        input.map(
+            move |x| match x.as_string() {
+                Ok(line) => {
+                    let highlights = highlighter.highlight(&line, line.len());
+
+                    Value::String {
+                        val: highlights.render_simple(),
+                        span: head,
+                    }
+                }
+                Err(err) => Value::Error { error: err },
+            },
+            ctrlc,
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Describe the type of a string",
+            example: "'let x = 3' | nu-highlight",
+            result: None,
+        }]
+    }
+}

crates/nu-cli/src/print.rs

@@ -0,0 +1,57 @@
+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, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct Print;
+
+impl Command for Print {
+    fn name(&self) -> &str {
+        "print"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("print")
+            .rest("rest", SyntaxShape::Any, "the values to print")
+            .category(Category::Strings)
+    }
+
+    fn usage(&self) -> &str {
+        "Prints the values given"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
+        let head = call.head;
+
+        for arg in args {
+            crate::util::print_pipeline_data(arg.into_pipeline_data(), engine_state, stack)?;
+        }
+
+        Ok(PipelineData::new(head))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Print 'hello world'",
+                example: r#"print "hello world""#,
+                result: None,
+            },
+            Example {
+                description: "Print the sum of 2 and 3",
+                example: r#"print (2 + 3)"#,
+                result: None,
+            },
+        ]
+    }
+}

crates/nu-cli/src/prompt.rs

@@ -0,0 +1,159 @@
+use reedline::DefaultPrompt;
+
+use {
+    reedline::{
+        Prompt, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus, PromptViMode,
+    },
+    std::borrow::Cow,
+};
+
+/// Nushell prompt definition
+#[derive(Clone)]
+pub struct NushellPrompt {
+    left_prompt_string: Option<String>,
+    right_prompt_string: Option<String>,
+    default_prompt_indicator: Option<String>,
+    default_vi_insert_prompt_indicator: Option<String>,
+    default_vi_normal_prompt_indicator: Option<String>,
+    default_multiline_indicator: Option<String>,
+}
+
+impl Default for NushellPrompt {
+    fn default() -> Self {
+        NushellPrompt::new()
+    }
+}
+
+impl NushellPrompt {
+    pub fn new() -> NushellPrompt {
+        NushellPrompt {
+            left_prompt_string: None,
+            right_prompt_string: None,
+            default_prompt_indicator: None,
+            default_vi_insert_prompt_indicator: None,
+            default_vi_normal_prompt_indicator: None,
+            default_multiline_indicator: None,
+        }
+    }
+
+    pub fn update_prompt_left(&mut self, prompt_string: Option<String>) {
+        self.left_prompt_string = prompt_string;
+    }
+
+    pub fn update_prompt_right(&mut self, prompt_string: Option<String>) {
+        self.right_prompt_string = prompt_string;
+    }
+
+    pub fn update_prompt_indicator(&mut self, prompt_indicator_string: Option<String>) {
+        self.default_prompt_indicator = prompt_indicator_string;
+    }
+
+    pub fn update_prompt_vi_insert(&mut self, prompt_vi_insert_string: Option<String>) {
+        self.default_vi_insert_prompt_indicator = prompt_vi_insert_string;
+    }
+
+    pub fn update_prompt_vi_normal(&mut self, prompt_vi_normal_string: Option<String>) {
+        self.default_vi_normal_prompt_indicator = prompt_vi_normal_string;
+    }
+
+    pub fn update_prompt_multiline(&mut self, prompt_multiline_indicator_string: Option<String>) {
+        self.default_multiline_indicator = prompt_multiline_indicator_string;
+    }
+
+    pub fn update_all_prompt_strings(
+        &mut self,
+        left_prompt_string: Option<String>,
+        right_prompt_string: Option<String>,
+        prompt_indicator_string: Option<String>,
+        prompt_multiline_indicator_string: Option<String>,
+        prompt_vi: (Option<String>, Option<String>),
+    ) {
+        let (prompt_vi_insert_string, prompt_vi_normal_string) = prompt_vi;
+
+        self.left_prompt_string = left_prompt_string;
+        self.right_prompt_string = right_prompt_string;
+        self.default_prompt_indicator = prompt_indicator_string;
+        self.default_multiline_indicator = prompt_multiline_indicator_string;
+
+        self.default_vi_insert_prompt_indicator = prompt_vi_insert_string;
+        self.default_vi_normal_prompt_indicator = prompt_vi_normal_string;
+    }
+
+    fn default_wrapped_custom_string(&self, str: String) -> String {
+        format!("({})", str)
+    }
+}
+
+impl Prompt for NushellPrompt {
+    fn render_prompt_left(&self) -> Cow<str> {
+        if let Some(prompt_string) = &self.left_prompt_string {
+            prompt_string.replace('\n', "\r\n").into()
+        } else {
+            let default = DefaultPrompt::new();
+            default
+                .render_prompt_left()
+                .to_string()
+                .replace('\n', "\r\n")
+                .into()
+        }
+    }
+
+    fn render_prompt_right(&self) -> Cow<str> {
+        if let Some(prompt_string) = &self.right_prompt_string {
+            prompt_string.replace('\n', "\r\n").into()
+        } else {
+            let default = DefaultPrompt::new();
+            default
+                .render_prompt_right()
+                .to_string()
+                .replace('\n', "\r\n")
+                .into()
+        }
+    }
+
+    fn render_prompt_indicator(&self, edit_mode: PromptEditMode) -> Cow<str> {
+        match edit_mode {
+            PromptEditMode::Default => match &self.default_prompt_indicator {
+                Some(indicator) => indicator.as_str().into(),
+                None => "〉".into(),
+            },
+            PromptEditMode::Emacs => match &self.default_prompt_indicator {
+                Some(indicator) => indicator.as_str().into(),
+                None => "〉".into(),
+            },
+            PromptEditMode::Vi(vi_mode) => match vi_mode {
+                PromptViMode::Normal => match &self.default_vi_normal_prompt_indicator {
+                    Some(indicator) => indicator.as_str().into(),
+                    None => ": ".into(),
+                },
+                PromptViMode::Insert => match &self.default_vi_insert_prompt_indicator {
+                    Some(indicator) => indicator.as_str().into(),
+                    None => "〉".into(),
+                },
+            },
+            PromptEditMode::Custom(str) => self.default_wrapped_custom_string(str).into(),
+        }
+    }
+
+    fn render_prompt_multiline_indicator(&self) -> Cow<str> {
+        match &self.default_multiline_indicator {
+            Some(indicator) => indicator.as_str().into(),
+            None => "::: ".into(),
+        }
+    }
+
+    fn render_prompt_history_search_indicator(
+        &self,
+        history_search: PromptHistorySearch,
+    ) -> Cow<str> {
+        let prefix = match history_search.status {
+            PromptHistorySearchStatus::Passing => "",
+            PromptHistorySearchStatus::Failing => "failing ",
+        };
+
+        Cow::Owned(format!(
+            "({}reverse-search: {})",
+            prefix, history_search.term
+        ))
+    }
+}

crates/nu-cli/src/prompt_update.rs

@@ -0,0 +1,156 @@
+use crate::util::report_error;
+use crate::NushellPrompt;
+use log::info;
+use nu_engine::eval_subexpression;
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, Span, Value,
+};
+use reedline::Prompt;
+
+// Name of environment variable where the prompt could be stored
+pub(crate) const PROMPT_COMMAND: &str = "PROMPT_COMMAND";
+pub(crate) const PROMPT_COMMAND_RIGHT: &str = "PROMPT_COMMAND_RIGHT";
+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";
+
+fn get_prompt_string(
+    prompt: &str,
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    is_perf_true: bool,
+) -> Option<String> {
+    stack
+        .get_env_var(engine_state, prompt)
+        .and_then(|v| match v {
+            Value::Block {
+                val: block_id,
+                captures,
+                ..
+            } => {
+                let block = engine_state.get_block(block_id);
+                let mut stack = stack.captures_to_stack(&captures);
+                // Use eval_subexpression to force a redirection of output, so we can use everything in prompt
+                let ret_val = eval_subexpression(
+                    engine_state,
+                    &mut stack,
+                    block,
+                    PipelineData::new(Span::new(0, 0)), // Don't try this at home, 0 span is ignored
+                );
+                if is_perf_true {
+                    info!(
+                        "get_prompt_string (block) {}:{}:{}",
+                        file!(),
+                        line!(),
+                        column!()
+                    );
+                }
+
+                match ret_val {
+                    Ok(ret_val) => Some(ret_val),
+                    Err(err) => {
+                        let working_set = StateWorkingSet::new(engine_state);
+                        report_error(&working_set, &err);
+                        None
+                    }
+                }
+            }
+            Value::String { .. } => Some(PipelineData::Value(v.clone(), None)),
+            _ => None,
+        })
+        .and_then(|pipeline_data| {
+            let output = pipeline_data.collect_string("", config).ok();
+
+            match output {
+                Some(mut x) => {
+                    // Just remove the very last newline.
+                    if x.ends_with('\n') {
+                        x.pop();
+                    }
+
+                    if x.ends_with('\r') {
+                        x.pop();
+                    }
+                    Some(x)
+                }
+                None => None,
+            }
+        })
+}
+
+pub(crate) fn update_prompt<'prompt>(
+    config: &Config,
+    engine_state: &EngineState,
+    stack: &Stack,
+    nu_prompt: &'prompt mut NushellPrompt,
+    is_perf_true: bool,
+) -> &'prompt dyn Prompt {
+    let mut stack = stack.clone();
+
+    let left_prompt_string = get_prompt_string(
+        PROMPT_COMMAND,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
+
+    let right_prompt_string = get_prompt_string(
+        PROMPT_COMMAND_RIGHT,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
+
+    let prompt_indicator_string = get_prompt_string(
+        PROMPT_INDICATOR,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
+
+    let prompt_multiline_string = get_prompt_string(
+        PROMPT_MULTILINE_INDICATOR,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
+
+    let prompt_vi_insert_string = get_prompt_string(
+        PROMPT_INDICATOR_VI_INSERT,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
+
+    let prompt_vi_normal_string = get_prompt_string(
+        PROMPT_INDICATOR_VI_NORMAL,
+        config,
+        engine_state,
+        &mut stack,
+        is_perf_true,
+    );
+
+    // apply the other indicators
+    nu_prompt.update_all_prompt_strings(
+        left_prompt_string,
+        right_prompt_string,
+        prompt_indicator_string,
+        prompt_multiline_string,
+        (prompt_vi_insert_string, prompt_vi_normal_string),
+    );
+
+    let ret_val = nu_prompt as &dyn Prompt;
+    if is_perf_true {
+        info!("update_prompt {}:{}:{}", file!(), line!(), column!());
+    }
+
+    ret_val
+}

crates/nu-cli/src/repl.rs

@@ -0,0 +1,345 @@
+use crate::reedline_config::add_menus;
+use crate::{completions::NuCompleter, NuHighlighter, NuValidator, NushellPrompt};
+use crate::{prompt_update, reedline_config};
+use crate::{
+    reedline_config::KeybindingsMode,
+    util::{eval_source, report_error},
+};
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_color_config::get_color_config;
+use nu_engine::convert_env_values;
+use nu_parser::lex;
+use nu_protocol::engine::Stack;
+use nu_protocol::PipelineData;
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Config, ShellError, Span, Value, CONFIG_VARIABLE_ID,
+};
+use reedline::{DefaultHinter, Emacs, Vi};
+use std::path::PathBuf;
+use std::{sync::atomic::Ordering, time::Instant};
+
+pub fn evaluate_repl(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    history_path: Option<PathBuf>,
+    is_perf_true: bool,
+) -> Result<()> {
+    use reedline::{FileBackedHistory, Reedline, Signal};
+
+    let mut entry_num = 0;
+
+    let mut nu_prompt = NushellPrompt::new();
+
+    if is_perf_true {
+        info!(
+            "translate environment vars {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
+
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+    }
+
+    // seed env vars
+    stack.add_env_var(
+        "CMD_DURATION_MS".into(),
+        Value::String {
+            val: "0823".to_string(),
+            span: Span { start: 0, end: 0 },
+        },
+    );
+
+    stack.add_env_var(
+        "LAST_EXIT_CODE".into(),
+        Value::Int {
+            val: 0,
+            span: Span { start: 0, end: 0 },
+        },
+    );
+
+    if is_perf_true {
+        info!(
+            "load config initially {}:{}:{}",
+            file!(),
+            line!(),
+            column!()
+        );
+    }
+
+    // Get the config once for the history `max_history_size`
+    // Updating that will not be possible in one session
+    let mut config = match stack.get_config() {
+        Ok(config) => config,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &e);
+            Config::default()
+        }
+    };
+
+    if is_perf_true {
+        info!("setup reedline {}:{}:{}", file!(), line!(), column!());
+    }
+    let mut line_editor = Reedline::create();
+    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(
+                config.max_history_size as usize,
+                history_path.to_path_buf(),
+            )
+            .into_diagnostic()?,
+        );
+        line_editor = line_editor.with_history(history);
+    };
+
+    loop {
+        if is_perf_true {
+            info!(
+                "load config each loop {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        config = match stack.get_config() {
+            Ok(config) => config,
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &e);
+                Config::default()
+            }
+        };
+
+        if is_perf_true {
+            info!("setup colors {}:{}:{}", file!(), line!(), column!());
+        }
+
+        let color_hm = get_color_config(&config);
+
+        //Reset the ctrl-c handler
+        if let Some(ctrlc) = &mut engine_state.ctrlc {
+            ctrlc.store(false, Ordering::SeqCst);
+        }
+
+        if is_perf_true {
+            info!("update reedline {}:{}:{}", file!(), line!(), column!());
+        }
+        let engine_reference = std::sync::Arc::new(engine_state.clone());
+        line_editor = line_editor
+            .with_highlighter(Box::new(NuHighlighter {
+                engine_state: engine_state.clone(),
+                config: config.clone(),
+            }))
+            .with_animation(config.animate_prompt)
+            .with_validator(Box::new(NuValidator {
+                engine_state: engine_state.clone(),
+            }))
+            .with_completer(Box::new(NuCompleter::new(
+                engine_reference.clone(),
+                stack.clone(),
+                stack.vars.get(&CONFIG_VARIABLE_ID).cloned(),
+            )))
+            .with_quick_completions(config.quick_completions)
+            .with_partial_completions(config.partial_completions)
+            .with_ansi_colors(config.use_ansi_coloring);
+
+        line_editor = if config.use_ansi_coloring {
+            line_editor.with_hinter(Box::new(
+                DefaultHinter::default().with_style(color_hm["hints"]),
+            ))
+        } else {
+            line_editor.disable_hints()
+        };
+
+        line_editor = match add_menus(line_editor, engine_reference, stack, &config) {
+            Ok(line_editor) => line_editor,
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(&working_set, &e);
+                Reedline::create()
+            }
+        };
+
+        if config.sync_history_on_enter {
+            if is_perf_true {
+                info!("sync history {}:{}:{}", file!(), line!(), column!());
+            }
+            line_editor.sync_history().into_diagnostic()?;
+        }
+
+        if is_perf_true {
+            info!("setup keybindings {}:{}:{}", file!(), line!(), column!());
+        }
+
+        // Changing the line editor based on the found keybindings
+        line_editor = match reedline_config::create_keybindings(&config) {
+            Ok(keybindings) => match keybindings {
+                KeybindingsMode::Emacs(keybindings) => {
+                    let edit_mode = Box::new(Emacs::new(keybindings));
+                    line_editor.with_edit_mode(edit_mode)
+                }
+                KeybindingsMode::Vi {
+                    insert_keybindings,
+                    normal_keybindings,
+                } => {
+                    let edit_mode = Box::new(Vi::new(insert_keybindings, normal_keybindings));
+                    line_editor.with_edit_mode(edit_mode)
+                }
+            },
+            Err(e) => {
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(&working_set, &e);
+                line_editor
+            }
+        };
+
+        if is_perf_true {
+            info!("prompt_update {}:{}:{}", file!(), line!(), column!());
+        }
+
+        let prompt = prompt_update::update_prompt(
+            &config,
+            engine_state,
+            stack,
+            &mut nu_prompt,
+            is_perf_true,
+        );
+
+        entry_num += 1;
+
+        if is_perf_true {
+            info!(
+                "finished setup, starting repl {}:{}:{}",
+                file!(),
+                line!(),
+                column!()
+            );
+        }
+
+        let input = line_editor.read_line(prompt);
+        match input {
+            Ok(Signal::Success(s)) => {
+                let start_time = Instant::now();
+                let tokens = lex(s.as_bytes(), 0, &[], &[], false);
+                // Check if this is a single call to a directory, if so auto-cd
+                let cwd = nu_engine::env::current_dir_str(engine_state, stack)?;
+                let path = nu_path::expand_path_with(&s, &cwd);
+
+                let orig = s.clone();
+
+                if (orig.starts_with('.')
+                    || 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() {
+                            let working_set = StateWorkingSet::new(engine_state);
+
+                            report_error(
+                                &working_set,
+                                &ShellError::DirectoryNotFound(tokens.0[0].span),
+                            );
+                        }
+
+                        let path = nu_path::canonicalize_with(path, &cwd)
+                            .expect("internal error: cannot canonicalize known path");
+                        (path.to_string_lossy().to_string(), tokens.0[0].span)
+                    };
+
+                    //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(
+                        "PWD".into(),
+                        Value::String {
+                            val: path.clone(),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                    let cwd = Value::String { val: cwd, span };
+
+                    let shells = stack.get_env_var(engine_state, "NUSHELL_SHELLS");
+                    let mut shells = if let Some(v) = shells {
+                        v.as_list()
+                            .map(|x| x.to_vec())
+                            .unwrap_or_else(|_| vec![cwd])
+                    } else {
+                        vec![cwd]
+                    };
+
+                    let current_shell = stack.get_env_var(engine_state, "NUSHELL_CURRENT_SHELL");
+                    let current_shell = if let Some(v) = current_shell {
+                        v.as_integer().unwrap_or_default() as usize
+                    } else {
+                        0
+                    };
+
+                    shells[current_shell] = Value::String { val: path, span };
+
+                    stack.add_env_var("NUSHELL_SHELLS".into(), Value::List { vals: shells, span });
+                } else {
+                    trace!("eval source: {}", s);
+
+                    eval_source(
+                        engine_state,
+                        stack,
+                        s.as_bytes(),
+                        &format!("entry #{}", entry_num),
+                        PipelineData::new(Span::new(0, 0)),
+                    );
+
+                    stack.add_env_var(
+                        "CMD_DURATION_MS".into(),
+                        Value::String {
+                            val: format!("{}", start_time.elapsed().as_millis()),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+                }
+                // FIXME: permanent state changes like this hopefully in time can be removed
+                // and be replaced by just passing the cwd in where needed
+                if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                    let path = cwd.as_string()?;
+                    let _ = std::env::set_current_dir(path);
+                    engine_state.env_vars.insert("PWD".into(), cwd);
+                }
+            }
+            Ok(Signal::CtrlC) => {
+                // `Reedline` clears the line content. New prompt is shown
+            }
+            Ok(Signal::CtrlD) => {
+                // When exiting clear to a new line
+                println!();
+                break;
+            }
+            Ok(Signal::CtrlL) => {
+                line_editor.clear_screen().into_diagnostic()?;
+            }
+            Err(err) => {
+                let message = err.to_string();
+                if !message.contains("duration") {
+                    println!("Error: {:?}", err);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

crates/nu-cli/src/shell.rs

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

crates/nu-cli/src/syntax_highlight.rs

@@ -0,0 +1,213 @@
+use log::trace;
+use nu_ansi_term::Style;
+use nu_color_config::get_shape_color;
+use nu_parser::{flatten_block, parse, FlatShape};
+use nu_protocol::engine::{EngineState, StateWorkingSet};
+use nu_protocol::Config;
+use reedline::{Highlighter, StyledText};
+
+pub struct NuHighlighter {
+    pub engine_state: EngineState,
+    pub config: Config,
+}
+
+impl Highlighter for NuHighlighter {
+    fn highlight(&self, line: &str, _cursor: usize) -> StyledText {
+        trace!("highlighting: {}", line);
+
+        let (shapes, global_span_offset) = {
+            let mut working_set = StateWorkingSet::new(&self.engine_state);
+            let (block, _) = parse(&mut working_set, None, line.as_bytes(), false, &[]);
+
+            let shapes = flatten_block(&working_set, &block);
+            (shapes, self.engine_state.next_span_start())
+        };
+
+        let mut output = StyledText::default();
+        let mut last_seen_span = global_span_offset;
+
+        for shape in &shapes {
+            if shape.0.end <= last_seen_span
+                || last_seen_span < global_span_offset
+                || shape.0.start < global_span_offset
+            {
+                // We've already output something for this span
+                // so just skip this one
+                continue;
+            }
+            if shape.0.start > last_seen_span {
+                let gap = line
+                    [(last_seen_span - global_span_offset)..(shape.0.start - global_span_offset)]
+                    .to_string();
+                output.push((Style::new(), gap));
+            }
+            let next_token = line
+                [(shape.0.start - global_span_offset)..(shape.0.end - global_span_offset)]
+                .to_string();
+            match shape.1 {
+                FlatShape::Garbage => output.push((
+                    // nushell Garbage
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Nothing => output.push((
+                    // nushell Nothing
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Binary => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Bool => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Int => {
+                    // nushell Int
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Float => {
+                    // nushell Decimal
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Range => output.push((
+                    // nushell DotDot ?
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::InternalCall => output.push((
+                    // nushell InternalCommand
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::External => {
+                    // nushell ExternalCommand
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::ExternalArg => {
+                    // nushell ExternalWord
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Literal => {
+                    // nushell ?
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Operator => output.push((
+                    // nushell Operator
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Signature => output.push((
+                    // nushell ?
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::String => {
+                    // nushell String
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::StringInterpolation => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::DateTime => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::List => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Table => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Record => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Block => {
+                    // nushell ???
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Filepath => output.push((
+                    // nushell Path
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::GlobPattern => output.push((
+                    // nushell GlobPattern
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Variable => output.push((
+                    // nushell Variable
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+                FlatShape::Flag => {
+                    // nushell Flag
+                    output.push((
+                        get_shape_color(shape.1.to_string(), &self.config),
+                        next_token,
+                    ))
+                }
+                FlatShape::Custom(..) => output.push((
+                    get_shape_color(shape.1.to_string(), &self.config),
+                    next_token,
+                )),
+            }
+            last_seen_span = shape.0.end;
+        }
+
+        let remainder = line[(last_seen_span - global_span_offset)..].to_string();
+        if !remainder.is_empty() {
+            output.push((Style::new(), remainder));
+        }
+
+        output
+    }
+}

crates/nu-cli/src/util.rs

@@ -0,0 +1,352 @@
+use crate::CliError;
+use log::trace;
+use nu_engine::eval_block;
+use nu_parser::{lex, parse, trim_quotes, Token, TokenContents};
+use nu_protocol::engine::StateWorkingSet;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack},
+    PipelineData, ShellError, Span, Value,
+};
+#[cfg(windows)]
+use nu_utils::enable_vt_processing;
+use std::io::Write;
+use std::path::PathBuf;
+
+pub fn print_pipeline_data(
+    input: PipelineData,
+    engine_state: &EngineState,
+    stack: &mut Stack,
+) -> Result<(), ShellError> {
+    // If the table function is in the declarations, then we can use it
+    // to create the table value that will be printed in the terminal
+
+    let config = stack.get_config().unwrap_or_default();
+
+    let stdout = std::io::stdout();
+
+    if let PipelineData::ExternalStream {
+        stdout: stream,
+        exit_code,
+        ..
+    } = input
+    {
+        if let Some(stream) = stream {
+            for s in stream {
+                let _ = stdout.lock().write_all(s?.as_binary()?);
+            }
+        }
+
+        // Make sure everything has finished
+        if let Some(exit_code) = exit_code {
+            let _: Vec<_> = exit_code.into_iter().collect();
+        }
+
+        return Ok(());
+    }
+
+    match engine_state.find_decl("table".as_bytes()) {
+        Some(decl_id) => {
+            let table = engine_state.get_decl(decl_id).run(
+                engine_state,
+                stack,
+                &Call::new(Span::new(0, 0)),
+                input,
+            )?;
+
+            for item in table {
+                let stdout = std::io::stdout();
+
+                if let Value::Error { error } = item {
+                    return Err(error);
+                }
+
+                let mut out = item.into_string("\n", &config);
+                out.push('\n');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+        None => {
+            for item in input {
+                let stdout = std::io::stdout();
+
+                if let Value::Error { error } = item {
+                    return Err(error);
+                }
+
+                let mut out = item.into_string("\n", &config);
+                out.push('\n');
+
+                match stdout.lock().write_all(out.as_bytes()) {
+                    Ok(_) => (),
+                    Err(err) => eprintln!("{}", err),
+                };
+            }
+        }
+    };
+
+    Ok(())
+}
+
+// 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) {
+    fn report_capture_error(engine_state: &EngineState, env_str: &str, msg: &str) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::LabeledError(
+                format!("Environment variable was not captured: {}", env_str),
+                msg.into(),
+            ),
+        );
+    }
+
+    fn put_env_to_fake_file(name: &str, val: &str, fake_env_file: &mut String) {
+        fake_env_file.push('`');
+        fake_env_file.push_str(name);
+        fake_env_file.push('`');
+        fake_env_file.push('=');
+        fake_env_file.push('`');
+        fake_env_file.push_str(val);
+        fake_env_file.push('`');
+        fake_env_file.push('\n');
+    }
+
+    let mut fake_env_file = String::new();
+
+    // Make sure we always have PWD
+    if std::env::var("PWD").is_err() {
+        match std::env::current_dir() {
+            Ok(cwd) => {
+                put_env_to_fake_file("PWD", &cwd.to_string_lossy(), &mut fake_env_file);
+            }
+            Err(e) => {
+                // Could not capture current working directory
+                let working_set = StateWorkingSet::new(engine_state);
+                report_error(
+                    &working_set,
+                    &ShellError::LabeledError(
+                        "Current directory not found".to_string(),
+                        format!("Retrieving current directory failed: {:?}", e),
+                    ),
+                );
+            }
+        }
+    }
+
+    // Write all the env vars into a fake file
+    for (name, val) in std::env::vars() {
+        put_env_to_fake_file(&name, &val, &mut fake_env_file);
+    }
+
+    // Lex the fake file, assign spans to all environment variables and add them
+    // to stack
+    let span_offset = engine_state.next_span_start();
+
+    engine_state.add_file(
+        "Host Environment Variables".to_string(),
+        fake_env_file.as_bytes().to_vec(),
+    );
+
+    let (tokens, _) = lex(fake_env_file.as_bytes(), span_offset, &[], &[], true);
+
+    for token in tokens {
+        if let Token {
+            contents: TokenContents::Item,
+            span: full_span,
+        } = token
+        {
+            let contents = engine_state.get_span_contents(&full_span);
+            let (parts, _) = lex(contents, full_span.start, &[], &[b'='], true);
+
+            let name = if let Some(Token {
+                contents: TokenContents::Item,
+                span,
+            }) = parts.get(0)
+            {
+                let bytes = engine_state.get_span_contents(span);
+
+                if bytes.len() < 2 {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got empty name.",
+                    );
+
+                    continue;
+                }
+
+                let bytes = trim_quotes(bytes);
+                String::from_utf8_lossy(bytes).to_string()
+            } else {
+                report_capture_error(
+                    engine_state,
+                    &String::from_utf8_lossy(contents),
+                    "Got empty name.",
+                );
+
+                continue;
+            };
+
+            let value = if let Some(Token {
+                contents: TokenContents::Item,
+                span,
+            }) = parts.get(2)
+            {
+                let bytes = engine_state.get_span_contents(span);
+
+                if bytes.len() < 2 {
+                    report_capture_error(
+                        engine_state,
+                        &String::from_utf8_lossy(contents),
+                        "Got empty value.",
+                    );
+
+                    continue;
+                }
+
+                let bytes = trim_quotes(bytes);
+
+                Value::String {
+                    val: String::from_utf8_lossy(bytes).to_string(),
+                    span: *span,
+                }
+            } else {
+                report_capture_error(
+                    engine_state,
+                    &String::from_utf8_lossy(contents),
+                    "Got empty value.",
+                );
+
+                continue;
+            };
+
+            // stack.add_env_var(name, value);
+            engine_state.env_vars.insert(name, value);
+        }
+    }
+}
+
+pub fn eval_source(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    source: &[u8],
+    fname: &str,
+    input: PipelineData,
+) -> bool {
+    trace!("eval_source");
+
+    let (block, delta) = {
+        let mut working_set = StateWorkingSet::new(engine_state);
+        let (output, err) = parse(
+            &mut working_set,
+            Some(fname), // format!("entry #{}", entry_num)
+            source,
+            false,
+            &[],
+        );
+        if let Some(err) = err {
+            set_last_exit_code(stack, 1);
+            report_error(&working_set, &err);
+            return false;
+        }
+
+        (output, working_set.render())
+    };
+
+    let cwd = match nu_engine::env::current_dir_str(engine_state, stack) {
+        Ok(p) => PathBuf::from(p),
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            get_init_cwd()
+        }
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta, Some(stack), &cwd) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    match eval_block(engine_state, stack, &block, input, false, false) {
+        Ok(mut pipeline_data) => {
+            if let PipelineData::ExternalStream { exit_code, .. } = &mut pipeline_data {
+                if let Some(exit_code) = exit_code.take().and_then(|it| it.last()) {
+                    stack.add_env_var("LAST_EXIT_CODE".to_string(), exit_code);
+                } else {
+                    set_last_exit_code(stack, 0);
+                }
+            } else {
+                set_last_exit_code(stack, 0);
+            }
+
+            if let Err(err) = print_pipeline_data(pipeline_data, engine_state, stack) {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &err);
+
+                return false;
+            }
+
+            // reset vt processing, aka ansi because illbehaved externals can break it
+            #[cfg(windows)]
+            {
+                let _ = enable_vt_processing();
+            }
+        }
+        Err(err) => {
+            set_last_exit_code(stack, 1);
+
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+
+            return false;
+        }
+    }
+
+    true
+}
+
+fn set_last_exit_code(stack: &mut Stack, exit_code: i64) {
+    stack.add_env_var(
+        "LAST_EXIT_CODE".to_string(),
+        Value::Int {
+            val: exit_code,
+            span: Span { start: 0, end: 0 },
+        },
+    );
+}
+
+pub fn report_error(
+    working_set: &StateWorkingSet,
+    error: &(dyn miette::Diagnostic + Send + Sync + 'static),
+) {
+    eprintln!("Error: {:?}", CliError(error, working_set));
+    // reset vt processing, aka ansi because illbehaved externals can break it
+    #[cfg(windows)]
+    {
+        let _ = nu_utils::enable_vt_processing();
+    }
+}
+
+pub fn get_init_cwd() -> PathBuf {
+    match std::env::current_dir() {
+        Ok(cwd) => cwd,
+        Err(_) => match std::env::var("PWD") {
+            Ok(cwd) => PathBuf::from(cwd),
+            Err(_) => match nu_path::home_dir() {
+                Some(cwd) => cwd,
+                None => PathBuf::new(),
+            },
+        },
+    }
+}