remove std clip (#11131)

follow up to
- https://github.com/nushell/nushell/pull/11097

related to
- https://github.com/nushell/nu_scripts/pull/674

> **Important**
> wait for in between Nushell 0.88.0 and 0.89.0

# Description
this PR removes the `std clip` command after it's been deprecated in
https://github.com/nushell/nushell/pull/11097 😋

# User-Facing Changes
`std clip` will no longer be available.

# Tests + Formatting

# After Submitting

.azure/azure-pipelines.yml

@@ -1,67 +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
-        sudo npm install -g wasm-pack
-      fi
-      if [ "$(uname)" == "Darwin" ]; then
-        curl https://sh.rustup.rs -sSf | sh -s -- -y --no-modify-path --default-toolchain "stable"
-        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
-    condition: eq(variables['style'], 'unflagged')
-    displayName: Check clippy lints
-  - bash: cd samples/wasm && wasm-pack 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,33 @@
-# use LLD as linker on Windows because it could be faster
-# for full and incremental builds compared to default
-
 [target.x86_64-pc-windows-msvc]
-#linker = "lld-link.exe"
-rustflags = ["-C", "link-args=-stack:10000000"]
+# increase the default windows stack size
+# statically link the CRT so users don't have to install it
+rustflags = ["-C", "link-args=-stack:10000000", "-C", "target-feature=+crt-static"]
+
+# keeping this but commentting out in case we need them in the future
+
+# 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"]
+
+# How to use mold in linux and mac
+
+# [target.x86_64-unknown-linux-gnu]
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/mold"]
+
+# [target.x86_64-apple-darwin]
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+
+# [target.aarch64-apple-darwin]
+# linker = "clang"
+# rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+
+[target.aarch64-apple-darwin]
+# We can guarantee that this target will always run on a CPU with _at least_
+# these capabilities, so let's optimize for them
+rustflags = ["-Ctarget-cpu=apple-m1"]

.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

.gitattributes

@@ -0,0 +1,2 @@
+# Example of a `.gitattributes` file which reclassifies `.nu` files as Nushell:
+*.nu linguist-language=Nushell

.githooks/pre-commit

@@ -0,0 +1,5 @@
+#!/usr/bin/env nu
+
+use ../toolkit.nu fmt
+
+fmt --check --verbose

.githooks/pre-push

@@ -0,0 +1,6 @@
+#!/usr/bin/env nu
+
+use ../toolkit.nu [fmt, clippy]
+
+fmt --check --verbose
+clippy --verbose

.github/.typos.toml

@@ -0,0 +1,15 @@
+[files]
+extend-exclude = ["crates/nu-command/tests/commands/table.rs", "*.tsv", "*.json", "*.txt"]
+
+[default.extend-words]
+# Ignore false-positives
+nd = "nd"
+fo = "fo"
+ons = "ons"
+ba = "ba"
+Plasticos = "Plasticos"
+IIF = "IIF"
+numer = "numer"
+ratatui = "ratatui"
+doas = "doas"
+wheres = "wheres"

.github/AUTO_ISSUE_TEMPLATE/README.md

@@ -0,0 +1 @@
+This directory is intended for templates to automatically create issues with the [create-an-issue](https://github.com/JasonEtco/create-an-issue) action.

.github/AUTO_ISSUE_TEMPLATE/nightly-build-fail.md

@@ -0,0 +1,16 @@
+---
+name: Nightly build of release binaries failed
+about: Used to submit issues related to binaries release workflow
+title: 'Attention: Nightly build of release binaries failed'
+labels: ['build-package', 'priority']
+assignees: ''
+
+---
+
+**Nightly build of release binaries failed**
+
+Hi there:
+
+If you see me here that means there is a release failure for the nightly build
+
+Please **click the status badge** to see more details: [![Nightly Build](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml/badge.svg)](https://github.com/nushell/nushell/actions/workflows/nightly-build.yml)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,47 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1.
-2.
-3.
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Configuration (please complete the following information):**
-
-Run `version | pivot` and paste the output to show OS, features, etc.
-
-```
-> version | pivot
-╭───┬────────────────────┬───────────────────────────────────────────────────────────────────────╮
-│ # │ Column0            │ Column1                                                               │
-├───┼────────────────────┼───────────────────────────────────────────────────────────────────────┤
-│ 0 │ version            │ 0.24.1                                                                │
-│ 1 │ build_os           │ macos-x86_64                                                          │
-│ 2 │ rust_version       │ rustc 1.48.0                                                          │
-│ 3 │ cargo_version      │ cargo 1.48.0                                                          │
-│ 4 │ pkg_version        │ 0.24.1                                                                │
-│ 5 │ build_time         │ 2020-12-18 09:54:09                                                   │
-│ 6 │ build_rust_channel │ release                                                               │
-│ 7 │ features           │ ctrlc, default, directories, dirs, git, ichwh, ptree, rich-benchmark, │
-│   │                    │ rustyline, term, uuid, which, zip                                     │
-╰───┴────────────────────┴───────────────────────────────────────────────────────────────────────╯
-```
-
-
-**Add any other context about the problem here.**

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,64 @@
+name: Bug Report
+description: Create a report to help us improve
+labels: ["needs-triage"]
+body: 
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: Thank you for your bug report.
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: How to reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1.
+        2.
+        3.
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+      placeholder: I expected nu to...
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: Please add any relevant screenshots here, if any
+    validations:
+      required: false
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: "Please run `version | transpose key value | to md --pretty` and paste the output to show OS, features, etc."
+      placeholder: |
+        > 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: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,35 @@
+name: Feature Request
+description: "When you want a new feature for something that doesn't already exist"
+labels: ["needs-triage", "enhancement"]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      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 [...]
+    validations:
+      required: false
+  - type: textarea
+    id: desired
+    attributes:
+      label: "Describe the solution you'd like"
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: "Describe alternatives you've considered"
+      description: "A clear and concise description of any alternative solutions or features you've considered."
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context and details
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/question.yml

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

.github/ISSUE_TEMPLATE/standard-library-bug-or-feature-report.md

@@ -0,0 +1,11 @@
+---
+name: standard library bug or feature report
+about: Used to submit issues related to the nu standard library
+title: ''
+labels: ['needs-triage', 'std-library']
+assignees: ''
+
+---
+
+**Describe the bug or feature**
+A clear and concise description of what the bug is.

.github/dependabot.yml

@@ -0,0 +1,20 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+# docs
+# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    ignore:
+      - dependency-name: "*"
+        update-types: ["version-update:semver-patch"]
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/pull_request_template.md

@@ -0,0 +1,40 @@
+<!--
+if this PR closes one or more issues, you can automatically link the PR with
+them by using one of the [*linking keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword), e.g.
+- this PR should close #xxxx
+- fixes #xxxx
+
+you can also mention related issues, PRs or discussions!
+-->
+
+# Description
+<!--
+Thank you for improving Nushell. Please, check our [contributing guide](../CONTRIBUTING.md) and talk to the core team before making major changes.
+
+Description of your pull request goes here. **Provide examples and/or screenshots** if your changes affect the user experience.
+-->
+
+# User-Facing Changes
+<!-- List of all changes that impact the user experience here. This helps us keep track of breaking changes. -->
+
+# Tests + Formatting
+<!--
+Don't forget to add tests that cover your changes.
+
+Make sure you've run and fixed any issues with these commands:
+
+- `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes)
+- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to check that you're using the standard code style
+- `cargo test --workspace` to check that all tests pass (on Windows make sure to [enable developer mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
+- `cargo run -- -c "use std testing; testing run-tests --path crates/nu-std"` to run the tests for the standard library
+
+> **Note**
+> from `nushell` you can also use the `toolkit` as follows
+> ```bash
+> use toolkit.nu  # or use an `env_change` hook to activate it automatically
+> toolkit check pr
+> ```
+-->
+
+# After Submitting
+<!-- If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date. -->

.github/workflows/audit.yml

@@ -0,0 +1,25 @@
+name: Security audit
+on:
+  pull_request:
+    paths:
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+  push:
+    branches:
+    - main
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+  CLICOLOR: 1
+
+jobs:
+  security_audit:
+    runs-on: ubuntu-latest
+    # Prevent sudden announcement of a new advisory from failing ci:
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: rustsec/audit-check@v1.4.1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -0,0 +1,185 @@
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+name: continuous-integration
+
+env:
+  NUSHELL_CARGO_PROFILE: ci
+  NU_LOG_LEVEL: DEBUG
+  # If changing these settings also change toolkit.nu
+  CLIPPY_OPTIONS: "-D warnings -D clippy::unwrap_used"
+
+jobs:
+  fmt-clippy:
+    strategy:
+      fail-fast: true
+      matrix:
+        # Pinning to Ubuntu 20.04 because building on newer Ubuntu versions causes linux-gnu
+        # builds to link against a too-new-for-many-Linux-installs glibc version. Consider
+        # revisiting this when 20.04 is closer to EOL (April 2025)
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
+        feature: [default, dataframe, extra]
+        include:
+          - feature: default
+            flags: ""
+          - feature: dataframe
+            flags: "--features=dataframe"
+          - feature: extra
+            flags: "--features=extra"
+        exclude:
+          - platform: windows-latest
+            feature: dataframe
+          - platform: macos-latest
+            feature: dataframe
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
+
+      - name: cargo fmt
+        run: cargo fmt --all -- --check
+
+        # If changing these settings also change toolkit.nu
+      - name: Clippy
+        run: cargo clippy --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- $CLIPPY_OPTIONS
+
+        # In tests we don't have to deny unwrap
+      - name: Clippy of tests
+        run: cargo clippy --tests --workspace ${{ matrix.flags }} --exclude nu_plugin_* -- -D warnings
+
+  tests:
+    strategy:
+      fail-fast: true
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
+        feature: [default, dataframe, extra]
+        include:
+          - feature: default
+            flags: ""
+          - feature: dataframe
+            flags: "--features=dataframe"
+          - feature: extra
+            flags: "--features=extra"
+        exclude:
+          - platform: windows-latest
+            feature: dataframe
+          - platform: macos-latest
+            feature: dataframe
+          - platform: windows-latest
+            feature: extra
+          - platform: macos-latest
+            feature: extra
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
+
+      - name: Tests
+        run: cargo test --workspace --profile ci --exclude nu_plugin_* ${{ matrix.flags }}
+
+      - name: Check for clean repo
+        shell: bash
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "there are changes";
+            git status --porcelain
+            exit 1
+          else
+            echo "no changes in working directory";
+          fi
+
+  std-lib-and-python-virtualenv:
+    strategy:
+      fail-fast: true
+      matrix:
+        platform: [ubuntu-20.04, macos-latest, windows-latest]
+        py:
+          - py
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
+
+      - name: Install Nushell
+        run: cargo install --path . --locked --no-default-features
+
+      - name: Standard library tests
+        run: nu -c 'use std testing; testing run-tests --path crates/nu-std'
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install virtualenv
+        run: pip install virtualenv
+        shell: bash
+
+      - name: Test Nushell in virtualenv
+        run: nu scripts/test_virtualenv.nu
+        shell: bash
+
+      - name: Check for clean repo
+        shell: bash
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "there are changes";
+            git status --porcelain
+            exit 1
+          else
+            echo "no changes in working directory";
+          fi
+
+  plugins:
+    strategy:
+      fail-fast: true
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-20.04]
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust toolchain and cache
+        uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+        with:
+          rustflags: ""
+
+      - name: Clippy
+        run: cargo clippy --package nu_plugin_* ${{ matrix.flags }} -- $CLIPPY_OPTIONS
+
+      - name: Tests
+        run: cargo test --profile ci --package nu_plugin_*
+
+      - name: Check for clean repo
+        shell: bash
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "there are changes";
+            git status --porcelain
+            exit 1
+          else
+            echo "no changes in working directory";
+          fi

.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/nightly-build.yml

@@ -0,0 +1,346 @@
+#
+# REF:
+#   1. https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrixinclude
+#   2. https://github.com/JasonEtco/create-an-issue
+#   3. https://docs.github.com/en/actions/learn-github-actions/variables
+#   4. https://github.com/actions/github-script
+#
+name: Nightly Build
+
+on:
+  push:
+    branches:
+      - nightly   # Just for test purpose only with the nightly repo
+  # This schedule will run only from the default branch
+  schedule:
+    - cron: '15 0 * * *' # run at 00:15 AM UTC
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  prepare:
+    name: Prepare
+    runs-on: ubuntu-latest
+    # This job is required by the release job, so we should make it run both from Nushell repo and nightly repo
+    # if: github.repository == 'nushell/nightly'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        if: github.repository == 'nushell/nightly'
+        with:
+          ref: main
+          fetch-depth: 0
+          # Configure PAT here: https://github.com/settings/tokens for the push operation in the following steps
+          token: ${{ secrets.WORKFLOW_TOKEN }}
+
+      - name: Setup Nushell
+        uses: hustcer/setup-nu@v3.8
+        if: github.repository == 'nushell/nightly'
+        with:
+          version: 0.86.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Synchronize the main branch of nightly repo with the main branch of Nushell official repo
+      - name: Prepare for Nightly Release
+        shell: nu {0}
+        if: github.repository == 'nushell/nightly'
+        run: |
+          cd $env.GITHUB_WORKSPACE
+          git checkout main
+          # We can't push if no user name and email are configured
+          git config user.name 'hustcer'
+          git config user.email 'hustcer@outlook.com'
+          git pull origin main
+          git remote add src https://github.com/nushell/nushell.git
+          git fetch src main
+          # All the changes will be overwritten by the upstream main branch
+          git reset --hard src/main
+          git push origin main -f
+          let sha_short = (git rev-parse --short origin/main | str trim | str substring 0..7)
+          let tag_name = $'nightly-($sha_short)'
+          if (git ls-remote --tags origin $tag_name | is-empty) {
+            git tag -a $tag_name -m $'Nightly build from ($sha_short)'
+            git push origin --tags
+          }
+
+  standard:
+    name: Std
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - aarch64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        - armv7-unknown-linux-gnueabihf
+        - riscv64gc-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: armv7-unknown-linux-gnueabihf
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: riscv64gc-unknown-linux-gnu
+          os: ubuntu-latest
+          target_rustflags: ''
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        ref: main
+        fetch-depth: 0
+
+    - name: Update Rust Toolchain Target
+      run: |
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
+
+    - name: Setup Rust toolchain and cache
+      uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
+      with:
+        rustflags: ''
+
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v3.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        RELEASE_TYPE: standard
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
+
+    - name: Create an Issue for Release Failure
+      if: ${{ failure() }}
+      uses: JasonEtco/create-an-issue@v2.9.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        update_existing: true
+        search_existing: open
+        filename: .github/AUTO_ISSUE_TEMPLATE/nightly-build-fail.md
+
+    - name: Set Outputs of Short SHA
+      id: vars
+      run: |
+        echo "date=$(date -u +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+        sha_short=$(git rev-parse --short HEAD)
+        echo "sha_short=${sha_short:0:7}" >> $GITHUB_OUTPUT
+
+    # REF: https://github.com/marketplace/actions/gh-release
+    # Create a release only in nushell/nightly repo
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v0.1.15
+      if: ${{ startsWith(github.repository, 'nushell/nightly') }}
+      with:
+        prerelease: true
+        files: ${{ steps.nu.outputs.archive }}
+        tag_name: nightly-${{ steps.vars.outputs.sha_short }}
+        name: Nu-nightly-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.sha_short }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  full:
+    name: Full
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - aarch64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        ref: main
+        fetch-depth: 0
+
+    - name: Update Rust Toolchain Target
+      run: |
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
+
+    - name: Setup Rust toolchain and cache
+      uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
+      with:
+        rustflags: ''
+
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v3.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        RELEASE_TYPE: full
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
+
+    - name: Create an Issue for Release Failure
+      if: ${{ failure() }}
+      uses: JasonEtco/create-an-issue@v2.9.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        update_existing: true
+        search_existing: open
+        filename: .github/AUTO_ISSUE_TEMPLATE/nightly-build-fail.md
+
+    - name: Set Outputs of Short SHA
+      id: vars
+      run: |
+        echo "date=$(date -u +'%Y-%m-%d')" >> $GITHUB_OUTPUT
+        sha_short=$(git rev-parse --short HEAD)
+        echo "sha_short=${sha_short:0:7}" >> $GITHUB_OUTPUT
+
+    # REF: https://github.com/marketplace/actions/gh-release
+    # Create a release only in nushell/nightly repo
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v0.1.15
+      if: ${{ startsWith(github.repository, 'nushell/nightly') }}
+      with:
+        draft: false
+        prerelease: true
+        name: Nu-nightly-${{ steps.vars.outputs.date }}-${{ steps.vars.outputs.sha_short }}
+        tag_name: nightly-${{ steps.vars.outputs.sha_short }}
+        body: |
+          This is a NIGHTLY build of Nushell.
+          It is NOT recommended for production use.
+        files: ${{ steps.nu.outputs.archive }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  cleanup:
+    name: Cleanup
+    # Should only run in nushell/nightly repo
+    if: github.repository == 'nushell/nightly'
+    runs-on: ubuntu-latest
+    steps:
+      # Sleep for 30 minutes, waiting for the release to be published
+      - name: Waiting for Release
+        run: sleep 1800
+
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Nushell
+        uses: hustcer/setup-nu@v3.8
+        with:
+          version: 0.86.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Keep the last a few releases
+      - name: Delete Older Releases
+        shell: nu {0}
+        run: |
+          let KEEP_COUNT = 10
+          let deprecated = (http get https://api.github.com/repos/nushell/nightly/releases | sort-by -r created_at | select tag_name id | range $KEEP_COUNT..)
+          for release in $deprecated {
+            print $'Deleting tag ($release.tag_name)'
+            git push origin --delete $release.tag_name
+            print $'Deleting release ($release.tag_name)'
+            let delete_url = $'https://api.github.com/repos/nushell/nightly/releases/($release.id)'
+            let version = "X-GitHub-Api-Version: 2022-11-28"
+            let accept = "Accept: application/vnd.github+json"
+            let auth = "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}"
+            # http delete $delete_url -H $version -H $auth -H $accept
+            curl -L -X DELETE -H $accept -H $auth -H $version $delete_url
+          }

.github/workflows/release-pkg.nu

@@ -0,0 +1,240 @@
+#!/usr/bin/env nu
+
+# Created: 2022/05/26 19:05:20
+# Description:
+#   A script to do the github release task, need nushell to be installed.
+# REF:
+#   1. https://github.com/volks73/cargo-wix
+
+# Instructions for manually creating an MSI for Winget Releases when they fail
+# Added 2022-11-29 when Windows packaging wouldn't work
+# Updated again on 2023-02-23 because msis are still failing validation
+# Update on 2023-10-18 to use RELEASE_TYPE env var to determine if full or not
+# To run this manual for windows here are the steps I take
+# checkout the release you want to publish
+# 1. git checkout 0.86.0
+# unset CARGO_TARGET_DIR if set (I have to do this in the parent shell to get it to work)
+# 2. $env:CARGO_TARGET_DIR = ""
+# 2. hide-env CARGO_TARGET_DIR
+# 3. $env.TARGET = 'x86_64-pc-windows-msvc'
+# 4. $env.TARGET_RUSTFLAGS = ''
+# 5. $env.GITHUB_WORKSPACE = 'D:\nushell'
+# 6. $env.GITHUB_OUTPUT = 'D:\nushell\output\out.txt'
+# 7. $env.OS = 'windows-latest'
+# 8. $env.RELEASE_TYPE = '' # There is full and '' for normal releases
+# make sure 7z.exe is in your path https://www.7-zip.org/download.html
+# 9. $env.Path = ($env.Path | append 'c:\apps\7-zip')
+# make sure aria2c.exe is in your path https://github.com/aria2/aria2
+# 10. $env.Path = ($env.Path | append 'c:\path\to\aria2c')
+# make sure you have the wixtools installed https://wixtoolset.org/
+# 11. $env.Path = ($env.Path | append 'C:\Users\dschroeder\AppData\Local\tauri\WixTools')
+# You need to run the release-pkg twice. The first pass, with _EXTRA_ as 'bin', makes the output
+# folder and builds everything. The second pass, that generates the msi file, with _EXTRA_ as 'msi'
+# 12. $env._EXTRA_ = 'bin'
+# 13. source .github\workflows\release-pkg.nu
+# 14. cd ..
+# 15. $env._EXTRA_ = 'msi'
+# 16. source .github\workflows\release-pkg.nu
+# After msi is generated, you have to update winget-pkgs repo, you'll need to patch the release
+# by deleting the existing msi and uploading this new msi. Then you'll need to update the hash
+# on the winget-pkgs PR. To generate the hash, run this command
+# 17. open target\wix\nu-0.74.0-x86_64-pc-windows-msvc.msi | hash sha256
+# Then, just take the output and put it in the winget-pkgs PR for the hash on the msi
+
+
+# The main binary file to be released
+let bin = 'nu'
+let os = $env.OS
+let target = $env.TARGET
+# Repo source dir like `/home/runner/work/nushell/nushell`
+let src = $env.GITHUB_WORKSPACE
+let flags = $env.TARGET_RUSTFLAGS
+let dist = $'($env.GITHUB_WORKSPACE)/output'
+let version = (open Cargo.toml | get package.version)
+
+print $'Debugging info:'
+print { version: $version, bin: $bin, os: $os, releaseType: $env.RELEASE_TYPE, target: $target, src: $src, flags: $flags, dist: $dist }; hr-line -b
+
+# Rename the full release name so that we won't break the existing scripts for standard release downloading, such as:
+# curl -s https://api.github.com/repos/chmln/sd/releases/latest | grep browser_download_url | cut -d '"' -f 4 | grep x86_64-unknown-linux-musl
+const FULL_RLS_NAMING = {
+    x86_64-apple-darwin: 'x86_64-darwin-full',
+    aarch64-apple-darwin: 'aarch64-darwin-full',
+    x86_64-unknown-linux-gnu: 'x86_64-linux-gnu-full',
+    x86_64-pc-windows-msvc: 'x86_64-windows-msvc-full',
+    x86_64-unknown-linux-musl: 'x86_64-linux-musl-full',
+    aarch64-unknown-linux-gnu: 'aarch64-linux-gnu-full',
+    aarch64-pc-windows-msvc: 'aarch64-windows-msvc-full',
+    riscv64gc-unknown-linux-gnu: 'riscv64-linux-gnu-full',
+    armv7-unknown-linux-gnueabihf: 'armv7-linux-gnueabihf-full',
+}
+
+# $env
+
+let USE_UBUNTU = 'ubuntu-20.04'
+let FULL_NAME = $FULL_RLS_NAMING | get -i $target | default 'unknown-target-full'
+
+print $'(char nl)Packaging ($bin) v($version) for ($target) in ($src)...'; hr-line -b
+if not ('Cargo.lock' | path exists) { cargo generate-lockfile }
+
+print $'Start building ($bin)...'; hr-line
+
+# ----------------------------------------------------------------------------
+# Build for Ubuntu and macOS
+# ----------------------------------------------------------------------------
+if $os in [$USE_UBUNTU, 'macos-latest', 'ubuntu-latest'] {
+    if $os starts-with ubuntu {
+        sudo apt update
+        sudo apt-get install libxcb-composite0-dev -y
+    }
+    match $target {
+        'aarch64-unknown-linux-gnu' => {
+            sudo apt-get install gcc-aarch64-linux-gnu -y
+            $env.CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 'aarch64-linux-gnu-gcc'
+            cargo-build-nu $flags
+        }
+        'riscv64gc-unknown-linux-gnu' => {
+            sudo apt-get install gcc-riscv64-linux-gnu -y
+            $env.CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER = 'riscv64-linux-gnu-gcc'
+            cargo-build-nu $flags
+        }
+        'armv7-unknown-linux-gnueabihf' => {
+            sudo apt-get install pkg-config gcc-arm-linux-gnueabihf -y
+            $env.CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER = 'arm-linux-gnueabihf-gcc'
+            cargo-build-nu $flags
+        }
+        _ => {
+            # musl-tools to fix 'Failed to find tool. Is `musl-gcc` installed?'
+            # Actually just for x86_64-unknown-linux-musl target
+            if $os starts-with ubuntu { sudo apt install musl-tools -y }
+            cargo-build-nu $flags
+        }
+    }
+}
+
+# ----------------------------------------------------------------------------
+# Build for Windows without static-link-openssl feature
+# ----------------------------------------------------------------------------
+if $os in ['windows-latest'] {
+    cargo-build-nu $flags
+}
+
+# ----------------------------------------------------------------------------
+# Prepare for the release archive
+# ----------------------------------------------------------------------------
+let suffix = if $os == 'windows-latest' { '.exe' }
+# nu, nu_plugin_* were all included
+let executable = $'target/($target)/release/($bin)*($suffix)'
+print $'Current executable file: ($executable)'
+
+cd $src; mkdir $dist;
+rm -rf $'target/($target)/release/*.d' $'target/($target)/release/nu_pretty_hex*'
+print $'(char nl)All executable files:'; hr-line
+# We have to use `print` here to make sure the command output is displayed
+print (ls -f $executable); sleep 1sec
+
+print $'(char nl)Copying release files...'; hr-line
+"To use Nu plugins, use the register command to tell Nu where to find the plugin. For example:
+
+> register ./nu_plugin_query" | save $'($dist)/README.txt' -f
+[LICENSE $executable] | each {|it| cp -rv $it $dist } | flatten
+
+print $'(char nl)Check binary release version detail:'; hr-line
+let ver = if $os == 'windows-latest' {
+    (do -i { .\output\nu.exe -c 'version' }) | str join
+} else {
+    (do -i { ./output/nu -c 'version' }) | str join
+}
+if ($ver | str trim | is-empty) {
+    print $'(ansi r)Incompatible Nu binary: The binary cross compiled is not runnable on current arch...(ansi reset)'
+} else { print $ver }
+
+# ----------------------------------------------------------------------------
+# Create a release archive and send it to output for the following steps
+# ----------------------------------------------------------------------------
+cd $dist; print $'(char nl)Creating release archive...'; hr-line
+if $os in [$USE_UBUNTU, 'macos-latest', 'ubuntu-latest'] {
+
+    let files = (ls | get name)
+    let dest = if $env.RELEASE_TYPE == 'full' { $'($bin)-($version)-($FULL_NAME)' } else { $'($bin)-($version)-($target)' }
+    let archive = $'($dist)/($dest).tar.gz'
+
+    mkdir $dest
+    $files | each {|it| mv $it $dest } | ignore
+
+    print $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls $dest
+
+    tar -czf $archive $dest
+    print $'archive: ---> ($archive)'; ls $archive
+    # REF: https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/
+    echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
+
+} else if $os == 'windows-latest' {
+
+    let releaseStem = if $env.RELEASE_TYPE == 'full' { $'($bin)-($version)-($FULL_NAME)' } else { $'($bin)-($version)-($target)' }
+
+    print $'(char nl)Download less related stuffs...'; hr-line
+    aria2c https://github.com/jftuga/less-Windows/releases/download/less-v608/less.exe -o less.exe
+    aria2c https://raw.githubusercontent.com/jftuga/less-Windows/master/LICENSE -o LICENSE-for-less.txt
+
+    # Create Windows msi release package
+    if (get-env _EXTRA_) == 'msi' {
+
+        let wixRelease = $'($src)/target/wix/($releaseStem).msi'
+        print $'(char nl)Start creating Windows msi package...'
+        cd $src; hr-line
+        # Wix need the binaries be stored in target/release/
+        cp -r $'($dist)/*' target/release/
+        cargo install cargo-wix --version 0.3.4
+        cargo wix --no-build --nocapture --package nu --output $wixRelease
+        # Workaround for https://github.com/softprops/action-gh-release/issues/280
+        let archive = ($wixRelease | str replace --all '\' '/')
+        print $'archive: ---> ($archive)';
+        echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
+
+    } else {
+
+        print $'(char nl)(ansi g)Archive contents:(ansi reset)'; hr-line; ls
+        let archive = $'($dist)/($releaseStem).zip'
+        7z a $archive *
+        let pkg = (ls -f $archive | get name)
+        if not ($pkg | is-empty) {
+            # Workaround for https://github.com/softprops/action-gh-release/issues/280
+            let archive = ($pkg | get 0 | str replace --all '\' '/')
+            print $'archive: ---> ($archive)'
+            echo $"archive=($archive)" | save --append $env.GITHUB_OUTPUT
+        }
+    }
+}
+
+def 'cargo-build-nu' [ options: string ] {
+    if ($options | str trim | is-empty) {
+        if $os == 'windows-latest' {
+            cargo build --release --all --target $target
+        } else {
+            cargo build --release --all --target $target --features=static-link-openssl
+        }
+    } else {
+        if $os == 'windows-latest' {
+            cargo build --release --all --target $target $options
+        } else {
+            cargo build --release --all --target $target --features=static-link-openssl $options
+        }
+    }
+}
+
+# Print a horizontal line marker
+def 'hr-line' [
+    --blank-line(-b)
+] {
+    print $'(ansi g)---------------------------------------------------------------------------->(ansi reset)'
+    if $blank_line { char nl }
+}
+
+# Get the specified env key's value or ''
+def 'get-env' [
+    key: string           # The key to get it's env value
+    default: string = ''  # The default value for an empty env
+] {
+    $env | get -i $key | default $default
+}

.github/workflows/release.yml

@@ -1,286 +1,204 @@
+#
+# REF:
+#   1. https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstrategymatrixinclude
+#
 name: Create Release Draft
 
 on:
+  workflow_dispatch:
   push:
-    tags: ['[0-9]+.[0-9]+.[0-9]+*']
+    tags: ["[0-9]+.[0-9]+.[0-9]+*"]
+
+defaults:
+  run:
+    shell: bash
 
 jobs:
-  linux:
-    name: Build Linux
-    runs-on: ubuntu-latest
+  standard:
+    name: Std
+
+    strategy:
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - aarch64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        - armv7-unknown-linux-gnueabihf
+        - riscv64gc-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: ''
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: armv7-unknown-linux-gnueabihf
+          os: ubuntu-20.04
+          target_rustflags: ''
+        - target: riscv64gc-unknown-linux-gnu
+          os: ubuntu-latest
+          target_rustflags: ''
+
+    runs-on: ${{matrix.os}}
+
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+    - uses: actions/checkout@v4
 
-      - name: Install libxcb
-        run: sudo apt-get install libxcb-composite0-dev
+    - name: Update Rust Toolchain Target
+      run: |
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
 
-      - name: Set up cargo
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+    - name: Setup Rust toolchain and cache
+      uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
+      with:
+        rustflags: ''
 
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release --all --features=extra
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v3.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Create output directory
-        run: mkdir output
+    - name: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        RELEASE_TYPE: standard
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
 
-      - name: Copy files to output
-        run: |
-          cp target/release/nu target/release/nu_plugin_* output/
-          cp README.build.txt output/README.txt
-          cp LICENSE output/LICENSE
-          rm output/*.d
-          rm output/nu_plugin_core_*
-          rm output/nu_plugin_extra_*
+    # REF: https://github.com/marketplace/actions/gh-release
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v0.1.15
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
+      with:
+        draft: true
+        files: ${{ steps.nu.outputs.archive }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      # Note: If OpenSSL changes, this path will need to be updated
-      - name: Copy OpenSSL to output
-        run: cp /usr/lib/x86_64-linux-gnu/libssl.so.1.1 output/
+  full:
+    name: Full
 
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: linux
-          path: output/*
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+        - aarch64-apple-darwin
+        - x86_64-apple-darwin
+        - x86_64-pc-windows-msvc
+        - aarch64-pc-windows-msvc
+        - x86_64-unknown-linux-gnu
+        - x86_64-unknown-linux-musl
+        - aarch64-unknown-linux-gnu
+        extra: ['bin']
+        include:
+        - target: aarch64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-apple-darwin
+          os: macos-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: 'bin'
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-pc-windows-msvc
+          extra: msi
+          os: windows-latest
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: x86_64-unknown-linux-musl
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+        - target: aarch64-unknown-linux-gnu
+          os: ubuntu-20.04
+          target_rustflags: '--features=dataframe,extra'
+
+    runs-on: ${{matrix.os}}
 
-  macos:
-    name: Build macOS
-    runs-on: macos-latest
     steps:
-      - name: Check out code
-        uses: actions/checkout@v2
+    - uses: actions/checkout@v4
 
-      - name: Set up cargo
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
+    - name: Update Rust Toolchain Target
+      run: |
+        echo "targets = ['${{matrix.target}}']" >> rust-toolchain.toml
 
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release --all --features=extra
+    - name: Setup Rust toolchain and cache
+      uses: actions-rust-lang/setup-rust-toolchain@v1.6.0
+      # WARN: Keep the rustflags to prevent from the winget submission error: `CAQuietExec:  Error 0xc0000135`
+      with:
+        rustflags: ''
 
-      - name: Create output directory
-        run: mkdir output
+    - name: Setup Nushell
+      uses: hustcer/setup-nu@v3.8
+      with:
+        version: 0.86.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Copy files to output
-        run: |
-          cp target/release/nu target/release/nu_plugin_* output/
-          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: Release Nu Binary
+      id: nu
+      run: nu .github/workflows/release-pkg.nu
+      env:
+        RELEASE_TYPE: full
+        OS: ${{ matrix.os }}
+        REF: ${{ github.ref }}
+        TARGET: ${{ matrix.target }}
+        _EXTRA_: ${{ matrix.extra }}
+        TARGET_RUSTFLAGS: ${{ matrix.target_rustflags }}
 
-      - name: Upload artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: macos
-          path: output/*
-
-  windows:
-    name: Build Windows
-    runs-on: windows-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: Set up cargo
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-
-      - name: Add cargo-wix subcommand
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-wix
-
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --release --all --features=extra
-
-      - name: Create output directory
-        run: mkdir output
-
-      - name: Download Less Binary
-        run: Invoke-WebRequest -Uri "https://github.com/jftuga/less-Windows/releases/download/less-v562.0/less.exe" -OutFile "target\release\less.exe"
-
-      - name: Download Less License
-        run: Invoke-WebRequest -Uri "https://raw.githubusercontent.com/jftuga/less-Windows/master/LICENSE" -OutFile "target\release\LICENSE-for-less.txt"
-
-      - name: Copy files to output
-        run: |
-          cp target\release\nu.exe output\
-          cp LICENSE output\
-          cp target\release\LICENSE-for-less.txt output\
-          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\
-      # Note: If the version of `less.exe` needs to be changed, update this URL
-      # Similarly, if `less.exe` is checked into the repo, copy from the local path here
-      # moved this stuff down to create wix after we download less
-
-      - name: Create msi with wix
-        uses: actions-rs/cargo@v1
-        with:
-          command: wix
-          args: --no-build --nocapture --output target\wix\nushell-windows.msi
-
-      - name: Upload installer
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-installer
-          path: target\wix\nushell-windows.msi
-
-      - name: Upload zip
-        uses: actions/upload-artifact@v2
-        with:
-          name: windows-zip
-          path: output\*
-
-  release:
-    name: Publish Release
-    runs-on: ubuntu-latest
-    needs:
-      - linux
-      - macos
-      - windows
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-
-      - name: Determine Release Info
-        id: info
-        env:
-          GITHUB_REF: ${{ github.ref }}
-        run: |
-          VERSION=${GITHUB_REF##*/}
-          MAJOR=${VERSION%%.*}
-          MINOR=${VERSION%.*}
-          MINOR=${MINOR#*.}
-          PATCH=${VERSION##*.}
-          echo "::set-output name=version::${VERSION}"
-          echo "::set-output name=linuxdir::nu_${MAJOR}_${MINOR}_${PATCH}_linux"
-          echo "::set-output name=macosdir::nu_${MAJOR}_${MINOR}_${PATCH}_macOS"
-          echo "::set-output name=windowsdir::nu_${MAJOR}_${MINOR}_${PATCH}_windows"
-          echo "::set-output name=innerdir::nushell-${VERSION}"
-
-      - name: Create Release Draft
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ steps.info.outputs.version }} Release
-          draft: true
-
-      - name: Create Linux Directory
-        run: mkdir -p ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Download Linux Artifacts
-        uses: actions/download-artifact@v2
-        with:
-          name: linux
-          path: ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Restore Linux File Modes
-        run: |
-          chmod 755 ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}/nu*
-          chmod 755 ${{ steps.info.outputs.linuxdir }}/${{ steps.info.outputs.innerdir }}/libssl*
-
-      - name: Create Linux tarball
-        run: tar -zcvf ${{ steps.info.outputs.linuxdir }}.tar.gz ${{ steps.info.outputs.linuxdir }}
-
-      - name: Upload Linux Artifact
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./${{ steps.info.outputs.linuxdir }}.tar.gz
-          asset_name: ${{ steps.info.outputs.linuxdir }}.tar.gz
-          asset_content_type: application/gzip
-
-      - name: Create macOS Directory
-        run: mkdir -p ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Download macOS Artifacts
-        uses: actions/download-artifact@v2
-        with:
-          name: macos
-          path: ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Restore macOS File Modes
-        run: chmod 755 ${{ steps.info.outputs.macosdir }}/${{ steps.info.outputs.innerdir }}/nu*
-
-      - name: Create macOS Archive
-        run: zip -r ${{ steps.info.outputs.macosdir }}.zip ${{ steps.info.outputs.macosdir }}
-
-      - name: Upload macOS Artifact
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./${{ steps.info.outputs.macosdir }}.zip
-          asset_name: ${{ steps.info.outputs.macosdir }}.zip
-          asset_content_type: application/zip
-
-      - name: Create Windows Directory
-        run: mkdir -p ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Download Windows zip
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-zip
-          path: ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Show Windows Artifacts
-        run: ls -la ${{ steps.info.outputs.windowsdir }}/${{ steps.info.outputs.innerdir }}
-
-      - name: Create macOS Archive
-        run: zip -r ${{ steps.info.outputs.windowsdir }}.zip ${{ steps.info.outputs.windowsdir }}
-
-      - name: Upload Windows zip
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./${{ steps.info.outputs.windowsdir }}.zip
-          asset_name: ${{ steps.info.outputs.windowsdir }}.zip
-          asset_content_type: application/zip
-
-      - name: Download Windows installer
-        uses: actions/download-artifact@v2
-        with:
-          name: windows-installer
-          path: ./
-          
-      - name: Upload Windows installer
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ./nushell-windows.msi
-          asset_name: ${{ steps.info.outputs.windowsdir }}.msi
-          asset_content_type: applictaion/x-msi
+    # REF: https://github.com/marketplace/actions/gh-release
+    - name: Publish Archive
+      uses: softprops/action-gh-release@v0.1.15
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
+      with:
+        draft: true
+        files: ${{ steps.nu.outputs.archive }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/typos.yml

@@ -0,0 +1,15 @@
+name: Typos
+on: [pull_request]
+
+jobs:
+  run:
+    name: Spell Check with Typos
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Actions Repository
+        uses: actions/checkout@v4
+
+      - name: Check spelling
+        uses: crate-ci/typos@v1.17.0
+        with:
+          config: ./.github/.typos.toml

.github/workflows/winget-submission.yml

@@ -0,0 +1,29 @@
+name: Submit Nushell package to Windows Package Manager Community Repository
+
+on:
+  release:
+    types: [released]
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'Specific tag name'
+        required: true
+        type: string
+
+jobs:
+
+  winget:
+    name: Publish winget package
+    runs-on: ubuntu-latest
+    steps:
+      - name: Submit package to Windows Package Manager Community Repository
+        uses: vedantmgoyal2009/winget-releaser@v2
+        with:
+          identifier: Nushell.Nushell
+          # Exclude all `*-msvc-full.msi` full release files,
+          # and only the default `*msvc.msi` files will be included
+          installers-regex: 'msvc\.msi$'
+          version: ${{ inputs.tag_name || github.event.release.tag_name }}
+          release-tag: ${{ inputs.tag_name || github.event.release.tag_name }}
+          token: ${{ secrets.NUSHELL_PAT }}
+          fork-user: fdncred

.gitignore

@@ -4,6 +4,7 @@
 history.txt
 tests/fixtures/nuplayground
 crates/*/target
+.mailmap
 
 # Debian/Ubuntu
 debian/.debhelper/
@@ -20,3 +21,32 @@ debian/nu/
 
 # VSCode's IDE items
 .vscode/*
+
+# JetBrains' Fleet IDE
+.fleet/*
+
+# Visual Studio Extension SourceGear Rust items
+VSWorkspaceSettings.json
+unstable_cargo_features.txt
+
+# Helix configuration folder
+.helix/*
+.helix
+
+# Coverage tools
+lcov.info
+tarpaulin-report.html
+
+# Visual Studio
+.vs/*
+*.rsproj
+*.rsproj.user
+*.sln
+*.code-workspace
+
+# direnv
+.direnv/
+.envrc
+
+# pre-commit-hooks
+.pre-commit-config.yaml

.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

@@ -1,21 +1,47 @@
 # Contributing
 
-Welcome to nushell!
+Welcome to Nushell and thank you for considering contributing!
 
-*Note: for a more complete guide see [The nu contributor book](https://www.nushell.sh/contributor-book/)*
+## Table of contents
+- [Proposing design changes](#proposing-design-changes)
+- [Developing](#developing)
+  - [Setup](#setup)
+  - [Tests](#tests)
+  - [Useful commands](#useful-commands)
+  - [Debugging tips](#debugging-tips)
+- [Git etiquette](#git-etiquette)
+- [License](#license)
 
-For speedy contributions open it in Gitpod, nu will be pre-installed with the latest build in a VSCode like editor all from your browser.
+## Other helpful resources
 
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/nushell/nushell)
+More resources can be found in the nascent [developer documentation](devdocs/README.md) in this repo.
 
-To get live support from the community see our [Discord](https://discordapp.com/invite/NtAbbGn), [Twitter](https://twitter.com/nu_shell) or file an issue or feature request here on [GitHub](https://github.com/nushell/nushell/issues/new/choose)!
-<!--WIP-->
+- [Developer FAQ](FAQ.md)
+- [Platform support policy](PLATFORM_SUPPORT.md)
+- [Our Rust style](devdocs/rust_style.md)
+
+## Proposing design changes
+
+First of all, before diving into the code, if you want to create a new feature, change something significantly, and especially if the change is user-facing, it is a good practice to first get an approval from the core team before starting to work on it.
+This saves both your and our time if we realize the change needs to go another direction before spending time on it.
+So, please, reach out and tell us what you want to do.
+This will significantly increase the chance of your PR being accepted.
+
+The review process can be summarized as follows:
+1. You want to make some change to Nushell that is more involved than simple bug-fixing.
+2. Go to [Discord](https://discordapp.com/invite/NtAbbGn) or a [GitHub issue](https://github.com/nushell/nushell/issues/new/choose) and chat with some core team members and/or other contributors about it.
+3. After getting a green light from the core team, implement the feature, open a pull request (PR) and write a concise but comprehensive description of the change.
+4. If your PR includes any use-facing features (such as adding a flag to a command), clearly list them in the PR description.
+5. Then, core team members and other regular contributors will review the PR and suggest changes.
+6. When we all agree, the PR will be merged.
+7. If your PR includes any user-facing features, make sure the changes are also reflected in [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged.
+8. Congratulate yourself, you just improved Nushell! :-)
 
 ## Developing
 
-### Set up
+### Setup
 
-This is no different than other Rust projects.
+Nushell requires a recent Rust toolchain and some dependencies; [refer to the Nu Book for up-to-date requirements](https://www.nushell.sh/book/installation.html#build-from-source). After installing dependencies, you should be able to clone+build Nu like any other Rust project:
 
 ```bash
 git clone https://github.com/nushell/nushell
@@ -23,53 +49,199 @@ cd nushell
 cargo build
 ```
 
+### Tests
+
+It is good practice to cover your changes with a test. Also, try to think about corner cases and various ways how your changes could break. Cover those in the tests as well.
+
+Tests can be found in different places:
+* `/tests`
+* `src/tests`
+* command examples
+* crate-specific tests
+
+Most of the tests are built upon the `nu-test-support` crate. For testing specific features, such as running Nushell in a REPL mode, we have so called "testbins". For simple tests, you can find `run_test()` and `fail_test()` functions.
+
 ### Useful Commands
 
+As Nushell is built using a cargo workspace consisting of multiple crates keep in mind that you may need to pass additional flags compared to how you may be used to it from a single crate project.
+Read cargo's documentation for more details: https://doc.rust-lang.org/cargo/reference/workspaces.html
+
 - Build and run Nushell:
 
-  ```shell
-  cargo build --release && cargo run --release
+  ```nushell
+  cargo run
   ```
 
-- Build and run with extra features:
-  ```shell
-  cargo build --release --features=extra && cargo run --release --features=extra
+- Build and run with dataframe support.
+  ```nushell
+  cargo run --features=dataframe
   ```
 
 - Run Clippy on Nushell:
 
-  ```shell
-  cargo clippy --all --features=stable
+  ```nushell
+  cargo clippy --workspace -- -D warnings -D clippy::unwrap_used
+  ```
+  or via the `toolkit.nu` command:
+  ```nushell
+  use toolkit.nu clippy
+  clippy
   ```
 
 - Run all tests:
 
-  ```shell
-  cargo test --all --features=stable
+  ```nushell
+  cargo test --workspace
+  ```
+
+  along with dataframe tests
+
+  ```nushell
+  cargo test --workspace --features=dataframe
+  ```
+  or via the `toolkit.nu` command:
+  ```nushell
+  use toolkit.nu test
+  test
   ```
 
 - Run all tests for a specific command
 
-  ```shell
+  ```nushell
   cargo test --package nu-cli --test main -- commands::<command_name_here>
   ```
 
 - Check to see if there are code formatting issues
 
-  ```shell
+  ```nushell
   cargo fmt --all -- --check
   ```
+  or via the `toolkit.nu` command:
+  ```nushell
+  use toolkit.nu fmt
+  fmt --check
+  ```
 
 - Format the code in the project
 
-  ```shell
+  ```nushell
   cargo fmt --all
   ```
+  or via the `toolkit.nu` command:
+  ```nushell
+  use toolkit.nu fmt
+  fmt
+  ```
+
+- Set up `git` hooks to check formatting and run `clippy` before committing and pushing:
+
+  ```nushell
+  use toolkit.nu setup-git-hooks
+  setup-git-hooks
+  ```
+  _Unfortunately, this hook isn't available on Windows._
 
 ### Debugging Tips
 
 - To view verbose logs when developing, enable the `trace` log level.
 
-  ```shell
-  cargo build --release --features=extra && cargo run --release --features=extra -- --loglevel trace
+  ```nushell
+  cargo run --release -- --log-level trace
   ```
+
+- To redirect trace logs to a file, enable the `--log-target file` switch.
+  ```nushell
+  cargo run --release -- --log-level trace --log-target file
+  open $"($nu.temp-path)/nu-($nu.pid).log"
+  ```
+
+## Git etiquette
+
+As nushell thrives on its broad base of volunteer contributors and maintainers with different backgrounds we have a few guidelines for how we best utilize git and GitHub for our contributions. We strive to balance three goals with those recommendations:
+
+1. The **volunteer maintainers and contributors** can easily follow the changes you propose, gauge the impact, and come to help you or make a decision.
+2. **You as a contributor** can focus most of your time on improving the quality of the nushell project and contributing your expertise to the code or documentation.
+3. Making sure we can trace back *why* decisions were made in the past.
+This includes discarded approaches. Also we want to quickly identify regressions and fix when something broke.
+
+### How we merge PRs
+
+In general the maintainers **squash** all changes of your PR into a single commit when merging.
+
+This keeps a clean enough linear history, while not forcing you to conform to a too strict style while iterating in your PR or fixing small problems. As an added benefit the commits on the `main` branch are tied to the discussion that happened in the PR through their `#1234` issue number.
+
+> **Note**
+> **Pro advice:** In some circumstances, we can agree on rebase-merging a particularly large but connected PR as a series of atomic commits onto the `main` branch to ensure we can more easily revert or bisect particular aspects.
+
+### A good PR makes a change!
+
+As a result of this PR-centric strategy and the general goal that the reviewers should easily understand your change, the **PR title and description matters** a great deal!
+
+Make sure your description is **concise** but contains all relevant information and context.
+This means demonstrating what changes, ideally through nushell code or output **examples**.
+Furthermore links to technical documentation or instructions for folks that want to play with your change make the review process much easier.
+
+> **Note**
+> Try to follow the suggestions in our PR message template to make sure we can quickly focus on the technical merits and impact on the users.
+
+#### A PR should limit itself to a single functional change or related set of same changes.
+
+Mixing different changes in the same PR will make the review process much harder. A PR might get stuck on one aspect while we would actually like to land another change. Furthermore, if we are forced to revert a change, mixing and matching different aspects makes fixing bugs or regressions much harder.
+
+Thus, please try to **separate out unrelated changes**!
+**Don't** mix unrelated refactors with a potentially contested change.
+Stylistic fixes and housekeeping can be bundled up into singular PRs.
+
+#### Guidelines for the PR title
+
+The PR title should be concise but contain everything for a contributor to know if they should help out in the review of this particular change.
+
+**DON'T**
+- `Update file/in/some/deeply/nested/path.rs`
+  - Why are you making this change?
+- `Fix 2134`
+  - What has to be fixed?
+  - Hard to follow when not online on GitHub.
+- ``Ignore `~` expansion``
+  - In what context should this change take effect?
+- `[feature] refactor the whole parser and also make nushell indentation-sensitive, upgrade to using Cpython. Let me know what you think!`
+  - Be concise
+  - Maybe break up into smaller commits or PRs if the title already appears too long?
+
+**DO**
+- Mention the nushell feature or command that is affected.
+  - ``Fix URL parsing in `http get` (issue #1234)``
+- You can mention the issue number if other context is there.
+  - In general, mention all related issues in the description to crosslink (e.g. `Fixes #1234`, `Closes #6789`)
+- For internal changes mention the area or symbols affected if it helps to clarify
+  - ``Factor out `quote_string()` from parser to reuse in `explore` ``
+
+### Review process / Merge conflicts
+
+> **Note**
+> Keep in mind that the maintainers are volunteers that need to allocate their attention to several different areas and active PRs. We will try to get back to you as soon as possible.
+
+You can help us to make the review process a smooth experience:
+- Testing:
+  - We generally review in detail after all the tests pass. Let us know if there is a problem you want to discuss to fix a test failure or forces us to accept a breaking change.
+  - If you fix a bug, it is highly recommended that you add a test that reproduces the original issue/panic in a minimal form.
+  - In general, added tests help us to understand which assumptions go into a particular addition/change.
+  - Try to also test corner cases where those assumptions might break. This can be more valuable than simply adding many similar tests.
+- Commit history inside a PR during code review:
+  - Good **atomic commits** can help follow larger changes, but we are not pedantic.
+  - We don't shame fixup commits while you try to figure out a problem. They can help others see what you tried and what didn't work. (see our [squash policy](#how-we-merge-prs))
+  - During active review constant **force pushing** just to amend changes can be confusing!
+    - GitHub's UI presents reviewers with less options to compare diffs
+    - fetched branches for experimentation become invalid!
+    - the notification a maintainer receives has a low signal-to-noise ratio
+  - Git pros *can* use their judgement to rebase/squash to clean up the history *if it aids the understanding* of a larger change during review
+- Merge conflicts:
+  - In general you should take care of resolving merge conflicts.
+    - Use your judgement whether to `git merge main` or to `git rebase main`
+    - Choose what simplifies having confidence in the conflict resolution and the review. **Merge commits in your branch are OK** in the squash model.
+  - Feel free to notify your reviewers or affected PR authors if your change might cause larger conflicts with another change.
+  - During the rollup of multiple PRs, we may choose to resolve merge conflicts and CI failures ourselves. (Allow maintainers to push to your branch to enable us to do this quickly.)
+ 
+## License
+
+We use the [MIT License](https://github.com/nushell/nushell/blob/main/LICENSE) in all of our Nushell projects. If you are including or referencing a crate that uses the [GPL License](https://www.gnu.org/licenses/gpl-3.0.en.html#license-text) unfortunately we will not be able to accept your PR.

Cargo.toml

@@ -1,275 +1,185 @@
 [package]
-authors = ["The Nu Project Contributors"]
+authors = ["The Nushell Project Developers"]
+build = "scripts/build.rs"
 default-run = "nu"
 description = "A new type of shell"
 documentation = "https://www.nushell.sh/book/"
-edition = "2018"
+edition = "2021"
 exclude = ["images"]
 homepage = "https://www.nushell.sh"
 license = "MIT"
 name = "nu"
-readme = "README.md"
 repository = "https://github.com/nushell/nushell"
-version = "0.33.0"
-
-[workspace]
-members = ["crates/*/"]
+rust-version = "1.72.1"
+version = "0.88.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[package.metadata.binstall]
+pkg-url = "{ repo }/releases/download/{ version }/{ name }-{ version }-{ target }.{ archive-format }"
+pkg-fmt = "tgz"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
+pkg-fmt = "zip"
+
+[workspace]
+members = [
+	"crates/nu-cli",
+	"crates/nu-engine",
+	"crates/nu-parser",
+	"crates/nu-system",
+	"crates/nu-cmd-base",
+	"crates/nu-cmd-extra",
+	"crates/nu-cmd-lang",
+	"crates/nu-cmd-dataframe",
+	"crates/nu-command",
+	"crates/nu-color-config",
+	"crates/nu-explore",
+	"crates/nu-json",
+	"crates/nu-lsp",
+	"crates/nu-pretty-hex",
+	"crates/nu-protocol",
+	"crates/nu-plugin",
+	"crates/nu_plugin_inc",
+	"crates/nu_plugin_gstat",
+	"crates/nu_plugin_example",
+	"crates/nu_plugin_query",
+	"crates/nu_plugin_custom_values",
+	"crates/nu_plugin_formats",
+	"crates/nu-std",
+	"crates/nu-table",
+	"crates/nu-term-grid",
+	"crates/nu-utils",
+]
+
 [dependencies]
-nu-cli = { version="0.33.0", path="./crates/nu-cli", default-features=false }
-nu-command = { version="0.33.0", path="./crates/nu-command" }
-nu-completion = { version="0.33.0", path="./crates/nu-completion" }
-nu-data = { version="0.33.0", path="./crates/nu-data" }
-nu-engine = { version="0.33.0", path="./crates/nu-engine" }
-nu-errors = { version="0.33.0", path="./crates/nu-errors" }
-nu-parser = { version="0.33.0", path="./crates/nu-parser" }
-nu-path = { version="0.33.0", path="./crates/nu-path" }
-nu-plugin = { version="0.33.0", path="./crates/nu-plugin" }
-nu-protocol = { version="0.33.0", path="./crates/nu-protocol" }
-nu-source = { version="0.33.0", path="./crates/nu-source" }
-nu-value-ext = { version="0.33.0", path="./crates/nu-value-ext" }
+nu-cli = { path = "./crates/nu-cli", version = "0.88.2" }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.88.2" }
+nu-cmd-base = { path = "./crates/nu-cmd-base", version = "0.88.2" }
+nu-cmd-lang = { path = "./crates/nu-cmd-lang", version = "0.88.2" }
+nu-cmd-dataframe = { path = "./crates/nu-cmd-dataframe", version = "0.88.2", features = ["dataframe"], optional = true }
+nu-cmd-extra = { path = "./crates/nu-cmd-extra", version = "0.88.2", optional = true }
+nu-command = { path = "./crates/nu-command", version = "0.88.2" }
+nu-engine = { path = "./crates/nu-engine", version = "0.88.2" }
+nu-explore = { path = "./crates/nu-explore", version = "0.88.2" }
+nu-json = { path = "./crates/nu-json", version = "0.88.2" }
+nu-lsp = { path = "./crates/nu-lsp/", version = "0.88.2" }
+nu-parser = { path = "./crates/nu-parser", version = "0.88.2" }
+nu-path = { path = "./crates/nu-path", version = "0.88.2" }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.88.2" }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.88.2" }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.88.2" }
+nu-system = { path = "./crates/nu-system", version = "0.88.2" }
+nu-table = { path = "./crates/nu-table", version = "0.88.2" }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.88.2" }
+nu-std = { path = "./crates/nu-std", version = "0.88.2" }
+nu-utils = { path = "./crates/nu-utils", version = "0.88.2" }
 
-nu_plugin_binaryview = { version="0.33.0", path="./crates/nu_plugin_binaryview", optional=true }
-nu_plugin_chart = { version="0.33.0", path="./crates/nu_plugin_chart", optional=true }
-nu_plugin_fetch = { version="0.33.0", path="./crates/nu_plugin_fetch", optional=true }
-nu_plugin_from_bson = { version="0.33.0", path="./crates/nu_plugin_from_bson", optional=true }
-nu_plugin_from_sqlite = { version="0.33.0", path="./crates/nu_plugin_from_sqlite", optional=true }
-nu_plugin_inc = { version="0.33.0", path="./crates/nu_plugin_inc", optional=true }
-nu_plugin_match = { version="0.33.0", path="./crates/nu_plugin_match", optional=true }
-nu_plugin_post = { version="0.33.0", path="./crates/nu_plugin_post", optional=true }
-nu_plugin_ps = { version="0.33.0", path="./crates/nu_plugin_ps", optional=true }
-nu_plugin_query_json = { version="0.33.0", path="./crates/nu_plugin_query_json", optional=true }
-nu_plugin_s3 = { version="0.33.0", path="./crates/nu_plugin_s3", optional=true }
-nu_plugin_selector = { version="0.33.0", path="./crates/nu_plugin_selector", optional=true }
-nu_plugin_start = { version="0.33.0", path="./crates/nu_plugin_start", optional=true }
-nu_plugin_sys = { version="0.33.0", path="./crates/nu_plugin_sys", optional=true }
-nu_plugin_textview = { version="0.33.0", path="./crates/nu_plugin_textview", optional=true }
-nu_plugin_to_bson = { version="0.33.0", path="./crates/nu_plugin_to_bson", optional=true }
-nu_plugin_to_sqlite = { version="0.33.0", path="./crates/nu_plugin_to_sqlite", optional=true }
-nu_plugin_tree = { version="0.33.0", path="./crates/nu_plugin_tree", optional=true }
-nu_plugin_xpath = { version="0.33.0", path="./crates/nu_plugin_xpath", optional=true }
+nu-ansi-term = "0.49.0"
+reedline = { version = "0.27.0", features = ["bashisms", "sqlite"] }
 
-# 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"
+crossterm = "0.27"
+ctrlc = "3.4"
+log = "0.4"
+miette = { version = "5.10", features = ["fancy-no-backtrace"] }
+mimalloc = { version = "0.1.37", default-features = false, optional = true }
+serde_json = "1.0"
+simplelog = "0.12"
+time = "0.3"
+
+[target.'cfg(not(target_os = "windows"))'.dependencies]
+# Our dependencies don't use OpenSSL on Windows
+openssl = { version = "0.10", features = ["vendored"], optional = true }
+signal-hook = { version = "0.3", default-features = false }
+
+[target.'cfg(windows)'.build-dependencies]
+winresource = "0.1"
+
+[target.'cfg(target_family = "unix")'.dependencies]
+nix = { version = "0.27", default-features = false, features = [
+	"signal",
+	"process",
+	"fs",
+	"term",
+] }
 
 [dev-dependencies]
-nu-test-support = { version="0.33.0", path="./crates/nu-test-support" }
-dunce = "1.0.1"
-serial_test = "0.5.1"
-hamcrest2 = "0.3.0"
-
-
-[build-dependencies]
+nu-test-support = { path = "./crates/nu-test-support", version = "0.88.2" }
+assert_cmd = "2.0"
+criterion = "0.5"
+pretty_assertions = "1.4"
+rstest = { version = "0.18", default-features = false }
+serial_test = "2.0"
+tempfile = "3.8"
 
 [features]
-ctrlc-support = ["nu-cli/ctrlc", "nu-command/ctrlc"]
-ptree-support = ["nu-cli/ptree", "nu-command/ptree"]
-rustyline-support = ["nu-cli/rustyline-support", "nu-command/rustyline-support"]
-term-support = ["nu-cli/term", "nu-command/term"]
-uuid-support = ["nu-cli/uuid_crate", "nu-command/uuid_crate"]
-which-support = ["nu-cli/which", "nu-command/which", "nu-engine/which"]
-executable-support = ["nu-completion/is_executable"]
-
-default = [
-    "nu-cli/shadow-rs",
-    "sys",
-    "ps",
-    "ctrlc-support",
-    "which-support",
-    "term-support",
-    "rustyline-support",
-    "match",
-    "post",
-    "fetch",
-    "zip-support",
-    "executable-support",
+plugin = [
+	"nu-plugin",
+	"nu-cli/plugin",
+	"nu-parser/plugin",
+	"nu-command/plugin",
+	"nu-protocol/plugin",
+	"nu-engine/plugin",
 ]
-
+default = ["plugin", "which-support", "trash-support", "sqlite", "mimalloc"]
 stable = ["default"]
-extra = [
-    "default",
-    "binaryview",
-    "inc",
-    "tree",
-    "ptree-support",
-    "textview",
-    "clipboard-cli",
-    "trash-support",
-    "uuid-support",
-    "start",
-    "bson",
-    "sqlite",
-    "s3",
-    "chart",
-    "xpath",
-    "selector",
-    "query-json",
-]
+wasi = ["nu-cmd-lang/wasi"]
+# NOTE: individual features are also passed to `nu-cmd-lang` that uses them to generate the feature matrix in the `version` command
 
-wasi = ["inc", "match", "ptree-support", "match", "tree", "rustyline-support"]
+# Enable to statically link OpenSSL (perl is required, to build OpenSSL https://docs.rs/openssl/latest/openssl/);
+# otherwise the system version will be used. Not enabled by default because it takes a while to build
+static-link-openssl = ["dep:openssl", "nu-cmd-lang/static-link-openssl"]
 
-trace = ["nu-parser/trace"]
+mimalloc = ["nu-cmd-lang/mimalloc", "dep:mimalloc"]
 
 # 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", "nu-cmd-lang/which-support"]
+trash-support = ["nu-command/trash-support", "nu-cmd-lang/trash-support"]
 
-# Extra
-binaryview = ["nu_plugin_binaryview"]
-bson = ["nu_plugin_from_bson", "nu_plugin_to_bson"]
-chart = ["nu_plugin_chart"]
-clipboard-cli = ["nu-cli/clipboard-cli", "nu-command/clipboard-cli"]
-query-json = ["nu_plugin_query_json"]
-s3 = ["nu_plugin_s3"]
-selector = ["nu_plugin_selector"]
-sqlite = ["nu_plugin_from_sqlite", "nu_plugin_to_sqlite"]
-start = ["nu_plugin_start"]
-trash-support = [
-    "nu-cli/trash-support",
-    "nu-command/trash-support",
-    "nu-engine/trash-support",
-]
-tree = ["nu_plugin_tree"]
-xpath = ["nu_plugin_xpath"]
-zip-support = ["nu-cli/zip", "nu-command/zip"]
+# Extra feature for nushell
+extra = ["dep:nu-cmd-extra", "nu-cmd-lang/extra"]
 
-#This is disabled in extra for now
-table-pager = ["nu-command/table-pager"]
-
-#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",
-]
+# Dataframe feature for nushell
+dataframe = ["dep:nu-cmd-dataframe", "nu-cmd-lang/dataframe"]
 
+# SQLite commands for nushell
+sqlite = ["nu-command/sqlite", "nu-cmd-lang/sqlite"]
 
 [profile.release]
-#strip = "symbols" #Couldn't get working +nightly
-codegen-units = 1 #Reduce parallel codegen units
-lto = true #Link Time Optimization
-# opt-level = 'z' #Optimize for size
-# debug = true
+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"]
+# build with `cargo build --profile profiling`
+# to analyze performance with tooling like linux perf
+[profile.profiling]
+inherits = "release"
+strip = false
+debug = true
 
-[[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 ci`
+# to analyze performance with tooling like linux perf
+[profile.ci]
+inherits = "dev"
+strip = false
+debug = false
 
 # Main nu binary
 [[bin]]
 name = "nu"
 path = "src/main.rs"
+bench = false
+
+# To use a development version of a dependency please use a global override here
+# changing versions in each sub-crate of the workspace is tedious
+[patch.crates-io]
+reedline = { git = "https://github.com/nushell/reedline.git", branch = "main" }
+# nu-ansi-term = {git = "https://github.com/nushell/nu-ansi-term.git", branch = "main"}
+# uu_cp = { git = "https://github.com/uutils/coreutils.git", branch = "main" }
+
+# Criterion benchmarking setup
+# Run all benchmarks with `cargo bench`
+# Run individual benchmarks like `cargo bench -- <regex>` e.g. `cargo bench -- parse`
+[[bench]]
+name = "benchmarks"
+harness = false

Cross.toml

@@ -0,0 +1,18 @@
+# Configuration for cross-rs: https://github.com/cross-rs/cross
+# Run cross-rs like this:
+# cross build --target aarch64-unknown-linux-gnu --release
+# or
+# cross build --target aarch64-unknown-linux-musl --release --features=static-link-openssl
+
+[target.aarch64-unknown-linux-gnu]
+pre-build = [
+    "dpkg --add-architecture $CROSS_DEB_ARCH",
+    "apt-get update && apt-get install --assume-yes libssl-dev:$CROSS_DEB_ARCH clang"
+]
+
+#  NOTE: for musl you will need to build with --features=static-link-openssl
+[target.aarch64-unknown-linux-musl]
+pre-build = [
+    "dpkg --add-architecture $CROSS_DEB_ARCH",
+    "apt-get update && apt-get install --assume-yes clang"
+]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 - 2021 Yehuda Katz, Jonathan Turner
+Copyright (c) 2019 - 2023 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

Makefile.toml

@@ -1,24 +0,0 @@
-[tasks.lalrpop]
-install_crate = { crate_name = "lalrpop", binary = "lalrpop", test_arg = "--help" }
-command = "lalrpop"
-args = ["src/parser/parser.lalrpop"]
-
-[tasks.baseline]
-command = "cargo"
-args = ["build", "--bins"]
-
-[tasks.run]
-command = "cargo"
-args = ["run"]
-dependencies = ["baseline"]
-
-[tasks.test]
-command = "cargo"
-args = ["test"]
-dependencies = ["baseline"]
-
-[tasks.check]
-command = "cargo"
-args = ["check"]
-dependencies = ["baseline"]
-

README.build.txt

@@ -1 +0,0 @@
-Nu will look for the plugins in your PATH on startup. While nu will have some functionality without them, for full functionality you'll need to copy them into your path so they can be loaded.

README.md

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

benches/README.md

@@ -0,0 +1,7 @@
+# Criterion benchmarks
+
+These are benchmarks using [Criterion](https://github.com/bheisler/criterion.rs), a microbenchmarking tool for Rust.
+
+Run all benchmarks with `cargo bench`
+
+Or run individual benchmarks like `cargo bench -- <regex>` e.g. `cargo bench -- parse`

benches/benchmarks.rs

@@ -0,0 +1,190 @@
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use nu_cli::eval_source;
+use nu_parser::parse;
+use nu_plugin::{EncodingType, PluginResponse};
+use nu_protocol::{engine::EngineState, PipelineData, Span, Value};
+use nu_utils::{get_default_config, get_default_env};
+use std::path::{Path, PathBuf};
+
+fn load_bench_commands() -> EngineState {
+    nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
+}
+
+fn canonicalize_path(engine_state: &EngineState, path: &Path) -> PathBuf {
+    let cwd = engine_state.current_work_dir();
+
+    if path.exists() {
+        match nu_path::canonicalize_with(path, cwd) {
+            Ok(canon_path) => canon_path,
+            Err(_) => path.to_owned(),
+        }
+    } else {
+        path.to_owned()
+    }
+}
+
+fn get_home_path(engine_state: &EngineState) -> PathBuf {
+    nu_path::home_dir()
+        .map(|path| canonicalize_path(engine_state, &path))
+        .unwrap_or_default()
+}
+
+// FIXME: All benchmarks live in this 1 file to speed up build times when benchmarking.
+// When the *_benchmarks functions were in different files, `cargo bench` would build
+// an executable for every single one - incredibly slowly. Would be nice to figure out
+// a way to split things up again.
+
+fn parser_benchmarks(c: &mut Criterion) {
+    let mut engine_state = load_bench_commands();
+    let home_path = get_home_path(&engine_state);
+
+    // parsing config.nu breaks without PWD set, so set a valid path
+    engine_state.add_env_var(
+        "PWD".into(),
+        Value::string(home_path.to_string_lossy(), Span::test_data()),
+    );
+
+    let default_env = get_default_env().as_bytes();
+    c.bench_function("parse_default_env_file", |b| {
+        b.iter_batched(
+            || nu_protocol::engine::StateWorkingSet::new(&engine_state),
+            |mut working_set| parse(&mut working_set, None, default_env, false),
+            BatchSize::SmallInput,
+        )
+    });
+
+    let default_config = get_default_config().as_bytes();
+    c.bench_function("parse_default_config_file", |b| {
+        b.iter_batched(
+            || nu_protocol::engine::StateWorkingSet::new(&engine_state),
+            |mut working_set| parse(&mut working_set, None, default_config, false),
+            BatchSize::SmallInput,
+        )
+    });
+
+    c.bench_function("eval default_env.nu", |b| {
+        b.iter(|| {
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_env().as_bytes(),
+                "default_env.nu",
+                PipelineData::empty(),
+                false,
+            )
+        })
+    });
+
+    c.bench_function("eval default_config.nu", |b| {
+        b.iter(|| {
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_config().as_bytes(),
+                "default_config.nu",
+                PipelineData::empty(),
+                false,
+            )
+        })
+    });
+}
+
+fn eval_benchmarks(c: &mut Criterion) {
+    let mut engine_state = load_bench_commands();
+    let home_path = get_home_path(&engine_state);
+
+    // parsing config.nu breaks without PWD set, so set a valid path
+    engine_state.add_env_var(
+        "PWD".into(),
+        Value::string(home_path.to_string_lossy(), Span::test_data()),
+    );
+
+    c.bench_function("eval default_env.nu", |b| {
+        b.iter(|| {
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_env().as_bytes(),
+                "default_env.nu",
+                PipelineData::empty(),
+                false,
+            )
+        })
+    });
+
+    c.bench_function("eval default_config.nu", |b| {
+        b.iter(|| {
+            let mut stack = nu_protocol::engine::Stack::new();
+            eval_source(
+                &mut engine_state,
+                &mut stack,
+                get_default_config().as_bytes(),
+                "default_config.nu",
+                PipelineData::empty(),
+                false,
+            )
+        })
+    });
+}
+
+// generate a new table data with `row_cnt` rows, `col_cnt` columns.
+fn encoding_test_data(row_cnt: usize, col_cnt: usize) -> Value {
+    let record = Value::test_record(
+        (0..col_cnt)
+            .map(|x| (format!("col_{x}"), Value::test_int(x as i64)))
+            .collect(),
+    );
+
+    Value::list(vec![record; row_cnt], Span::test_data())
+}
+
+fn encoding_benchmarks(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Encoding");
+    let test_cnt_pairs = [(100, 5), (100, 15), (10000, 5), (10000, 15)];
+    for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
+        for fmt in ["json", "msgpack"] {
+            group.bench_function(&format!("{fmt} encode {row_cnt} * {col_cnt}"), |b| {
+                let mut res = vec![];
+                let test_data =
+                    PluginResponse::Value(Box::new(encoding_test_data(row_cnt, col_cnt)));
+                let encoder = EncodingType::try_from_bytes(fmt.as_bytes()).unwrap();
+                b.iter(|| encoder.encode_response(&test_data, &mut res))
+            });
+        }
+    }
+    group.finish();
+}
+
+fn decoding_benchmarks(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Decoding");
+    let test_cnt_pairs = [(100, 5), (100, 15), (10000, 5), (10000, 15)];
+    for (row_cnt, col_cnt) in test_cnt_pairs.into_iter() {
+        for fmt in ["json", "msgpack"] {
+            group.bench_function(&format!("{fmt} decode for {row_cnt} * {col_cnt}"), |b| {
+                let mut res = vec![];
+                let test_data =
+                    PluginResponse::Value(Box::new(encoding_test_data(row_cnt, col_cnt)));
+                let encoder = EncodingType::try_from_bytes(fmt.as_bytes()).unwrap();
+                encoder.encode_response(&test_data, &mut res).unwrap();
+                let mut binary_data = std::io::Cursor::new(res);
+                b.iter(|| {
+                    binary_data.set_position(0);
+                    encoder.decode_response(&mut binary_data)
+                })
+            });
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    parser_benchmarks,
+    eval_benchmarks,
+    encoding_benchmarks,
+    decoding_benchmarks
+);
+criterion_main!(benches);

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.33.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/LICENCE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Benjamin Sago
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

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,130 +1,46 @@
 [package]
-authors = ["The Nu Project Contributors"]
-build = "build.rs"
-description = "CLI for nushell"
-edition = "2018"
+authors = ["The Nushell Project Developers"]
+description = "CLI-related functionality for Nushell"
+repository = "https://github.com/nushell/nushell/tree/main/crates/nu-cli"
+edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.33.0"
+version = "0.88.2"
 
 [lib]
-doctest = false
-
-[dependencies]
-nu-completion = { version="0.33.0", path="../nu-completion" }
-nu-command = { version="0.33.0", path="../nu-command" }
-nu-data = { version="0.33.0", path="../nu-data" }
-nu-engine = { version="0.33.0", path="../nu-engine" }
-nu-errors = { version="0.33.0", path="../nu-errors" }
-nu-json = { version="0.33.0", path="../nu-json" }
-nu-parser = { version="0.33.0", path="../nu-parser" }
-nu-plugin = { version="0.33.0", path="../nu-plugin" }
-nu-protocol = { version="0.33.0", path="../nu-protocol" }
-nu-source = { version="0.33.0", path="../nu-source" }
-nu-stream = { version="0.33.0", path="../nu-stream" }
-nu-table = { version="0.33.0", path="../nu-table" }
-nu-test-support = { version="0.33.0", path="../nu-test-support" }
-nu-value-ext = { version="0.33.0", path="../nu-value-ext" }
-nu-ansi-term = { version="0.33.0", path="../nu-ansi-term" }
-nu-pretty-hex = { version="0.33.0", path="../nu-pretty-hex" }
-
-Inflector = "0.11"
-arboard = { version="1.1.0", optional=true }
-async-recursion = "0.3.2"
-async-trait = "0.1.42"
-base64 = "0.13.0"
-bigdecimal = { version="0.2.0", features=["serde"] }
-byte-unit = "4.0.9"
-bytes = "1.0.1"
-calamine = "0.17.0"
-chrono = { version="0.4.19", features=["serde"] }
-chrono-tz = "0.5.3"
-codespan-reporting = "0.11.0"
-csv = "1.1.5"
-ctrlc = { version="3.1.7", optional=true }
-derive-new = "0.5.8"
-directories-next = "2.0.0"
-dirs-next = "2.0.0"
-dtparse = "1.2.0"
-dunce = "1.0.1"
-eml-parser = "0.1.0"
-encoding_rs = "0.8.28"
-filesize = "0.2.0"
-fs_extra = "1.2.0"
-futures = { version="0.3.12", features=["compat", "io-compat"] }
-futures-util = "0.3.12"
-futures_codec = "0.4.1"
-getset = "0.1.1"
-glob = "0.3.0"
-htmlescape = "0.3.1"
-ical = "0.7.0"
-indexmap = { version="1.6.1", features=["serde-1"] }
-log = "0.4.14"
-pretty_env_logger = "0.4.0"
-meval = "0.2.0"
-num-bigint = { version="0.3.1", features=["serde"] }
-num-format = { version="0.4.0", features=["with-num-bigint"] }
-num-traits = "0.2.14"
-parking_lot = "0.11.1"
-pin-utils = "0.1.0"
-ptree = { version="0.3.1", optional=true }
-query_interface = "0.3.5"
-quick-xml = "0.21.0"
-rand = "0.8.3"
-rayon = "1.5.0"
-regex = "1.4.3"
-roxmltree = "0.14.0"
-rust-embed = "5.9.0"
-rustyline = { version="8.1.0", optional=true }
-serde = { version="1.0.123", features=["derive"] }
-serde_bytes = "0.11.5"
-serde_ini = "0.2.0"
-serde_json = "1.0.61"
-serde_urlencoded = "0.7.0"
-serde_yaml = "0.8.16"
-sha2 = "0.9.3"
-strip-ansi-escapes = "0.1.0"
-sxd-document = "0.3.2"
-sxd-xpath = "0.4.2"
-tempfile = "3.2.0"
-term = { version="0.7.0", optional=true }
-term_size = "0.3.2"
-termcolor = "1.1.2"
-titlecase = "1.1.0"
-toml = "0.5.8"
-trash = { version="1.3.0", optional=true }
-unicode-segmentation = "1.7.1"
-url = "2.1.1"
-uuid_crate = { package="uuid", version="0.8.2", features=["v4"], optional=true }
-which = { version="4.0.2", optional=true }
-zip = { version="0.5.9", optional=true }
-shadow-rs = { version="0.5", default-features=false, optional=true }
-
-[target.'cfg(unix)'.dependencies]
-umask = "1.0.0"
-users = "0.11.0"
-
-# TODO this will be possible with new dependency resolver
-#   (currently on nightly behind -Zfeatures=itarget):
-#   https://github.com/rust-lang/cargo/issues/7914
-#[target.'cfg(not(windows))'.dependencies]
-#num-format = {version = "0.4", features = ["with-system-locale"]}
-
-[dependencies.rusqlite]
-features = ["bundled", "blob"]
-optional = true
-version = "0.25.3"
-
-[build-dependencies]
-shadow-rs = "0.5"
+bench = false
 
 [dev-dependencies]
-quickcheck = "1.0.3"
-quickcheck_macros = "1.0.0"
+nu-cmd-lang = { path = "../nu-cmd-lang", version = "0.88.2" }
+nu-command = { path = "../nu-command", version = "0.88.2" }
+nu-test-support = { path = "../nu-test-support", version = "0.88.2" }
+rstest = { version = "0.18.1", default-features = false }
+
+[dependencies]
+nu-cmd-base = { path = "../nu-cmd-base", version = "0.88.2" }
+nu-engine = { path = "../nu-engine", version = "0.88.2" }
+nu-path = { path = "../nu-path", version = "0.88.2" }
+nu-parser = { path = "../nu-parser", version = "0.88.2" }
+nu-protocol = { path = "../nu-protocol", version = "0.88.2" }
+nu-utils = { path = "../nu-utils", version = "0.88.2" }
+nu-color-config = { path = "../nu-color-config", version = "0.88.2" }
+nu-ansi-term = "0.49.0"
+reedline = { version = "0.27.0", features = ["bashisms", "sqlite"] }
+
+chrono = { default-features = false, features = ["std"], version = "0.4" }
+crossterm = "0.27"
+fancy-regex = "0.12"
+fuzzy-matcher = "0.3"
+is_executable = "1.0"
+log = "0.4"
+miette = { version = "5.10", features = ["fancy-no-backtrace"] }
+once_cell = "1.18"
+percent-encoding = "2"
+pathdiff = "0.2"
+sysinfo = "0.30"
+unicode-segmentation = "1.10"
+uuid = { version = "1.6.0", features = ["v4"] }
+which = "5.0.0"
 
 [features]
-default = ["shadow-rs"]
-clipboard-cli = ["arboard"]
-rustyline-support = ["rustyline", "nu-engine/rustyline-support"]
-stable = []
-trash-support = ["trash"]
+plugin = []

crates/nu-cli/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 - 2023 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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,525 +0,0 @@
-mod logger;
-mod options;
-mod options_parser;
-
-pub use options::{CliOptions, NuScript, Options};
-use options_parser::{NuParser, OptionsParser};
-
-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 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> {
-        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)?;
-
-            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)?;
-            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();
-
-        use logger::{configure, debug_filters, logger, trace_filters};
-
-        logger(|builder| {
-            configure(&self, builder)?;
-            trace_filters(&self, builder)?;
-            debug_filters(&self, builder)?;
-
-            Ok(())
-        })?;
-
-        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 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(());
-        }
-
-        let context = crate::create_default_context(true)?;
-
-        if !self.skip_plugins() {
-            let _ = crate::register_plugins(&context);
-        }
-
-        #[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 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,100 +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,
-}
-
-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,
-        }
-    }
-}
-
-#[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);
-        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/cli.rs

@@ -1,474 +0,0 @@
-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()),
-    );
-    trace!(
-        "startup commands took {:?}",
-        startup_commands_start_time.elapsed()
-    );
-
-    //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()
-    };
-
-    // Don't load history if it's not necessary
-    if options.save_history {
-        let _ = rl.load_history(&history_path);
-    }
-
-    //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)
-    };
-
-    //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;
-
-    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()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use nu_engine::EvaluationContext;
-
-    #[quickcheck]
-    fn quickcheck_parse(data: String) -> bool {
-        let (tokens, err) = nu_parser::lex(&data, 0);
-        let (lite_block, err2) = nu_parser::parse_block(tokens);
-        if err.is_none() && err2.is_none() {
-            let context = EvaluationContext::basic();
-            let _ = nu_parser::classify_block(&lite_block, &context.scope);
-        }
-        true
-    }
-}

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

@@ -0,0 +1,129 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
+};
+use unicode_segmentation::UnicodeSegmentation;
+
+#[derive(Clone)]
+pub struct Commandline;
+
+impl Command for Commandline {
+    fn name(&self) -> &str {
+        "commandline"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("commandline")
+            .input_output_types(vec![
+                (Type::Nothing, Type::Nothing),
+                (Type::String, Type::String),
+            ])
+            .switch(
+                "cursor",
+                "Set or get the current cursor position",
+                Some('c'),
+            )
+            .switch(
+                "cursor-end",
+                "Set the current cursor position to the end of the buffer",
+                Some('e'),
+            )
+            .switch(
+                "append",
+                "appends the string to the end of the buffer",
+                Some('a'),
+            )
+            .switch(
+                "insert",
+                "inserts the string into the buffer at the cursor position",
+                Some('i'),
+            )
+            .switch(
+                "replace",
+                "replaces the current contents of the buffer (default)",
+                Some('r'),
+            )
+            .optional(
+                "cmd",
+                SyntaxShape::String,
+                "the string to perform the operation with",
+            )
+            .category(Category::Core)
+    }
+
+    fn usage(&self) -> &str {
+        "View or modify the current command line input buffer."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["repl", "interactive"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        if let Some(cmd) = call.opt::<Value>(engine_state, stack, 0)? {
+            let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+
+            if call.has_flag("cursor") {
+                let cmd_str = cmd.as_string()?;
+                match cmd_str.parse::<i64>() {
+                    Ok(n) => {
+                        repl.cursor_pos = if n <= 0 {
+                            0usize
+                        } else {
+                            repl.buffer
+                                .grapheme_indices(true)
+                                .map(|(i, _c)| i)
+                                .nth(n as usize)
+                                .unwrap_or(repl.buffer.len())
+                        }
+                    }
+                    Err(_) => {
+                        return Err(ShellError::CantConvert {
+                            to_type: "int".to_string(),
+                            from_type: "string".to_string(),
+                            span: cmd.span(),
+                            help: Some(format!(
+                                r#"string "{cmd_str}" does not represent a valid int"#
+                            )),
+                        })
+                    }
+                }
+            } else if call.has_flag("append") {
+                repl.buffer.push_str(&cmd.as_string()?);
+            } else if call.has_flag("insert") {
+                let cmd_str = cmd.as_string()?;
+                let cursor_pos = repl.cursor_pos;
+                repl.buffer.insert_str(cursor_pos, &cmd_str);
+                repl.cursor_pos += cmd_str.len();
+            } else {
+                repl.buffer = cmd.as_string()?;
+                repl.cursor_pos = repl.buffer.len();
+            }
+            Ok(Value::nothing(call.head).into_pipeline_data())
+        } else {
+            let mut repl = engine_state.repl_state.lock().expect("repl state mutex");
+            if call.has_flag("cursor-end") {
+                repl.cursor_pos = repl.buffer.graphemes(true).count();
+                Ok(Value::nothing(call.head).into_pipeline_data())
+            } else if call.has_flag("cursor") {
+                let char_pos = repl
+                    .buffer
+                    .grapheme_indices(true)
+                    .chain(std::iter::once((repl.buffer.len(), "")))
+                    .position(|(i, _c)| i == repl.cursor_pos)
+                    .expect("Cursor position isn't on a grapheme boundary");
+                Ok(Value::string(char_pos.to_string(), call.head).into_pipeline_data())
+            } else {
+                Ok(Value::string(repl.buffer.to_string(), call.head).into_pipeline_data())
+            }
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+use nu_protocol::engine::{EngineState, StateWorkingSet};
+
+use crate::commands::*;
+
+pub fn add_cli_context(mut engine_state: EngineState) -> EngineState {
+    let delta = {
+        let mut working_set = StateWorkingSet::new(&engine_state);
+
+        macro_rules! bind_command {
+            ( $( $command:expr ),* $(,)? ) => {
+                $( working_set.add_decl(Box::new($command)); )*
+            };
+        }
+
+        bind_command! {
+            Commandline,
+            History,
+            HistorySession,
+            Keybindings,
+            KeybindingsDefault,
+            KeybindingsList,
+            KeybindingsListen,
+        };
+
+        working_set.render()
+    };
+
+    if let Err(err) = engine_state.merge_delta(delta) {
+        eprintln!("Error creating CLI command context: {err:?}");
+    }
+
+    engine_state
+}

crates/nu-cli/src/commands/history/history_.rs

@@ -0,0 +1,240 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    record, Category, Example, HistoryFileFormat, IntoInterruptiblePipelineData, PipelineData,
+    ShellError, Signature, Span, Type, Value,
+};
+use reedline::{
+    FileBackedHistory, History as ReedlineHistory, HistoryItem, SearchDirection, SearchQuery,
+    SqliteBackedHistory,
+};
+
+#[derive(Clone)]
+pub struct History;
+
+impl Command for History {
+    fn name(&self) -> &str {
+        "history"
+    }
+
+    fn usage(&self) -> &str {
+        "Get the command history."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("history")
+            .input_output_types(vec![
+                (Type::Nothing, Type::Table(vec![])),
+                (Type::Nothing, Type::Nothing),
+            ])
+            .allow_variants_without_examples(true)
+            .switch("clear", "Clears out the history entries", Some('c'))
+            .switch(
+                "long",
+                "Show long listing of entries for sqlite history",
+                Some('l'),
+            )
+            .category(Category::History)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+
+        // todo for sqlite history this command should be an alias to `open ~/.config/nushell/history.sqlite3 | get history`
+        if let Some(config_path) = nu_path::config_dir() {
+            let clear = call.has_flag("clear");
+            let long = call.has_flag("long");
+            let ctrlc = engine_state.ctrlc.clone();
+
+            let mut history_path = config_path;
+            history_path.push("nushell");
+            match engine_state.config.history_file_format {
+                HistoryFileFormat::Sqlite => {
+                    history_path.push("history.sqlite3");
+                }
+                HistoryFileFormat::PlainText => {
+                    history_path.push("history.txt");
+                }
+            }
+
+            if clear {
+                let _ = std::fs::remove_file(history_path);
+                // TODO: FIXME also clear the auxiliary files when using sqlite
+                Ok(PipelineData::empty())
+            } else {
+                let history_reader: Option<Box<dyn ReedlineHistory>> =
+                    match engine_state.config.history_file_format {
+                        HistoryFileFormat::Sqlite => {
+                            SqliteBackedHistory::with_file(history_path, None, None)
+                                .map(|inner| {
+                                    let boxed: Box<dyn ReedlineHistory> = Box::new(inner);
+                                    boxed
+                                })
+                                .ok()
+                        }
+
+                        HistoryFileFormat::PlainText => FileBackedHistory::with_file(
+                            engine_state.config.max_history_size as usize,
+                            history_path,
+                        )
+                        .map(|inner| {
+                            let boxed: Box<dyn ReedlineHistory> = Box::new(inner);
+                            boxed
+                        })
+                        .ok(),
+                    };
+
+                match engine_state.config.history_file_format {
+                    HistoryFileFormat::PlainText => Ok(history_reader
+                        .and_then(|h| {
+                            h.search(SearchQuery::everything(SearchDirection::Forward, None))
+                                .ok()
+                        })
+                        .map(move |entries| {
+                            entries.into_iter().enumerate().map(move |(idx, entry)| {
+                                Value::record(
+                                    record! {
+                                        "command" => Value::string(entry.command_line, head),
+                                        "index" => Value::int(idx as i64, head),
+                                    },
+                                    head,
+                                )
+                            })
+                        })
+                        .ok_or(ShellError::FileNotFound { span: head })?
+                        .into_pipeline_data(ctrlc)),
+                    HistoryFileFormat::Sqlite => Ok(history_reader
+                        .and_then(|h| {
+                            h.search(SearchQuery::everything(SearchDirection::Forward, None))
+                                .ok()
+                        })
+                        .map(move |entries| {
+                            entries.into_iter().enumerate().map(move |(idx, entry)| {
+                                create_history_record(idx, entry, long, head)
+                            })
+                        })
+                        .ok_or(ShellError::FileNotFound { span: head })?
+                        .into_pipeline_data(ctrlc)),
+                }
+            }
+        } else {
+            Err(ShellError::FileNotFound { span: head })
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                example: "history | length",
+                description: "Get current history length",
+                result: None,
+            },
+            Example {
+                example: "history | last 5",
+                description: "Show last 5 commands you have ran",
+                result: None,
+            },
+            Example {
+                example: "history | where command =~ cargo | get command",
+                description: "Search all the commands from history that contains 'cargo'",
+                result: None,
+            },
+        ]
+    }
+}
+
+fn create_history_record(idx: usize, entry: HistoryItem, long: bool, head: Span) -> Value {
+    //1. Format all the values
+    //2. Create a record of either short or long columns and values
+
+    let item_id_value = Value::int(
+        match entry.id {
+            Some(id) => {
+                let ids = id.to_string();
+                match ids.parse::<i64>() {
+                    Ok(i) => i,
+                    _ => 0i64,
+                }
+            }
+            None => 0i64,
+        },
+        head,
+    );
+    let start_timestamp_value = Value::string(
+        match entry.start_timestamp {
+            Some(time) => time.to_string(),
+            None => "".into(),
+        },
+        head,
+    );
+    let command_value = Value::string(entry.command_line, head);
+    let session_id_value = Value::int(
+        match entry.session_id {
+            Some(sid) => {
+                let sids = sid.to_string();
+                match sids.parse::<i64>() {
+                    Ok(i) => i,
+                    _ => 0i64,
+                }
+            }
+            None => 0i64,
+        },
+        head,
+    );
+    let hostname_value = Value::string(
+        match entry.hostname {
+            Some(host) => host,
+            None => "".into(),
+        },
+        head,
+    );
+    let cwd_value = Value::string(
+        match entry.cwd {
+            Some(cwd) => cwd,
+            None => "".into(),
+        },
+        head,
+    );
+    let duration_value = Value::duration(
+        match entry.duration {
+            Some(d) => d.as_nanos().try_into().unwrap_or(0),
+            None => 0,
+        },
+        head,
+    );
+    let exit_status_value = Value::int(entry.exit_status.unwrap_or(0), head);
+    let index_value = Value::int(idx as i64, head);
+    if long {
+        Value::record(
+            record! {
+                "item_id" => item_id_value,
+                "start_timestamp" => start_timestamp_value,
+                "command" => command_value,
+                "session_id" => session_id_value,
+                "hostname" => hostname_value,
+                "cwd" => cwd_value,
+                "duration" => duration_value,
+                "exit_status" => exit_status_value,
+                "idx" => index_value,
+            },
+            head,
+        )
+    } else {
+        Value::record(
+            record! {
+                "start_timestamp" => start_timestamp_value,
+                "command" => command_value,
+                "cwd" => cwd_value,
+                "duration" => duration_value,
+                "exit_status" => exit_status_value,
+            },
+            head,
+        )
+    }
+}

crates/nu-cli/src/commands/history/history_session.rs

@@ -0,0 +1,42 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct HistorySession;
+
+impl Command for HistorySession {
+    fn name(&self) -> &str {
+        "history session"
+    }
+
+    fn usage(&self) -> &str {
+        "Get the command history session."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("history session")
+            .category(Category::History)
+            .input_output_types(vec![(Type::Nothing, Type::Int)])
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            example: "history session",
+            description: "Get current history session",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        Ok(Value::int(engine_state.history_session_id, call.head).into_pipeline_data())
+    }
+}

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

@@ -0,0 +1,5 @@
+mod history_;
+mod history_session;
+
+pub use history_::History;
+pub use history_session::HistorySession;

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

@@ -0,0 +1,56 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct Keybindings;
+
+impl Command for Keybindings {
+    fn name(&self) -> &str {
+        "keybindings"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .category(Category::Platform)
+            .input_output_types(vec![(Type::Nothing, Type::String)])
+    }
+
+    fn usage(&self) -> &str {
+        "Keybindings related commands."
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"You must use one of the following subcommands. Using this command as-is will only produce this help message.
+
+For more information on input and keybindings, check:
+  https://www.nushell.sh/book/line_editor.html"#
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["shortcut", "hotkey"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        Ok(Value::string(
+            get_full_help(
+                &Keybindings.signature(),
+                &Keybindings.examples(),
+                engine_state,
+                stack,
+                self.is_parser_keyword(),
+            ),
+            call.head,
+        )
+        .into_pipeline_data())
+    }
+}

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

@@ -0,0 +1,58 @@
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
+};
+use reedline::get_reedline_default_keybindings;
+
+#[derive(Clone)]
+pub struct KeybindingsDefault;
+
+impl Command for KeybindingsDefault {
+    fn name(&self) -> &str {
+        "keybindings default"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .category(Category::Platform)
+            .input_output_types(vec![(Type::Nothing, Type::Table(vec![]))])
+    }
+
+    fn usage(&self) -> &str {
+        "List default keybindings."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get list with default keybindings",
+            example: "keybindings default",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let records = get_reedline_default_keybindings()
+            .into_iter()
+            .map(|(mode, modifier, code, event)| {
+                Value::record(
+                    record! {
+                        "mode" => Value::string(mode, call.head),
+                        "modifier" => Value::string(modifier, call.head),
+                        "code" => Value::string(code, call.head),
+                        "event" => Value::string(event, call.head),
+                    },
+                    call.head,
+                )
+            })
+            .collect();
+
+        Ok(Value::list(records, call.head).into_pipeline_data())
+    }
+}

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

@@ -0,0 +1,118 @@
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type,
+    Value,
+};
+use reedline::{
+    get_reedline_edit_commands, get_reedline_keybinding_modifiers, get_reedline_keycodes,
+    get_reedline_prompt_edit_modes, get_reedline_reedline_events,
+};
+
+#[derive(Clone)]
+pub struct KeybindingsList;
+
+impl Command for KeybindingsList {
+    fn name(&self) -> &str {
+        "keybindings list"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .input_output_types(vec![(Type::Nothing, Type::Table(vec![]))])
+            .switch("modifiers", "list of modifiers", Some('m'))
+            .switch("keycodes", "list of keycodes", Some('k'))
+            .switch("modes", "list of edit modes", Some('o'))
+            .switch("events", "list of reedline event", Some('e'))
+            .switch("edits", "list of edit commands", Some('d'))
+            .category(Category::Platform)
+    }
+
+    fn usage(&self) -> &str {
+        "List available options that can be used to create keybindings."
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get list of key modifiers",
+                example: "keybindings list --modifiers",
+                result: None,
+            },
+            Example {
+                description: "Get list of reedline events and edit commands",
+                example: "keybindings list -e -d",
+                result: None,
+            },
+            Example {
+                description: "Get list with all the available options",
+                example: "keybindings list",
+                result: None,
+            },
+        ]
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let records = if call.named_len() == 0 {
+            let all_options = ["modifiers", "keycodes", "edits", "modes", "events"];
+            all_options
+                .iter()
+                .flat_map(|argument| get_records(argument, call.head))
+                .collect()
+        } else {
+            call.named_iter()
+                .flat_map(|(argument, _, _)| get_records(argument.item.as_str(), call.head))
+                .collect()
+        };
+
+        Ok(Value::list(records, call.head).into_pipeline_data())
+    }
+}
+
+fn get_records(entry_type: &str, span: Span) -> Vec<Value> {
+    let values = match entry_type {
+        "modifiers" => get_reedline_keybinding_modifiers().sorted(),
+        "keycodes" => get_reedline_keycodes().sorted(),
+        "edits" => get_reedline_edit_commands().sorted(),
+        "modes" => get_reedline_prompt_edit_modes().sorted(),
+        "events" => get_reedline_reedline_events().sorted(),
+        _ => Vec::new(),
+    };
+
+    values
+        .iter()
+        .map(|edit| edit.split('\n'))
+        .flat_map(|edit| edit.map(|edit| convert_to_record(edit, entry_type, span)))
+        .collect()
+}
+
+fn convert_to_record(edit: &str, entry_type: &str, span: Span) -> Value {
+    Value::record(
+        record! {
+            "type" => Value::string(entry_type, span),
+            "name" => Value::string(edit, span),
+        },
+        span,
+    )
+}
+
+// Helper to sort a vec and return a vec
+trait SortedImpl {
+    fn sorted(self) -> Self;
+}
+
+impl<E> SortedImpl for Vec<E>
+where
+    E: std::cmp::Ord,
+{
+    fn sorted(mut self) -> Self {
+        self.sort();
+        self
+    }
+}

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

@@ -0,0 +1,178 @@
+use crossterm::execute;
+use crossterm::QueueableCommand;
+use crossterm::{event::Event, event::KeyCode, event::KeyEvent, terminal};
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type,
+    Value,
+};
+use std::io::{stdout, Write};
+
+#[derive(Clone)]
+pub struct KeybindingsListen;
+
+impl Command for KeybindingsListen {
+    fn name(&self) -> &str {
+        "keybindings listen"
+    }
+
+    fn usage(&self) -> &str {
+        "Get input from the user."
+    }
+
+    fn extra_usage(&self) -> &str {
+        "This is an internal debugging tool. For better output, try `input listen --types [key]`"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .category(Category::Platform)
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .allow_variants_without_examples(true)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        _call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        println!("Type any key combination to see key details. Press ESC to abort.");
+
+        match print_events(engine_state) {
+            Ok(v) => Ok(v.into_pipeline_data()),
+            Err(e) => {
+                terminal::disable_raw_mode()?;
+                Err(ShellError::GenericError {
+                    error: "Error with input".into(),
+                    msg: "".into(),
+                    span: None,
+                    help: Some(e.to_string()),
+                    inner: vec![],
+                })
+            }
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Type and see key event codes",
+            example: "keybindings listen",
+            result: None,
+        }]
+    }
+}
+
+pub fn print_events(engine_state: &EngineState) -> Result<Value, ShellError> {
+    let config = engine_state.get_config();
+
+    stdout().flush()?;
+    terminal::enable_raw_mode()?;
+
+    if config.use_kitty_protocol {
+        if let Ok(false) = crossterm::terminal::supports_keyboard_enhancement() {
+            println!("WARN: The terminal doesn't support use_kitty_protocol config.\r");
+        }
+
+        // enable kitty protocol
+        //
+        // Note that, currently, only the following support this protocol:
+        // * [kitty terminal](https://sw.kovidgoyal.net/kitty/)
+        // * [foot terminal](https://codeberg.org/dnkl/foot/issues/319)
+        // * [WezTerm terminal](https://wezfurlong.org/wezterm/config/lua/config/enable_kitty_keyboard.html)
+        // * [notcurses library](https://github.com/dankamongmen/notcurses/issues/2131)
+        // * [neovim text editor](https://github.com/neovim/neovim/pull/18181)
+        // * [kakoune text editor](https://github.com/mawww/kakoune/issues/4103)
+        // * [dte text editor](https://gitlab.com/craigbarnes/dte/-/issues/138)
+        //
+        // Refer to https://sw.kovidgoyal.net/kitty/keyboard-protocol/ if you're curious.
+        let _ = execute!(
+            stdout(),
+            crossterm::event::PushKeyboardEnhancementFlags(
+                crossterm::event::KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+            )
+        );
+    }
+
+    let mut stdout = std::io::BufWriter::new(std::io::stderr());
+
+    loop {
+        let event = crossterm::event::read()?;
+        if event == Event::Key(KeyCode::Esc.into()) {
+            break;
+        }
+        // stdout.queue(crossterm::style::Print(format!("event: {:?}", &event)))?;
+        // stdout.queue(crossterm::style::Print("\r\n"))?;
+
+        // Get a record
+        let v = print_events_helper(event)?;
+        // Print out the record
+        let o = match v {
+            Value::Record { val, .. } => val
+                .iter()
+                .map(|(x, y)| format!("{}: {}", x, y.into_string("", config)))
+                .collect::<Vec<String>>()
+                .join(", "),
+
+            _ => "".to_string(),
+        };
+        stdout.queue(crossterm::style::Print(o))?;
+        stdout.queue(crossterm::style::Print("\r\n"))?;
+        stdout.flush()?;
+    }
+
+    if config.use_kitty_protocol {
+        let _ = execute!(
+            std::io::stdout(),
+            crossterm::event::PopKeyboardEnhancementFlags
+        );
+    }
+
+    terminal::disable_raw_mode()?;
+
+    Ok(Value::nothing(Span::unknown()))
+}
+
+// this fn is totally ripped off from crossterm's examples
+// it's really a diagnostic routine to see if crossterm is
+// even seeing the events. if you press a key and no events
+// are printed, it's a good chance your terminal is eating
+// those events.
+fn print_events_helper(event: Event) -> Result<Value, ShellError> {
+    if let Event::Key(KeyEvent {
+        code,
+        modifiers,
+        kind,
+        state,
+    }) = event
+    {
+        match code {
+            KeyCode::Char(c) => {
+                let record = record! {
+                    "char" => Value::string(format!("{c}"), Span::unknown()),
+                    "code" => Value::string(format!("{:#08x}", u32::from(c)), Span::unknown()),
+                    "modifier" => Value::string(format!("{modifiers:?}"), Span::unknown()),
+                    "flags" => Value::string(format!("{modifiers:#08b}"), Span::unknown()),
+                    "kind" => Value::string(format!("{kind:?}"), Span::unknown()),
+                    "state" => Value::string(format!("{state:?}"), Span::unknown()),
+                };
+                Ok(Value::record(record, Span::unknown()))
+            }
+            _ => {
+                let record = record! {
+                    "code" => Value::string(format!("{code:?}"), Span::unknown()),
+                    "modifier" => Value::string(format!("{modifiers:?}"), Span::unknown()),
+                    "flags" => Value::string(format!("{modifiers:#08b}"), Span::unknown()),
+                    "kind" => Value::string(format!("{kind:?}"), Span::unknown()),
+                    "state" => Value::string(format!("{state:?}"), Span::unknown()),
+                };
+                Ok(Value::record(record, Span::unknown()))
+            }
+        }
+    } else {
+        let record = record! { "event" => Value::string(format!("{event:?}"), Span::unknown()) };
+        Ok(Value::record(record, Span::unknown()))
+    }
+}

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

@@ -0,0 +1,16 @@
+mod commandline;
+mod default_context;
+mod history;
+mod keybindings;
+mod keybindings_default;
+mod keybindings_list;
+mod keybindings_listen;
+
+pub use commandline::Commandline;
+pub use history::{History, HistorySession};
+pub use keybindings::Keybindings;
+pub use keybindings_default::KeybindingsDefault;
+pub use keybindings_list::KeybindingsList;
+pub use keybindings_listen::KeybindingsListen;
+
+pub use default_context::add_cli_context;

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

@@ -0,0 +1,43 @@
+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,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion>;
+
+    fn get_sort_by(&self) -> SortBy {
+        SortBy::Ascending
+    }
+
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+        let mut filtered_items = items;
+
+        // Sort items
+        match self.get_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,318 @@
+use crate::completions::{Completer, CompletionOptions, MatchAlgorithm, SortBy};
+use nu_parser::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_shape: FlatShape,
+    force_completion_after_space: bool,
+}
+
+impl CommandCompletion {
+    pub fn new(
+        engine_state: Arc<EngineState>,
+        _: &StateWorkingSet,
+        flattened: Vec<(Span, FlatShape)>,
+        flat_shape: FlatShape,
+        force_completion_after_space: bool,
+    ) -> Self {
+        Self {
+            engine_state,
+            flattened,
+            flat_shape,
+            force_completion_after_space,
+        }
+    }
+
+    fn external_command_completion(
+        &self,
+        prefix: &str,
+        match_algorithm: MatchAlgorithm,
+    ) -> Vec<String> {
+        let mut executables = vec![];
+
+        // os agnostic way to get the PATH env var
+        let paths = self.engine_state.get_path_env_var();
+
+        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 self.engine_state.config.max_external_completion_results
+                                > executables.len() as i64
+                                && !executables.contains(
+                                    &item
+                                        .path()
+                                        .file_name()
+                                        .map(|x| x.to_string_lossy().to_string())
+                                        .unwrap_or_default(),
+                                )
+                                && matches!(
+                                    item.path().file_name().map(|x| match_algorithm
+                                        .matches_str(&x.to_string_lossy(), 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,
+        match_algorithm: MatchAlgorithm,
+    ) -> Vec<Suggestion> {
+        let partial = working_set.get_span_contents(span);
+
+        let filter_predicate = |command: &[u8]| match_algorithm.matches_u8(command, partial);
+
+        let mut results = working_set
+            .find_commands_by_predicate(filter_predicate, true)
+            .into_iter()
+            .map(move |x| Suggestion {
+                value: String::from_utf8_lossy(&x.0).to_string(),
+                description: x.1,
+                extra: None,
+                span: reedline::Span::new(span.start - offset, span.end - offset),
+                append_whitespace: true,
+            })
+            .collect::<Vec<_>>();
+
+        let partial = working_set.get_span_contents(span);
+        let partial = String::from_utf8_lossy(partial).to_string();
+
+        if find_externals {
+            let results_external = self
+                .external_command_completion(&partial, match_algorithm)
+                .into_iter()
+                .map(move |x| Suggestion {
+                    value: x,
+                    description: None,
+                    extra: None,
+                    span: reedline::Span::new(span.start - offset, span.end - offset),
+                    append_whitespace: true,
+                });
+
+            let results_strings: Vec<String> =
+                results.clone().into_iter().map(|x| x.value).collect();
+
+            for external in results_external {
+                if results_strings.contains(&external.value) {
+                    results.push(Suggestion {
+                        value: format!("^{}", external.value),
+                        description: None,
+                        extra: None,
+                        span: external.span,
+                        append_whitespace: true,
+                    })
+                } else {
+                    results.push(external)
+                }
+            }
+
+            results
+        } else {
+            results
+        }
+    }
+}
+
+impl Completer for CommandCompletion {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        _prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        pos: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        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();
+
+        // 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::new(last.0.start, pos),
+                offset,
+                false,
+                options.match_algorithm,
+            )
+        } else {
+            vec![]
+        };
+
+        if !subcommands.is_empty() {
+            return subcommands;
+        }
+
+        let config = working_set.get_config();
+        let commands = if matches!(self.flat_shape, nu_parser::FlatShape::External)
+            || matches!(self.flat_shape, nu_parser::FlatShape::InternalCall(_))
+            || ((span.end - span.start) == 0)
+            || is_passthrough_command(working_set.delta.get_file_contents())
+        {
+            // we're in a gap or at a command
+            if working_set.get_span_contents(span).is_empty() && !self.force_completion_after_space
+            {
+                return vec![];
+            }
+            self.complete_commands(
+                working_set,
+                span,
+                offset,
+                config.enable_external_completion,
+                options.match_algorithm,
+            )
+        } else {
+            vec![]
+        };
+
+        subcommands.into_iter().chain(commands).collect::<Vec<_>>()
+    }
+
+    fn get_sort_by(&self) -> SortBy {
+        SortBy::LevenshteinDistance
+    }
+}
+
+pub fn find_non_whitespace_index(contents: &[u8], start: usize) -> usize {
+    match contents.get(start..) {
+        Some(contents) => {
+            contents
+                .iter()
+                .take_while(|x| x.is_ascii_whitespace())
+                .count()
+                + start
+        }
+        None => start,
+    }
+}
+
+pub fn is_passthrough_command(working_set_file_contents: &[(Vec<u8>, usize, usize)]) -> bool {
+    for (contents, _, _) in working_set_file_contents {
+        let last_pipe_pos_rev = contents.iter().rev().position(|x| x == &b'|');
+        let last_pipe_pos = last_pipe_pos_rev.map(|x| contents.len() - x).unwrap_or(0);
+
+        let cur_pos = find_non_whitespace_index(contents, last_pipe_pos);
+
+        let result = match contents.get(cur_pos..) {
+            Some(contents) => contents.starts_with(b"sudo ") || contents.starts_with(b"doas "),
+            None => false,
+        };
+        if result {
+            return true;
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod command_completions_tests {
+    use super::*;
+
+    #[test]
+    fn test_find_non_whitespace_index() {
+        let commands = vec![
+            ("    hello", 4),
+            ("sudo ", 0),
+            (" 	sudo ", 2),
+            ("	 sudo ", 2),
+            ("	hello ", 1),
+            ("	  hello ", 3),
+            ("    hello | sudo ", 4),
+            ("     sudo|sudo", 5),
+            ("sudo | sudo ", 0),
+            ("	hello sud", 1),
+        ];
+        for (idx, ele) in commands.iter().enumerate() {
+            let index = find_non_whitespace_index(ele.0.as_bytes(), 0);
+            assert_eq!(index, ele.1, "Failed on index {}", idx);
+        }
+    }
+
+    #[test]
+    fn test_is_last_command_passthrough() {
+        let commands = vec![
+            ("    hello", false),
+            ("    sudo ", true),
+            ("sudo ", true),
+            ("	hello", false),
+            ("	sudo", false),
+            ("	sudo ", true),
+            (" 	sudo ", true),
+            ("	 sudo ", true),
+            ("	hello ", false),
+            ("    hello | sudo ", true),
+            ("    sudo|sudo", false),
+            ("sudo | sudo ", true),
+            ("	hello sud", false),
+            ("	sudo | sud ", false),
+            ("	sudo|sudo ", true),
+            (" 	sudo | sudo ls | sudo ", true),
+        ];
+        for (idx, ele) in commands.iter().enumerate() {
+            let input = ele.0.as_bytes();
+
+            let mut engine_state = EngineState::new();
+            engine_state.add_file("test.nu".into(), vec![]);
+
+            let delta = {
+                let mut working_set = StateWorkingSet::new(&engine_state);
+                let _ = working_set.add_file("child.nu".into(), input);
+                working_set.render()
+            };
+
+            let result = engine_state.merge_delta(delta);
+            assert!(
+                result.is_ok(),
+                "Merge delta has failed: {}",
+                result.err().unwrap()
+            );
+
+            let is_passthrough_command = is_passthrough_command(engine_state.get_file_contents());
+            assert_eq!(
+                is_passthrough_command, ele.1,
+                "index for '{}': {}",
+                ele.0, idx
+            );
+        }
+    }
+}

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

@@ -0,0 +1,566 @@
+use crate::completions::{
+    CommandCompletion, Completer, CompletionOptions, CustomCompletion, DirectoryCompletion,
+    DotNuCompletion, FileCompletion, FlagCompletion, VariableCompletion,
+};
+use nu_engine::eval_block;
+use nu_parser::{flatten_expression, parse, FlatShape};
+use nu_protocol::{
+    ast::PipelineElement,
+    engine::{EngineState, Stack, StateWorkingSet},
+    BlockId, PipelineData, Span, Value,
+};
+use reedline::{Completer as ReedlineCompleter, Suggestion};
+use std::str;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct NuCompleter {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+}
+
+impl NuCompleter {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack) -> Self {
+        Self {
+            engine_state,
+            stack,
+        }
+    }
+
+    // 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> {
+        let config = self.engine_state.get_config();
+
+        let options = CompletionOptions {
+            case_sensitive: config.case_sensitive_completions,
+            match_algorithm: config.completion_algorithm.into(),
+            ..Default::default()
+        };
+
+        // Fetch
+        let mut suggestions =
+            completer.fetch(working_set, prefix.clone(), new_span, offset, pos, &options);
+
+        // Sort
+        suggestions = completer.sort(suggestions, prefix);
+
+        suggestions
+    }
+
+    fn external_completion(
+        &self,
+        block_id: BlockId,
+        spans: &[String],
+        offset: usize,
+        span: Span,
+    ) -> Option<Vec<Suggestion>> {
+        let stack = self.stack.clone();
+        let block = self.engine_state.get_block(block_id);
+        let mut callee_stack = stack.gather_captures(&self.engine_state, &block.captures);
+
+        // Line
+        if let Some(pos_arg) = block.signature.required_positional.first() {
+            if let Some(var_id) = pos_arg.var_id {
+                callee_stack.add_var(
+                    var_id,
+                    Value::list(
+                        spans
+                            .iter()
+                            .map(|it| Value::string(it, Span::unknown()))
+                            .collect(),
+                        Span::unknown(),
+                    ),
+                );
+            }
+        }
+
+        let result = eval_block(
+            &self.engine_state,
+            &mut callee_stack,
+            block,
+            PipelineData::empty(),
+            true,
+            true,
+        );
+
+        match result {
+            Ok(pd) => {
+                let value = pd.into_value(span);
+                if let Value::List { vals, .. } = value {
+                    let result =
+                        map_value_completions(vals.iter(), Span::new(span.start, span.end), offset);
+
+                    return Some(result);
+                }
+            }
+            Err(err) => println!("failed to eval completer block: {err}"),
+        }
+
+        None
+    }
+
+    fn completion_helper(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+        let mut working_set = StateWorkingSet::new(&self.engine_state);
+        let offset = working_set.next_span_start();
+        let initial_line = line.to_string();
+        let mut line = line.to_string();
+        line.insert(pos, 'a');
+        let pos = offset + pos;
+        let config = self.engine_state.get_config();
+
+        let output = parse(&mut working_set, Some("completer"), line.as_bytes(), false);
+
+        for pipeline in output.pipelines.into_iter() {
+            for pipeline_element in pipeline.elements {
+                match pipeline_element {
+                    PipelineElement::Expression(_, expr)
+                    | PipelineElement::Redirection(_, _, expr, _)
+                    | PipelineElement::And(_, expr)
+                    | PipelineElement::Or(_, expr)
+                    | PipelineElement::SameTargetRedirection { cmd: (_, expr), .. }
+                    | PipelineElement::SeparateRedirection {
+                        out: (_, expr, _), ..
+                    } => {
+                        let flattened: Vec<_> = flatten_expression(&working_set, &expr);
+                        let mut spans: Vec<String> = vec![];
+
+                        for (flat_idx, flat) in flattened.iter().enumerate() {
+                            let is_passthrough_command = spans
+                                .first()
+                                .filter(|content| {
+                                    content.as_str() == "sudo" || content.as_str() == "doas"
+                                })
+                                .is_some();
+                            // Read the current spam to string
+                            let current_span = working_set.get_span_contents(flat.0).to_vec();
+                            let current_span_str = String::from_utf8_lossy(&current_span);
+
+                            let is_last_span = pos >= flat.0.start && pos < flat.0.end;
+
+                            // Skip the last 'a' as span item
+                            if is_last_span {
+                                let offset = pos - flat.0.start;
+                                if offset == 0 {
+                                    spans.push(String::new())
+                                } else {
+                                    let mut current_span_str = current_span_str.to_string();
+                                    current_span_str.remove(offset);
+                                    spans.push(current_span_str);
+                                }
+                            } else {
+                                spans.push(current_span_str.to_string());
+                            }
+
+                            // Complete based on the last span
+                            if is_last_span {
+                                // Context variables
+                                let most_left_var =
+                                    most_left_variable(flat_idx, &working_set, flattened.clone());
+
+                                // Create a new span
+                                let new_span = Span::new(flat.0.start, flat.0.end - 1);
+
+                                // Parses the prefix. Completion should look up to the cursor position, not after.
+                                let mut prefix = working_set.get_span_contents(flat.0).to_vec();
+                                let index = pos - flat.0.start;
+                                prefix.drain(index..);
+
+                                // Variables completion
+                                if prefix.starts_with(b"$") || most_left_var.is_some() {
+                                    let mut completer = VariableCompletion::new(
+                                        self.engine_state.clone(),
+                                        self.stack.clone(),
+                                        most_left_var.unwrap_or((vec![], vec![])),
+                                    );
+
+                                    return self.process_completion(
+                                        &mut completer,
+                                        &working_set,
+                                        prefix,
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
+                                }
+
+                                // Flags completion
+                                if prefix.starts_with(b"-") {
+                                    // Try to complete flag internally
+                                    let mut completer = FlagCompletion::new(expr.clone());
+                                    let result = self.process_completion(
+                                        &mut completer,
+                                        &working_set,
+                                        prefix.clone(),
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
+
+                                    if !result.is_empty() {
+                                        return result;
+                                    }
+
+                                    // We got no results for internal completion
+                                    // now we can check if external completer is set and use it
+                                    if let Some(block_id) = config.external_completer {
+                                        if let Some(external_result) = self
+                                            .external_completion(block_id, &spans, offset, new_span)
+                                        {
+                                            return external_result;
+                                        }
+                                    }
+                                }
+
+                                // specially check if it is currently empty - always complete commands
+                                if (is_passthrough_command && flat_idx == 1)
+                                    || (flat_idx == 0
+                                        && working_set.get_span_contents(new_span).is_empty())
+                                {
+                                    let mut completer = CommandCompletion::new(
+                                        self.engine_state.clone(),
+                                        &working_set,
+                                        flattened.clone(),
+                                        // flat_idx,
+                                        FlatShape::String,
+                                        true,
+                                    );
+                                    return self.process_completion(
+                                        &mut completer,
+                                        &working_set,
+                                        prefix,
+                                        new_span,
+                                        offset,
+                                        pos,
+                                    );
+                                }
+
+                                // Completions that depends on the previous expression (e.g: use, source-env)
+                                if (is_passthrough_command && flat_idx > 1) || flat_idx > 0 {
+                                    if let Some(previous_expr) = flattened.get(flat_idx - 1) {
+                                        // Read the content for the previous expression
+                                        let prev_expr_str =
+                                            working_set.get_span_contents(previous_expr.0).to_vec();
+
+                                        // Completion for .nu files
+                                        if prev_expr_str == b"use"
+                                            || prev_expr_str == b"overlay use"
+                                            || prev_expr_str == b"source-env"
+                                        {
+                                            let mut completer =
+                                                DotNuCompletion::new(self.engine_state.clone());
+
+                                            return self.process_completion(
+                                                &mut completer,
+                                                &working_set,
+                                                prefix,
+                                                new_span,
+                                                offset,
+                                                pos,
+                                            );
+                                        } else if prev_expr_str == b"ls" {
+                                            let mut completer =
+                                                FileCompletion::new(self.engine_state.clone());
+
+                                            return self.process_completion(
+                                                &mut completer,
+                                                &working_set,
+                                                prefix,
+                                                new_span,
+                                                offset,
+                                                pos,
+                                            );
+                                        }
+                                    }
+                                }
+
+                                // Match other types
+                                match &flat.1 {
+                                    FlatShape::Custom(decl_id) => {
+                                        let mut completer = CustomCompletion::new(
+                                            self.engine_state.clone(),
+                                            self.stack.clone(),
+                                            *decl_id,
+                                            initial_line,
+                                        );
+
+                                        return self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+                                    }
+                                    FlatShape::Directory => {
+                                        let mut completer =
+                                            DirectoryCompletion::new(self.engine_state.clone());
+
+                                        return self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+                                    }
+                                    FlatShape::Filepath | FlatShape::GlobPattern => {
+                                        let mut completer =
+                                            FileCompletion::new(self.engine_state.clone());
+
+                                        return self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+                                    }
+                                    flat_shape => {
+                                        let mut completer = CommandCompletion::new(
+                                            self.engine_state.clone(),
+                                            &working_set,
+                                            flattened.clone(),
+                                            // flat_idx,
+                                            flat_shape.clone(),
+                                            false,
+                                        );
+
+                                        let mut out: Vec<_> = self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix.clone(),
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+
+                                        if !out.is_empty() {
+                                            return out;
+                                        }
+
+                                        // Try to complete using an external completer (if set)
+                                        if let Some(block_id) = config.external_completer {
+                                            if let Some(external_result) = self.external_completion(
+                                                block_id, &spans, offset, new_span,
+                                            ) {
+                                                return external_result;
+                                            }
+                                        }
+
+                                        // Check for file completion
+                                        let mut completer =
+                                            FileCompletion::new(self.engine_state.clone());
+                                        out = self.process_completion(
+                                            &mut completer,
+                                            &working_set,
+                                            prefix,
+                                            new_span,
+                                            offset,
+                                            pos,
+                                        );
+
+                                        if !out.is_empty() {
+                                            return out;
+                                        }
+                                    }
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        vec![]
+    }
+}
+
+impl ReedlineCompleter for NuCompleter {
+    fn complete(&mut self, line: &str, pos: usize) -> Vec<Suggestion> {
+        self.completion_helper(line, pos)
+    }
+}
+
+// reads the most left variable returning it's name (e.g: $myvar)
+// and the depth (a.b.c)
+fn most_left_variable(
+    idx: usize,
+    working_set: &StateWorkingSet<'_>,
+    flattened: Vec<(Span, FlatShape)>,
+) -> Option<(Vec<u8>, Vec<Vec<u8>>)> {
+    // Reverse items to read the list backwards and truncate
+    // because the only items that matters are the ones before the current index
+    let mut rev = flattened;
+    rev.truncate(idx);
+    rev = rev.into_iter().rev().collect();
+
+    // Store the variables and sub levels found and reverse to correct order
+    let mut variables_found: Vec<Vec<u8>> = vec![];
+    let mut found_var = false;
+    for item in rev.clone() {
+        let result = working_set.get_span_contents(item.0).to_vec();
+
+        match item.1 {
+            FlatShape::Variable(_) => {
+                variables_found.push(result);
+                found_var = true;
+
+                break;
+            }
+            FlatShape::String => {
+                variables_found.push(result);
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+
+    // If most left var was not found
+    if !found_var {
+        return None;
+    }
+
+    // Reverse the order back
+    variables_found = variables_found.into_iter().rev().collect();
+
+    // Extract the variable and the sublevels
+    let var = variables_found.first().unwrap_or(&vec![]).to_vec();
+    let sublevels: Vec<Vec<u8>> = variables_found.into_iter().skip(1).collect();
+
+    Some((var, sublevels))
+}
+
+pub fn map_value_completions<'a>(
+    list: impl Iterator<Item = &'a Value>,
+    span: Span,
+    offset: usize,
+) -> Vec<Suggestion> {
+    list.filter_map(move |x| {
+        // Match for string values
+        if let Ok(s) = x.as_string() {
+            return Some(Suggestion {
+                value: s,
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
+                append_whitespace: false,
+            });
+        }
+
+        // Match for record values
+        if let Ok(record) = x.as_record() {
+            let mut suggestion = Suggestion {
+                value: String::from(""), // Initialize with empty string
+                description: None,
+                extra: None,
+                span: reedline::Span {
+                    start: span.start - offset,
+                    end: span.end - offset,
+                },
+                append_whitespace: false,
+            };
+
+            // Iterate the cols looking for `value` and `description`
+            record.iter().for_each(|it| {
+                // Match `value` column
+                if it.0 == "value" {
+                    // Convert the value to string
+                    if let Ok(val_str) = it.1.as_string() {
+                        // Update the suggestion value
+                        suggestion.value = val_str;
+                    }
+                }
+
+                // Match `description` column
+                if it.0 == "description" {
+                    // Convert the value to string
+                    if let Ok(desc_str) = it.1.as_string() {
+                        // Update the suggestion value
+                        suggestion.description = Some(desc_str);
+                    }
+                }
+            });
+
+            return Some(suggestion);
+        }
+
+        None
+    })
+    .collect()
+}
+
+#[cfg(test)]
+mod completer_tests {
+    use super::*;
+
+    #[test]
+    fn test_completion_helper() {
+        let mut engine_state =
+            nu_command::add_shell_command_context(nu_cmd_lang::create_default_context());
+
+        // Custom additions
+        let delta = {
+            let working_set = nu_protocol::engine::StateWorkingSet::new(&engine_state);
+            working_set.render()
+        };
+
+        let result = engine_state.merge_delta(delta);
+        assert!(
+            result.is_ok(),
+            "Error merging delta: {:?}",
+            result.err().unwrap()
+        );
+
+        let mut completer = NuCompleter::new(engine_state.into(), Stack::new());
+        let dataset = vec![
+            ("sudo", false, "", Vec::new()),
+            ("sudo l", true, "l", vec!["ls", "let", "lines", "loop"]),
+            (" sudo", false, "", Vec::new()),
+            (" sudo le", true, "le", vec!["let", "length"]),
+            (
+                "ls | c",
+                true,
+                "c",
+                vec!["cd", "config", "const", "cp", "cal"],
+            ),
+            ("ls | sudo m", true, "m", vec!["mv", "mut", "move"]),
+        ];
+        for (line, has_result, begins_with, expected_values) in dataset {
+            let result = completer.completion_helper(line, line.len());
+            // Test whether the result is empty or not
+            assert_eq!(!result.is_empty(), has_result, "line: {}", line);
+
+            // Test whether the result begins with the expected value
+            result
+                .iter()
+                .for_each(|x| assert!(x.value.starts_with(begins_with)));
+
+            // Test whether the result contains all the expected values
+            assert_eq!(
+                result
+                    .iter()
+                    .map(|x| expected_values.contains(&x.value.as_str()))
+                    .filter(|x| *x)
+                    .count(),
+                expected_values.len(),
+                "line: {}",
+                line
+            );
+        }
+    }
+}

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

@@ -0,0 +1,199 @@
+use crate::completions::{matches, CompletionOptions};
+use nu_path::home_dir;
+use nu_protocol::{engine::StateWorkingSet, Span};
+use std::path::{is_separator, Component, Path, PathBuf, MAIN_SEPARATOR as SEP};
+
+fn complete_rec(
+    partial: &[String],
+    cwd: &Path,
+    options: &CompletionOptions,
+    dir: bool,
+    isdir: bool,
+) -> Vec<PathBuf> {
+    let mut completions = vec![];
+
+    if let Ok(result) = cwd.read_dir() {
+        for entry in result.filter_map(|e| e.ok()) {
+            let entry_name = entry.file_name().to_string_lossy().into_owned();
+            let path = entry.path();
+
+            if !dir || path.is_dir() {
+                match partial.first() {
+                    Some(base) if matches(base, &entry_name, options) => {
+                        let partial = &partial[1..];
+                        if !partial.is_empty() || isdir {
+                            completions.extend(complete_rec(partial, &path, options, dir, isdir));
+                            if entry_name.eq(base) {
+                                break;
+                            }
+                        } else {
+                            completions.push(path)
+                        }
+                    }
+                    None => completions.push(path),
+                    _ => {}
+                }
+            }
+        }
+    }
+    completions
+}
+
+enum OriginalCwd {
+    None,
+    Home(PathBuf),
+    Some(PathBuf),
+    // referencing a single local file
+    Local(PathBuf),
+}
+
+impl OriginalCwd {
+    fn apply(&self, p: &Path) -> String {
+        let mut ret = match self {
+            Self::None => p.to_string_lossy().into_owned(),
+            Self::Some(base) => pathdiff::diff_paths(p, base)
+                .unwrap_or(p.to_path_buf())
+                .to_string_lossy()
+                .into_owned(),
+            Self::Home(home) => match p.strip_prefix(home) {
+                Ok(suffix) => format!("~{}{}", SEP, suffix.to_string_lossy()),
+                _ => p.to_string_lossy().into_owned(),
+            },
+            Self::Local(base) => Path::new(".")
+                .join(pathdiff::diff_paths(p, base).unwrap_or(p.to_path_buf()))
+                .to_string_lossy()
+                .into_owned(),
+        };
+
+        if p.is_dir() {
+            ret.push(SEP);
+        }
+        ret
+    }
+}
+
+fn surround_remove(partial: &str) -> String {
+    for c in ['`', '"', '\''] {
+        if partial.starts_with(c) {
+            let ret = partial.strip_prefix(c).unwrap_or(partial);
+            return match ret.split(c).collect::<Vec<_>>()[..] {
+                [inside] => inside.to_string(),
+                [inside, outside] if inside.ends_with(is_separator) => format!("{inside}{outside}"),
+                _ => ret.to_string(),
+            };
+        }
+    }
+    partial.to_string()
+}
+
+pub fn complete_item(
+    want_directory: bool,
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+    options: &CompletionOptions,
+) -> Vec<(nu_protocol::Span, String)> {
+    let partial = surround_remove(partial);
+    let isdir = partial.ends_with(is_separator);
+    let cwd_pathbuf = Path::new(cwd).to_path_buf();
+    let mut original_cwd = OriginalCwd::None;
+    let mut components = Path::new(&partial).components().peekable();
+    let mut cwd = match components.peek().cloned() {
+        Some(c @ Component::Prefix(..)) => {
+            // windows only by definition
+            components.next();
+            if let Some(Component::RootDir) = components.peek().cloned() {
+                components.next();
+            };
+            [c, Component::RootDir].iter().collect()
+        }
+        Some(c @ Component::RootDir) => {
+            components.next();
+            PathBuf::from(c.as_os_str())
+        }
+        Some(Component::Normal(home)) if home.to_string_lossy() == "~" => {
+            components.next();
+            original_cwd = OriginalCwd::Home(home_dir().unwrap_or(cwd_pathbuf.clone()));
+            home_dir().unwrap_or(cwd_pathbuf)
+        }
+        Some(Component::CurDir) => {
+            components.next();
+            original_cwd = match components.peek().cloned() {
+                Some(Component::Normal(_)) | None => OriginalCwd::Local(cwd_pathbuf.clone()),
+                _ => OriginalCwd::Some(cwd_pathbuf.clone()),
+            };
+            cwd_pathbuf
+        }
+        _ => {
+            original_cwd = OriginalCwd::Some(cwd_pathbuf.clone());
+            cwd_pathbuf
+        }
+    };
+
+    let mut partial = vec![];
+
+    for component in components {
+        match component {
+            Component::Prefix(..) => unreachable!(),
+            Component::RootDir => unreachable!(),
+            Component::CurDir => {}
+            Component::ParentDir => {
+                if partial.pop().is_none() {
+                    cwd.pop();
+                }
+            }
+            Component::Normal(c) => partial.push(c.to_string_lossy().into_owned()),
+        }
+    }
+
+    complete_rec(partial.as_slice(), &cwd, options, want_directory, isdir)
+        .into_iter()
+        .map(|p| (span, escape_path(original_cwd.apply(&p), want_directory)))
+        .collect()
+}
+
+// Fix files or folders with quotes or hashes
+pub fn escape_path(path: String, dir: bool) -> String {
+    let filename_contaminated = !dir && path.contains(['\'', '"', ' ', '#', '(', ')']);
+    let dirname_contaminated = dir && path.contains(['\'', '"', ' ', '#']);
+    let maybe_flag = path.starts_with('-');
+    let maybe_number = path.parse::<f64>().is_ok();
+    if filename_contaminated || dirname_contaminated || maybe_flag || maybe_number {
+        format!("`{path}`")
+    } else {
+        path
+    }
+}
+
+pub struct AdjustView {
+    pub prefix: String,
+    pub span: Span,
+    pub readjusted: bool,
+}
+
+pub fn adjust_if_intermediate(
+    prefix: &[u8],
+    working_set: &StateWorkingSet,
+    mut span: nu_protocol::Span,
+) -> AdjustView {
+    let span_contents = String::from_utf8_lossy(working_set.get_span_contents(span)).to_string();
+    let mut prefix = String::from_utf8_lossy(prefix).to_string();
+
+    // A difference of 1 because of the cursor's unicode code point in between.
+    // Using .chars().count() because unicode and Windows.
+    let readjusted = span_contents.chars().count() - prefix.chars().count() > 1;
+    if readjusted {
+        let remnant: String = span_contents
+            .chars()
+            .skip(prefix.chars().count() + 1)
+            .take_while(|&c| !is_separator(c))
+            .collect();
+        prefix.push_str(&remnant);
+        span = Span::new(span.start, span.start + prefix.chars().count() + 1);
+    }
+    AdjustView {
+        prefix,
+        span,
+        readjusted,
+    }
+}

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

@@ -0,0 +1,147 @@
+use std::fmt::Display;
+
+use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
+use nu_parser::trim_quotes_str;
+use nu_protocol::CompletionAlgorithm;
+
+#[derive(Copy, Clone)]
+pub enum SortBy {
+    LevenshteinDistance,
+    Ascending,
+    None,
+}
+
+/// Describes how suggestions should be matched.
+#[derive(Copy, Clone, Debug)]
+pub enum MatchAlgorithm {
+    /// Only show suggestions which begin with the given input
+    ///
+    /// Example:
+    /// "git switch" is matched by "git sw"
+    Prefix,
+
+    /// Only show suggestions which contain the input chars at any place
+    ///
+    /// Example:
+    /// "git checkout" is matched by "gco"
+    Fuzzy,
+}
+
+impl MatchAlgorithm {
+    /// Returns whether the `needle` search text matches the given `haystack`.
+    pub fn matches_str(&self, haystack: &str, needle: &str) -> bool {
+        let haystack = trim_quotes_str(haystack);
+        let needle = trim_quotes_str(needle);
+        match *self {
+            MatchAlgorithm::Prefix => haystack.starts_with(needle),
+            MatchAlgorithm::Fuzzy => {
+                let matcher = SkimMatcherV2::default();
+                matcher.fuzzy_match(haystack, needle).is_some()
+            }
+        }
+    }
+
+    /// Returns whether the `needle` search text matches the given `haystack`.
+    pub fn matches_u8(&self, haystack: &[u8], needle: &[u8]) -> bool {
+        match *self {
+            MatchAlgorithm::Prefix => haystack.starts_with(needle),
+            MatchAlgorithm::Fuzzy => {
+                let haystack_str = String::from_utf8_lossy(haystack);
+                let needle_str = String::from_utf8_lossy(needle);
+
+                let matcher = SkimMatcherV2::default();
+                matcher.fuzzy_match(&haystack_str, &needle_str).is_some()
+            }
+        }
+    }
+}
+
+impl From<CompletionAlgorithm> for MatchAlgorithm {
+    fn from(value: CompletionAlgorithm) -> Self {
+        match value {
+            CompletionAlgorithm::Prefix => MatchAlgorithm::Prefix,
+            CompletionAlgorithm::Fuzzy => MatchAlgorithm::Fuzzy,
+        }
+    }
+}
+
+impl TryFrom<String> for MatchAlgorithm {
+    type Error = InvalidMatchAlgorithm;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        match value.as_str() {
+            "prefix" => Ok(Self::Prefix),
+            "fuzzy" => Ok(Self::Fuzzy),
+            _ => Err(InvalidMatchAlgorithm::Unknown),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum InvalidMatchAlgorithm {
+    Unknown,
+}
+
+impl Display for InvalidMatchAlgorithm {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            InvalidMatchAlgorithm::Unknown => write!(f, "unknown match algorithm"),
+        }
+    }
+}
+
+impl std::error::Error for InvalidMatchAlgorithm {}
+
+#[derive(Clone)]
+pub struct CompletionOptions {
+    pub case_sensitive: bool,
+    pub positional: bool,
+    pub sort_by: SortBy,
+    pub match_algorithm: MatchAlgorithm,
+}
+
+impl Default for CompletionOptions {
+    fn default() -> Self {
+        Self {
+            case_sensitive: true,
+            positional: true,
+            sort_by: SortBy::Ascending,
+            match_algorithm: MatchAlgorithm::Prefix,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::MatchAlgorithm;
+
+    #[test]
+    fn match_algorithm_prefix() {
+        let algorithm = MatchAlgorithm::Prefix;
+
+        assert!(algorithm.matches_str("example text", ""));
+        assert!(algorithm.matches_str("example text", "examp"));
+        assert!(!algorithm.matches_str("example text", "text"));
+
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 2]));
+        assert!(!algorithm.matches_u8(&[1, 2, 3], &[2, 3]));
+    }
+
+    #[test]
+    fn match_algorithm_fuzzy() {
+        let algorithm = MatchAlgorithm::Fuzzy;
+
+        assert!(algorithm.matches_str("example text", ""));
+        assert!(algorithm.matches_str("example text", "examp"));
+        assert!(algorithm.matches_str("example text", "ext"));
+        assert!(algorithm.matches_str("example text", "mplxt"));
+        assert!(!algorithm.matches_str("example text", "mpp"));
+
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 2]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[2, 3]));
+        assert!(algorithm.matches_u8(&[1, 2, 3], &[1, 3]));
+        assert!(!algorithm.matches_u8(&[1, 2, 3], &[2, 2]));
+    }
+}

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

@@ -0,0 +1,171 @@
+use crate::completions::{Completer, CompletionOptions, MatchAlgorithm, SortBy};
+use nu_engine::eval_call;
+use nu_protocol::{
+    ast::{Argument, Call, Expr, Expression},
+    engine::{EngineState, Stack, StateWorkingSet},
+    PipelineData, Span, Type, Value,
+};
+use nu_utils::IgnoreCaseExt;
+use reedline::Suggestion;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use super::completer::map_value_completions;
+
+pub struct CustomCompletion {
+    engine_state: Arc<EngineState>,
+    stack: Stack,
+    decl_id: usize,
+    line: String,
+    sort_by: SortBy,
+}
+
+impl CustomCompletion {
+    pub fn new(engine_state: Arc<EngineState>, stack: Stack, decl_id: usize, line: String) -> Self {
+        Self {
+            engine_state,
+            stack,
+            decl_id,
+            line,
+            sort_by: SortBy::None,
+        }
+    }
+}
+
+impl Completer for CustomCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        pos: usize,
+        completion_options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        // Line position
+        let line_pos = pos - offset;
+
+        // 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::unknown(),
+                        ty: Type::String,
+                        expr: Expr::String(self.line.clone()),
+                        custom_completion: None,
+                    }),
+                    Argument::Positional(Expression {
+                        span: Span::unknown(),
+                        ty: Type::Int,
+                        expr: Expr::Int(line_pos as i64),
+                        custom_completion: None,
+                    }),
+                ],
+                redirect_stdout: true,
+                redirect_stderr: true,
+                parser_info: HashMap::new(),
+            },
+            PipelineData::empty(),
+        );
+
+        let mut custom_completion_options = None;
+
+        // Parse result
+        let suggestions = result
+            .map(|pd| {
+                let value = pd.into_value(span);
+                match &value {
+                    Value::Record { val, .. } => {
+                        let completions = val
+                            .get("completions")
+                            .and_then(|val| {
+                                val.as_list()
+                                    .ok()
+                                    .map(|it| map_value_completions(it.iter(), span, offset))
+                            })
+                            .unwrap_or_default();
+                        let options = val.get("options");
+
+                        if let Some(Value::Record { val: options, .. }) = &options {
+                            let should_sort = options
+                                .get("sort")
+                                .and_then(|val| val.as_bool().ok())
+                                .unwrap_or(false);
+
+                            if should_sort {
+                                self.sort_by = SortBy::Ascending;
+                            }
+
+                            custom_completion_options = Some(CompletionOptions {
+                                case_sensitive: options
+                                    .get("case_sensitive")
+                                    .and_then(|val| val.as_bool().ok())
+                                    .unwrap_or(true),
+                                positional: options
+                                    .get("positional")
+                                    .and_then(|val| val.as_bool().ok())
+                                    .unwrap_or(true),
+                                sort_by: if should_sort {
+                                    SortBy::Ascending
+                                } else {
+                                    SortBy::None
+                                },
+                                match_algorithm: match options.get("completion_algorithm") {
+                                    Some(option) => option
+                                        .as_string()
+                                        .ok()
+                                        .and_then(|option| option.try_into().ok())
+                                        .unwrap_or(MatchAlgorithm::Prefix),
+                                    None => completion_options.match_algorithm,
+                                },
+                            });
+                        }
+
+                        completions
+                    }
+                    Value::List { vals, .. } => map_value_completions(vals.iter(), span, offset),
+                    _ => vec![],
+                }
+            })
+            .unwrap_or_default();
+
+        if let Some(custom_completion_options) = custom_completion_options {
+            filter(&prefix, suggestions, &custom_completion_options)
+        } else {
+            filter(&prefix, suggestions, completion_options)
+        }
+    }
+
+    fn get_sort_by(&self) -> SortBy {
+        self.sort_by
+    }
+}
+
+fn filter(prefix: &[u8], items: Vec<Suggestion>, options: &CompletionOptions) -> Vec<Suggestion> {
+    items
+        .into_iter()
+        .filter(|it| match options.match_algorithm {
+            MatchAlgorithm::Prefix => 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_folded_case();
+                    let prefix = std::str::from_utf8(prefix).unwrap_or("").to_folded_case();
+                    if positional {
+                        value.starts_with(&prefix)
+                    } else {
+                        value.contains(&prefix)
+                    }
+                }
+            },
+            MatchAlgorithm::Fuzzy => options
+                .match_algorithm
+                .matches_u8(it.value.as_bytes(), prefix),
+        })
+        .collect()
+}

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

@@ -0,0 +1,117 @@
+use crate::completions::{
+    completion_common::{adjust_if_intermediate, complete_item, AdjustView},
+    Completer, CompletionOptions, SortBy,
+};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    levenshtein_distance, Span,
+};
+use reedline::Suggestion;
+use std::path::{Path, MAIN_SEPARATOR as SEP};
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct DirectoryCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl DirectoryCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for DirectoryCompletion {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let AdjustView { prefix, span, .. } = adjust_if_intermediate(&prefix, working_set, span);
+
+        // Filter only the folders
+        let output: Vec<_> = directory_completion(
+            span,
+            &prefix,
+            &self.engine_state.current_work_dir(),
+            options,
+        )
+        .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,
+            },
+            append_whitespace: false,
+        })
+        .collect();
+
+        output
+    }
+
+    // Sort results prioritizing the non hidden folders
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+
+        // Sort items
+        let mut sorted_items = items;
+
+        match self.get_sort_by() {
+            SortBy::Ascending => {
+                sorted_items.sort_by(|a, b| {
+                    // Ignore trailing slashes in folder names when sorting
+                    a.value
+                        .trim_end_matches(SEP)
+                        .cmp(b.value.trim_end_matches(SEP))
+                });
+            }
+            SortBy::LevenshteinDistance => {
+                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
+    }
+}
+
+pub fn directory_completion(
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+    options: &CompletionOptions,
+) -> Vec<(nu_protocol::Span, String)> {
+    complete_item(true, span, partial, cwd, options)
+}

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

@@ -0,0 +1,130 @@
+use crate::completions::{file_path_completion, Completer, CompletionOptions, SortBy};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    Span,
+};
+use reedline::Suggestion;
+use std::{
+    path::{is_separator, Path, MAIN_SEPARATOR as SEP, MAIN_SEPARATOR_STR},
+    sync::Arc,
+};
+
+#[derive(Clone)]
+pub struct DotNuCompletion {
+    engine_state: Arc<EngineState>,
+}
+
+impl DotNuCompletion {
+    pub fn new(engine_state: Arc<EngineState>) -> Self {
+        Self { engine_state }
+    }
+}
+
+impl Completer for DotNuCompletion {
+    fn fetch(
+        &mut self,
+        _: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).replace('`', "");
+        let mut search_dirs: Vec<String> = vec![];
+
+        // If prefix_str is only a word we want to search in the current dir
+        let (base, partial) = prefix_str
+            .rsplit_once(is_separator)
+            .unwrap_or((".", &prefix_str));
+        let base_dir = base.replace(is_separator, MAIN_SEPARATOR_STR);
+        let mut partial = partial.to_string();
+        // On windows, this standardizes paths to use \
+        let mut is_current_folder = false;
+
+        // Fetch the lib dirs
+        let lib_dirs: Vec<String> =
+            if let Some(lib_dirs) = self.engine_state.get_env_var("NU_LIB_DIRS") {
+                lib_dirs
+                    .as_list()
+                    .into_iter()
+                    .flat_map(|it| {
+                        it.iter().map(|x| {
+                            x.as_path()
+                                .expect("internal error: failed to convert lib path")
+                        })
+                    })
+                    .map(|it| {
+                        it.into_os_string()
+                            .into_string()
+                            .expect("internal error: failed to convert OS path")
+                    })
+                    .collect()
+            } else {
+                vec![]
+            };
+
+        // Check if the base_dir is a folder
+        // rsplit_once removes the separator
+        if base_dir != "." {
+            // Add the base dir into the directories to be searched
+            search_dirs.push(base_dir.clone());
+
+            // Reset the partial adding the basic dir back
+            // in order to make the span replace work properly
+            let mut base_dir_partial = base_dir;
+            base_dir_partial.push_str(&partial);
+
+            partial = base_dir_partial;
+        } else {
+            // Fetch the current folder
+            let current_folder = self.engine_state.current_work_dir();
+            is_current_folder = true;
+
+            // Add the current folder and the lib dirs into the
+            // directories to be searched
+            search_dirs.push(current_folder);
+            search_dirs.extend(lib_dirs);
+        }
+
+        // Fetch the files filtering the ones that ends with .nu
+        // and transform them into suggestions
+        let output: Vec<Suggestion> = search_dirs
+            .into_iter()
+            .flat_map(|search_dir| {
+                let completions = file_path_completion(span, &partial, &search_dir, options);
+                completions
+                    .into_iter()
+                    .filter(move |it| {
+                        // Different base dir, so we list the .nu files or folders
+                        if !is_current_folder {
+                            it.1.ends_with(".nu") || it.1.ends_with(SEP)
+                        } else {
+                            // Lib dirs, so we filter only the .nu files or directory modules
+                            if it.1.ends_with(SEP) {
+                                Path::new(&search_dir).join(&it.1).join("mod.nu").exists()
+                            } else {
+                                it.1.ends_with(".nu")
+                            }
+                        }
+                    })
+                    .map(move |x| Suggestion {
+                        value: x.1,
+                        description: None,
+                        extra: None,
+                        span: reedline::Span {
+                            start: x.0.start - offset,
+                            end: x.0.end - offset,
+                        },
+                        append_whitespace: true,
+                    })
+            })
+            .collect();
+
+        output
+    }
+
+    fn get_sort_by(&self) -> SortBy {
+        SortBy::LevenshteinDistance
+    }
+}

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

@@ -0,0 +1,133 @@
+use crate::completions::{
+    completion_common::{adjust_if_intermediate, complete_item, AdjustView},
+    Completer, CompletionOptions, SortBy,
+};
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    levenshtein_distance, Span,
+};
+use nu_utils::IgnoreCaseExt;
+use reedline::Suggestion;
+use std::path::{Path, MAIN_SEPARATOR as SEP};
+use std::sync::Arc;
+
+#[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,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let AdjustView {
+            prefix,
+            span,
+            readjusted,
+        } = adjust_if_intermediate(&prefix, working_set, span);
+
+        let output: Vec<_> = complete_item(
+            readjusted,
+            span,
+            &prefix,
+            &self.engine_state.current_work_dir(),
+            options,
+        )
+        .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,
+            },
+            append_whitespace: false,
+        })
+        .collect();
+
+        output
+    }
+
+    // Sort results prioritizing the non hidden folders
+    fn sort(&self, items: Vec<Suggestion>, prefix: Vec<u8>) -> Vec<Suggestion> {
+        let prefix_str = String::from_utf8_lossy(&prefix).to_string();
+
+        // Sort items
+        let mut sorted_items = items;
+
+        match self.get_sort_by() {
+            SortBy::Ascending => {
+                sorted_items.sort_by(|a, b| {
+                    // Ignore trailing slashes in folder names when sorting
+                    a.value
+                        .trim_end_matches(SEP)
+                        .cmp(b.value.trim_end_matches(SEP))
+                });
+            }
+            SortBy::LevenshteinDistance => {
+                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
+    }
+}
+
+pub fn file_path_completion(
+    span: nu_protocol::Span,
+    partial: &str,
+    cwd: &str,
+    options: &CompletionOptions,
+) -> Vec<(nu_protocol::Span, String)> {
+    complete_item(false, span, partial, cwd, options)
+}
+
+pub fn matches(partial: &str, from: &str, options: &CompletionOptions) -> bool {
+    // Check for case sensitive
+    if !options.case_sensitive {
+        return options
+            .match_algorithm
+            .matches_str(&from.to_folded_case(), &partial.to_folded_case());
+    }
+
+    options.match_algorithm.matches_str(from, partial)
+}

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

@@ -0,0 +1,86 @@
+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,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        // 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 options.match_algorithm.matches_u8(&named, &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,
+                            },
+                            append_whitespace: true,
+                        });
+                    }
+                }
+
+                if named.long.is_empty() {
+                    continue;
+                }
+
+                let mut named = named.long.as_bytes().to_vec();
+                named.insert(0, b'-');
+                named.insert(0, b'-');
+
+                if options.match_algorithm.matches_u8(&named, &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,
+                        },
+                        append_whitespace: true,
+                    });
+                }
+            }
+
+            return output;
+        }
+
+        vec![]
+    }
+}

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

@@ -0,0 +1,22 @@
+mod base;
+mod command_completions;
+mod completer;
+mod completion_common;
+mod completion_options;
+mod custom_completions;
+mod directory_completions;
+mod dotnu_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, MatchAlgorithm, SortBy};
+pub use custom_completions::CustomCompletion;
+pub use directory_completions::DirectoryCompletion;
+pub use dotnu_completions::DotNuCompletion;
+pub use file_completions::{file_path_completion, matches, FileCompletion};
+pub use flag_completions::FlagCompletion;
+pub use variable_completions::VariableCompletion;

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

@@ -0,0 +1,342 @@
+use crate::completions::{Completer, CompletionOptions};
+use nu_engine::{column::get_columns, eval_variable};
+use nu_protocol::{
+    engine::{EngineState, Stack, StateWorkingSet},
+    Span, Value,
+};
+
+use reedline::Suggestion;
+use std::str;
+use std::sync::Arc;
+
+use super::MatchAlgorithm;
+
+#[derive(Clone)]
+pub struct VariableCompletion {
+    engine_state: Arc<EngineState>, // TODO: Is engine state necessary? It's already a part of working set in fetch()
+    stack: Stack,
+    var_context: (Vec<u8>, Vec<Vec<u8>>), // tuple with $var and the sublevels (.b.c.d)
+}
+
+impl VariableCompletion {
+    pub fn new(
+        engine_state: Arc<EngineState>,
+        stack: Stack,
+        var_context: (Vec<u8>, Vec<Vec<u8>>),
+    ) -> Self {
+        Self {
+            engine_state,
+            stack,
+            var_context,
+        }
+    }
+}
+
+impl Completer for VariableCompletion {
+    fn fetch(
+        &mut self,
+        working_set: &StateWorkingSet,
+        prefix: Vec<u8>,
+        span: Span,
+        offset: usize,
+        _: usize,
+        options: &CompletionOptions,
+    ) -> Vec<Suggestion> {
+        let mut output = vec![];
+        let builtins = ["$nu", "$in", "$env"];
+        let var_str = std::str::from_utf8(&self.var_context.0).unwrap_or("");
+        let var_id = working_set.find_variable(&self.var_context.0);
+        let current_span = reedline::Span {
+            start: span.start - offset,
+            end: span.end - offset,
+        };
+        let sublevels_count = self.var_context.1.len();
+
+        // Completions for the given variable
+        if !var_str.is_empty() {
+            // Completion for $env.<tab>
+            if var_str == "$env" {
+                let env_vars = self.stack.get_env_vars(&self.engine_state);
+
+                // Return nested values
+                if sublevels_count > 0 {
+                    // Extract the target var ($env.<target-var>)
+                    let target_var = self.var_context.1[0].clone();
+                    let target_var_str =
+                        str::from_utf8(&target_var).unwrap_or_default().to_string();
+
+                    // Everything after the target var is the nested level ($env.<target-var>.<nested_levels>...)
+                    let nested_levels: Vec<Vec<u8>> =
+                        self.var_context.1.clone().into_iter().skip(1).collect();
+
+                    if let Some(val) = env_vars.get(&target_var_str) {
+                        for suggestion in
+                            nested_suggestions(val.clone(), nested_levels, current_span)
+                        {
+                            if options.match_algorithm.matches_u8_insensitive(
+                                options.case_sensitive,
+                                suggestion.value.as_bytes(),
+                                &prefix,
+                            ) {
+                                output.push(suggestion);
+                            }
+                        }
+
+                        return output;
+                    }
+                } else {
+                    // No nesting provided, return all env vars
+                    for env_var in env_vars {
+                        if options.match_algorithm.matches_u8_insensitive(
+                            options.case_sensitive,
+                            env_var.0.as_bytes(),
+                            &prefix,
+                        ) {
+                            output.push(Suggestion {
+                                value: env_var.0,
+                                description: None,
+                                extra: None,
+                                span: current_span,
+                                append_whitespace: false,
+                            });
+                        }
+                    }
+
+                    return output;
+                }
+            }
+
+            // Completions for $nu.<tab>
+            if var_str == "$nu" {
+                // Eval nu var
+                if let Ok(nuval) = eval_variable(
+                    &self.engine_state,
+                    &self.stack,
+                    nu_protocol::NU_VARIABLE_ID,
+                    nu_protocol::Span::new(current_span.start, current_span.end),
+                ) {
+                    for suggestion in
+                        nested_suggestions(nuval, self.var_context.1.clone(), current_span)
+                    {
+                        if options.match_algorithm.matches_u8_insensitive(
+                            options.case_sensitive,
+                            suggestion.value.as_bytes(),
+                            &prefix,
+                        ) {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return output;
+                }
+            }
+
+            // Completion other variable types
+            if let Some(var_id) = var_id {
+                // Extract the variable value from the stack
+                let var = self.stack.get_var(var_id, Span::new(span.start, span.end));
+
+                // If the value exists and it's of type Record
+                if let Ok(value) = var {
+                    for suggestion in
+                        nested_suggestions(value, self.var_context.1.clone(), current_span)
+                    {
+                        if options.match_algorithm.matches_u8_insensitive(
+                            options.case_sensitive,
+                            suggestion.value.as_bytes(),
+                            &prefix,
+                        ) {
+                            output.push(suggestion);
+                        }
+                    }
+
+                    return output;
+                }
+            }
+        }
+
+        // Variable completion (e.g: $en<tab> to complete $env)
+        for builtin in builtins {
+            if options.match_algorithm.matches_u8_insensitive(
+                options.case_sensitive,
+                builtin.as_bytes(),
+                &prefix,
+            ) {
+                output.push(Suggestion {
+                    value: builtin.to_string(),
+                    description: None,
+                    extra: None,
+                    span: current_span,
+                    append_whitespace: false,
+                });
+            }
+        }
+
+        // TODO: The following can be refactored (see find_commands_by_predicate() used in
+        // command_completions).
+        let mut removed_overlays = vec![];
+        // Working set scope vars
+        for scope_frame in working_set.delta.scope.iter().rev() {
+            for overlay_frame in scope_frame.active_overlays(&mut removed_overlays).rev() {
+                for v in &overlay_frame.vars {
+                    if options.match_algorithm.matches_u8_insensitive(
+                        options.case_sensitive,
+                        v.0,
+                        &prefix,
+                    ) {
+                        output.push(Suggestion {
+                            value: String::from_utf8_lossy(v.0).to_string(),
+                            description: None,
+                            extra: None,
+                            span: current_span,
+                            append_whitespace: false,
+                        });
+                    }
+                }
+            }
+        }
+
+        // Permanent state vars
+        // for scope in &self.engine_state.scope {
+        for overlay_frame in self.engine_state.active_overlays(&removed_overlays).rev() {
+            for v in &overlay_frame.vars {
+                if options.match_algorithm.matches_u8_insensitive(
+                    options.case_sensitive,
+                    v.0,
+                    &prefix,
+                ) {
+                    output.push(Suggestion {
+                        value: String::from_utf8_lossy(v.0).to_string(),
+                        description: None,
+                        extra: None,
+                        span: current_span,
+                        append_whitespace: false,
+                    });
+                }
+            }
+        }
+
+        output.dedup(); // TODO: Removes only consecutive duplicates, is it intended?
+
+        output
+    }
+}
+
+// Find recursively the values for sublevels
+// if no sublevels are set it returns the current value
+fn nested_suggestions(
+    val: Value,
+    sublevels: Vec<Vec<u8>>,
+    current_span: reedline::Span,
+) -> Vec<Suggestion> {
+    let mut output: Vec<Suggestion> = vec![];
+    let value = recursive_value(val, sublevels);
+
+    match value {
+        Value::Record { val, .. } => {
+            // Add all the columns as completion
+            for (col, _) in val.into_iter() {
+                output.push(Suggestion {
+                    value: col,
+                    description: None,
+                    extra: None,
+                    span: current_span,
+                    append_whitespace: false,
+                });
+            }
+
+            output
+        }
+        Value::LazyRecord { val, .. } => {
+            // Add all the columns as completion
+            for column_name in val.column_names() {
+                output.push(Suggestion {
+                    value: column_name.to_string(),
+                    description: None,
+                    extra: None,
+                    span: current_span,
+                    append_whitespace: false,
+                });
+            }
+
+            output
+        }
+        Value::List { vals, .. } => {
+            for column_name in get_columns(vals.as_slice()) {
+                output.push(Suggestion {
+                    value: column_name,
+                    description: None,
+                    extra: None,
+                    span: current_span,
+                    append_whitespace: false,
+                });
+            }
+
+            output
+        }
+        _ => output,
+    }
+}
+
+// Extracts the recursive value (e.g: $var.a.b.c)
+fn recursive_value(val: Value, sublevels: Vec<Vec<u8>>) -> Value {
+    // Go to next sublevel
+    if let Some(next_sublevel) = sublevels.clone().into_iter().next() {
+        let span = val.span();
+        match val {
+            Value::Record { val, .. } => {
+                for item in val {
+                    // Check if index matches with sublevel
+                    if item.0.as_bytes().to_vec() == next_sublevel {
+                        // If matches try to fetch recursively the next
+                        return recursive_value(item.1, sublevels.into_iter().skip(1).collect());
+                    }
+                }
+
+                // Current sublevel value not found
+                return Value::nothing(span);
+            }
+            Value::LazyRecord { val, .. } => {
+                for col in val.column_names() {
+                    if col.as_bytes().to_vec() == next_sublevel {
+                        return recursive_value(
+                            val.get_column_value(col).unwrap_or_default(),
+                            sublevels.into_iter().skip(1).collect(),
+                        );
+                    }
+                }
+
+                // Current sublevel value not found
+                return Value::nothing(span);
+            }
+            Value::List { vals, .. } => {
+                for col in get_columns(vals.as_slice()) {
+                    if col.as_bytes().to_vec() == next_sublevel {
+                        return recursive_value(
+                            Value::list(vals, span)
+                                .get_data_by_key(&col)
+                                .unwrap_or_default(),
+                            sublevels.into_iter().skip(1).collect(),
+                        );
+                    }
+                }
+
+                // Current sublevel value not found
+                return Value::nothing(span);
+            }
+            _ => return val,
+        }
+    }
+
+    val
+}
+
+impl MatchAlgorithm {
+    pub fn matches_u8_insensitive(&self, sensitive: bool, haystack: &[u8], needle: &[u8]) -> bool {
+        if sensitive {
+            self.matches_u8(haystack, needle)
+        } else {
+            self.matches_u8(&haystack.to_ascii_lowercase(), &needle.to_ascii_lowercase())
+        }
+    }
+}

crates/nu-cli/src/config_files.rs

@@ -0,0 +1,126 @@
+use crate::util::eval_source;
+#[cfg(feature = "plugin")]
+use nu_path::canonicalize_with;
+use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
+use nu_protocol::report_error;
+use nu_protocol::{HistoryFileFormat, PipelineData};
+#[cfg(feature = "plugin")]
+use nu_protocol::{ParseError, Spanned};
+#[cfg(feature = "plugin")]
+use nu_utils::utils::perf;
+use std::path::PathBuf;
+
+#[cfg(feature = "plugin")]
+const PLUGIN_FILE: &str = "plugin.nu";
+
+const HISTORY_FILE_TXT: &str = "history.txt";
+const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
+
+#[cfg(feature = "plugin")]
+pub fn read_plugin_file(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    plugin_file: Option<Spanned<String>>,
+    storage_path: &str,
+) {
+    let start_time = std::time::Instant::now();
+    let mut plug_path = String::new();
+    // Reading signatures from signature file
+    // The plugin.nu file stores the parsed signature collected from each registered plugin
+    add_plugin_file(engine_state, plugin_file, 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();
+        plug_path = plugin_filename.to_string();
+        if let Ok(contents) = std::fs::read(&plugin_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &plugin_filename,
+                PipelineData::empty(),
+                false,
+            );
+        }
+    }
+
+    perf(
+        &format!("read_plugin_file {}", &plug_path),
+        start_time,
+        file!(),
+        line!(),
+        column!(),
+        engine_state.get_config().use_ansi_coloring,
+    );
+}
+
+#[cfg(feature = "plugin")]
+pub fn add_plugin_file(
+    engine_state: &mut EngineState,
+    plugin_file: Option<Spanned<String>>,
+    storage_path: &str,
+) {
+    if let Some(plugin_file) = plugin_file {
+        let working_set = StateWorkingSet::new(engine_state);
+        let cwd = working_set.get_cwd();
+
+        if let Ok(path) = canonicalize_with(&plugin_file.item, cwd) {
+            engine_state.plugin_signatures = Some(path)
+        } else {
+            let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
+            report_error(&working_set, &e);
+        }
+    } else if let Some(mut plugin_path) = nu_path::config_dir() {
+        // Path to store plugins signatures
+        plugin_path.push(storage_path);
+        plugin_path.push(PLUGIN_FILE);
+        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();
+
+        if let Ok(contents) = std::fs::read(&config_path) {
+            eval_source(
+                engine_state,
+                stack,
+                &contents,
+                &config_filename,
+                PipelineData::empty(),
+                false,
+            );
+
+            // Merge the environment in case env vars changed in the config
+            match nu_engine::env::current_dir(engine_state, stack) {
+                Ok(cwd) => {
+                    if let Err(e) = engine_state.merge_env(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);
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn get_history_path(storage_path: &str, mode: HistoryFileFormat) -> Option<PathBuf> {
+    nu_path::config_dir().map(|mut history_path| {
+        history_path.push(storage_path);
+        history_path.push(match mode {
+            HistoryFileFormat::PlainText => HISTORY_FILE_TXT,
+            HistoryFileFormat::Sqlite => HISTORY_FILE_SQLITE,
+        });
+        history_path
+    })
+}

crates/nu-cli/src/eval_cmds.rs

@@ -0,0 +1,77 @@
+use log::info;
+use miette::Result;
+use nu_engine::{convert_env_values, eval_block};
+use nu_parser::parse;
+use nu_protocol::engine::Stack;
+use nu_protocol::report_error;
+use nu_protocol::{
+    engine::{EngineState, StateWorkingSet},
+    PipelineData, Spanned, Value,
+};
+
+/// Run a command (or commands) given to us by the user
+pub fn evaluate_commands(
+    commands: &Spanned<String>,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    input: PipelineData,
+    table_mode: Option<Value>,
+) -> Result<Option<i64>> {
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    // Parse the source code
+    let (block, delta) = {
+        if let Some(ref t_mode) = table_mode {
+            let mut config = engine_state.get_config().clone();
+            config.table_mode = t_mode.as_string()?.parse().unwrap_or_default();
+            engine_state.set_config(config);
+        }
+
+        let mut working_set = StateWorkingSet::new(engine_state);
+
+        let output = parse(&mut working_set, None, commands.item.as_bytes(), false);
+        if let Some(warning) = working_set.parse_warnings.first() {
+            report_error(&working_set, warning);
+        }
+
+        if let Some(err) = working_set.parse_errors.first() {
+            report_error(&working_set, err);
+
+            std::process::exit(1);
+        }
+
+        (output, working_set.render())
+    };
+
+    // Update permanent state
+    if let Err(err) = engine_state.merge_delta(delta) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &err);
+    }
+
+    // Run the block
+    let exit_code = match eval_block(engine_state, stack, &block, input, false, false) {
+        Ok(pipeline_data) => {
+            let mut config = engine_state.get_config().clone();
+            if let Some(t_mode) = table_mode {
+                config.table_mode = t_mode.as_string()?.parse().unwrap_or_default();
+            }
+            crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &mut config)
+        }
+        Err(err) => {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &err);
+            std::process::exit(1);
+        }
+    };
+
+    info!("evaluate {}:{}:{}", file!(), line!(), column!());
+
+    Ok(exit_code)
+}

crates/nu-cli/src/eval_file.rs

@@ -0,0 +1,262 @@
+use crate::util::eval_source;
+use log::info;
+use log::trace;
+use miette::{IntoDiagnostic, Result};
+use nu_engine::eval_block;
+use nu_engine::{convert_env_values, current_dir};
+use nu_parser::parse;
+use nu_path::canonicalize_with;
+use nu_protocol::report_error;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack, StateWorkingSet},
+    Config, PipelineData, ShellError, Span, Value,
+};
+use nu_utils::stdout_write_all_and_flush;
+
+/// 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,
+) -> 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 cwd = current_dir(engine_state, stack)?;
+
+    let file_path = canonicalize_with(&path, cwd).unwrap_or_else(|e| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::FileNotFoundCustom {
+                msg: format!("Could not access file '{}': {:?}", path, e.to_string()),
+                span: Span::unknown(),
+            },
+        );
+        std::process::exit(1);
+    });
+
+    let file_path_str = file_path.to_str().unwrap_or_else(|| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::NonUtf8Custom {
+                msg: format!(
+                    "Input file name '{}' is not valid UTF8",
+                    file_path.to_string_lossy()
+                ),
+                span: Span::unknown(),
+            },
+        );
+        std::process::exit(1);
+    });
+
+    let file = std::fs::read(&file_path)
+        .into_diagnostic()
+        .unwrap_or_else(|e| {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(
+                &working_set,
+                &ShellError::FileNotFoundCustom {
+                    msg: format!(
+                        "Could not read file '{}': {:?}",
+                        file_path_str,
+                        e.to_string()
+                    ),
+                    span: Span::unknown(),
+                },
+            );
+            std::process::exit(1);
+        });
+
+    engine_state.start_in_file(Some(file_path_str));
+
+    let parent = file_path.parent().unwrap_or_else(|| {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(
+            &working_set,
+            &ShellError::FileNotFoundCustom {
+                msg: format!("The file path '{file_path_str}' does not have a parent"),
+                span: Span::unknown(),
+            },
+        );
+        std::process::exit(1);
+    });
+
+    stack.add_env_var(
+        "FILE_PWD".to_string(),
+        Value::string(parent.to_string_lossy(), Span::unknown()),
+    );
+    stack.add_env_var(
+        "CURRENT_FILE".to_string(),
+        Value::string(file_path.to_string_lossy(), Span::unknown()),
+    );
+    stack.add_env_var(
+        "PROCESS_PATH".to_string(),
+        Value::string(path, Span::unknown()),
+    );
+
+    let source_filename = file_path
+        .file_name()
+        .expect("internal error: script missing filename");
+
+    let mut working_set = StateWorkingSet::new(engine_state);
+    trace!("parsing file: {}", file_path_str);
+    let block = parse(&mut working_set, Some(file_path_str), &file, false);
+
+    if let Some(err) = working_set.parse_errors.first() {
+        report_error(&working_set, err);
+        std::process::exit(1);
+    }
+
+    for block in &mut working_set.delta.blocks {
+        if block.signature.name == "main" {
+            block.signature.name = source_filename.to_string_lossy().to_string();
+        } else if block.signature.name.starts_with("main ") {
+            block.signature.name =
+                source_filename.to_string_lossy().to_string() + " " + &block.signature.name[5..];
+        }
+    }
+
+    let _ = engine_state.merge_delta(working_set.delta);
+
+    if engine_state.find_decl(b"main", &[]).is_some() {
+        let args = format!("main {}", args.join(" "));
+
+        let pipeline_data = eval_block(
+            engine_state,
+            stack,
+            &block,
+            PipelineData::empty(),
+            false,
+            false,
+        );
+        let pipeline_data = match pipeline_data {
+            Err(ShellError::Return { .. }) => {
+                // allows early exists before `main` is run.
+                return Ok(());
+            }
+
+            x => x,
+        }
+        .unwrap_or_else(|e| {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            std::process::exit(1);
+        });
+
+        let result = pipeline_data.print(engine_state, stack, true, false);
+
+        match result {
+            Err(err) => {
+                let working_set = StateWorkingSet::new(engine_state);
+
+                report_error(&working_set, &err);
+                std::process::exit(1);
+            }
+            Ok(exit_code) => {
+                if exit_code != 0 {
+                    std::process::exit(exit_code as i32);
+                }
+            }
+        }
+
+        if !eval_source(
+            engine_state,
+            stack,
+            args.as_bytes(),
+            "<commandline>",
+            input,
+            true,
+        ) {
+            std::process::exit(1);
+        }
+    } else if !eval_source(engine_state, stack, &file, file_path_str, input, true) {
+        std::process::exit(1);
+    }
+
+    info!("evaluate {}:{}:{}", file!(), line!(), column!());
+
+    Ok(())
+}
+
+pub(crate) fn print_table_or_error(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    mut pipeline_data: PipelineData,
+    config: &mut Config,
+) -> Option<i64> {
+    let exit_code = match &mut pipeline_data {
+        PipelineData::ExternalStream { exit_code, .. } => exit_code.take(),
+        _ => None,
+    };
+
+    // Change the engine_state config to use the passed in configuration
+    engine_state.set_config(config.clone());
+
+    if let PipelineData::Value(Value::Error { error, .. }, ..) = &pipeline_data {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &**error);
+        std::process::exit(1);
+    }
+
+    if let Some(decl_id) = engine_state.find_decl("table".as_bytes(), &[]) {
+        let command = engine_state.get_decl(decl_id);
+        if command.get_block_id().is_some() {
+            print_or_exit(pipeline_data, engine_state, config);
+        } else {
+            // The final call on table command, it's ok to set redirect_output to false.
+            let mut call = Call::new(Span::new(0, 0));
+            call.redirect_stdout = false;
+            let table = command.run(engine_state, stack, &call, pipeline_data);
+
+            match table {
+                Ok(table) => {
+                    print_or_exit(table, engine_state, config);
+                }
+                Err(error) => {
+                    let working_set = StateWorkingSet::new(engine_state);
+                    report_error(&working_set, &error);
+                    std::process::exit(1);
+                }
+            }
+        }
+    } else {
+        print_or_exit(pipeline_data, engine_state, config);
+    }
+
+    // Make sure everything has finished
+    if let Some(exit_code) = exit_code {
+        let mut exit_code: Vec<_> = exit_code.into_iter().collect();
+        exit_code
+            .pop()
+            .and_then(|last_exit_code| match last_exit_code {
+                Value::Int { val: code, .. } => Some(code),
+                _ => None,
+            })
+    } else {
+        None
+    }
+}
+
+fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, config: &Config) {
+    for item in pipeline_data {
+        if let Value::Error { error, .. } = item {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &*error);
+
+            std::process::exit(1);
+        }
+
+        let out = item.into_string("\n", config) + "\n";
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{err}"));
+    }
+}