Use tempfiles for clircle tests

Change circle detection to use new more conservative method and run in main loop instead of before the loop
Update syntaxes and themes
2026-08-03 18:51:44 +00:00 · 2021-02-28 23:04:49 +01:00 · 2021-02-28 23:04:49 +01:00 · 2021-02-28 18:57:11 +01:00 · 2021-02-28 18:57:11 +01:00 · 2021-02-28 18:09:44 +01:00
338 changed files with 22130 additions and 2126 deletions
@@ -7,33 +7,41 @@ assignees: ''

 ---

-<!--
-Hey there, thanks for creating an issue!
-
-In order to reproduce your issue, we might need to know a little bit more about the environment
-which you're running `bat` on.
-
-If you're on Linux or MacOS:
-  Please run the script at https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh and
-  paste the output at the bottom of the bug report.
-
-If you're on Windows:
-  Please tell us about your Windows Version (e.g. "Windows 10 1908") at the
-  bottom of the bug report.
-->
+<!-- Hey there, thank you for creating an issue! -->

 **What version of `bat` are you using?**
-[paste the output of `bat --version` here]
+
+<!-- Output of `bat --version` -->
+

 **Describe the bug you encountered:**
+
 ...

-**Describe what you expected to happen?**
+**What did you expect to happen instead?**
+
 ...

+
 **How did you install `bat`?**
-apt-get, homebrew, GitHub release, etc.
+
+<!-- apt-get, homebrew, GitHub release, etc. -->

 ---

-[paste the output of `info.sh` here]
+**Environment**
+
+<!--
+In order to reproduce your issue, please add some information about the environment
+in which you're running bat.
+
+Linux and MacOS:
+  Please run the script at
+
+    https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh
+
+  (click "Raw" to get the actual source code) and paste the Markdown output here.
+
+Windows:
+  Please add your Windows Version (e.g. "Windows 10 1908")
+-->
@@ -1,38 +1,50 @@
 name: CICD

 env:
-  PROJECT_NAME: bat
-  PROJECT_DESC: "A `cat` clone with wings"
-  PROJECT_MAINTAINER: "David Peter <mail@david-peter.de>"
-  PROJECT_HOMEPAGE: "https://github.com/sharkdp/bat"
-  MIN_SUPPORTED_RUST_VERSION: "1.40.0"
+  MIN_SUPPORTED_RUST_VERSION: "1.42.0"
+  CICD_INTERMEDIATES_DIR: "_cicd-intermediates"

-on: [push, pull_request]
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'

 jobs:
  min_version:
    name: Minimum supported rust version
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-18.04
    steps:
    - name: Git checkout
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})
      uses: actions-rs/toolchain@v1
      with:
        toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}
        default: true
        profile: minimal # minimal component installation (ie, no documentation)
-    - name: Test
+        components: clippy
+    - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
+      uses: actions-rs/cargo@v1
+      with:
+        command: clippy
+        # clippy::match_bool is allowed by default from Rust 1.45.0, see
+        # https://github.com/rust-lang/rust-clippy/commit/e1d13c34b0beaea9a5fbf13687672ef85e779d9f
+        args: --all-targets --all-features -- --allow clippy::match_bool
+    - name: Run tests
      uses: actions-rs/cargo@v1
      with:
        command: test

  test_with_new_syntaxes_and_themes:
-    name: Test with new syntaxes and themes
-    runs-on: ubuntu-latest
+    name: Run tests with updated syntaxes and themes
+    runs-on: ubuntu-18.04
    steps:
    - name: Git checkout
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
      with:
        submodules: true # we need all syntax and theme submodules
    - name: Install Rust toolchain
@@ -58,6 +70,11 @@ jobs:
      with:
        command: test
        args: --release
+    - name: Run ignored-by-default unit tests with new syntaxes and themes
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --release -- --ignored
    - name: Syntax highlighting regression test
      run: tests/syntax-tests/regression_test.sh
    - name: List of languages
@@ -66,28 +83,27 @@ jobs:
      run: bat --list-themes

  build:
-    name: Build
+    name: ${{ matrix.job.os }} (${{ matrix.job.target }})
    runs-on: ${{ matrix.job.os }}
    strategy:
      fail-fast: false
      matrix:
        job:
-          # { os, target, cargo-options, features, use-cross, toolchain }
-          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: aarch64-unknown-linux-gnu   , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , use-cross: use-cross }
-          - { os: ubuntu-16.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
-          - { os: macos-latest   , target: x86_64-apple-darwin         }
-          # - { os: windows-latest , target: i686-pc-windows-gnu         }  ## disabled; linker errors (missing '_imp____acrt_iob_func')
-          - { os: windows-latest , target: i686-pc-windows-msvc        }
-          # - { os: windows-latest , target: x86_64-pc-windows-gnu       }  ## disabled; linker errors (missing '_imp____acrt_iob_func')
-          - { os: windows-latest , target: x86_64-pc-windows-msvc      }
+          - { os: ubuntu-18.04 , target: arm-unknown-linux-gnueabihf , use-cross: true }
+          - { os: ubuntu-18.04 , target: aarch64-unknown-linux-gnu   , use-cross: true }
+          - { os: ubuntu-18.04 , target: i686-unknown-linux-gnu      , use-cross: true }
+          - { os: ubuntu-18.04 , target: i686-unknown-linux-musl     , use-cross: true }
+          - { os: ubuntu-18.04 , target: x86_64-unknown-linux-gnu    }
+          - { os: ubuntu-18.04 , target: x86_64-unknown-linux-musl   , use-cross: true }
+          - { os: macos-10.15  , target: x86_64-apple-darwin         }
+          # - { os: windows-2019 , target: i686-pc-windows-gnu         }  ## disabled; error: linker `i686-w64-mingw32-gcc` not found
+          - { os: windows-2019 , target: i686-pc-windows-msvc        }
+          - { os: windows-2019 , target: x86_64-pc-windows-gnu       }
+          - { os: windows-2019 , target: x86_64-pc-windows-msvc      }
    steps:
-    - name: Git checkout
-      uses: actions/checkout@v1
+    - name: Checkout source code
+      uses: actions/checkout@v2
+
    - name: Install prerequisites
      shell: bash
      run: |
@@ -95,121 +111,24 @@ jobs:
          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
          aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
        esac
-    - name: Initialize workflow variables
-      id: vars
+
+    - name: Extract crate information
      shell: bash
      run: |
-        # toolchain
-        TOOLCHAIN="stable" ## default to "stable" toolchain
-        # * specify alternate TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: <https://github.com/rust-lang/rust/issues/47048>, <https://github.com/rust-lang/rust/issues/53454>, <https://github.com/rust-lang/cargo/issues/6754>)
-        case ${{ matrix.job.target }} in *-pc-windows-gnu) TOOLCHAIN="stable-${{ matrix.job.target }}" ;; esac;
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
-        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
-        # staging directory
-        STAGING='_staging'
-        echo set-output name=STAGING::${STAGING}
-        echo ::set-output name=STAGING::${STAGING}
-        # determine EXE suffix
-        EXE_suffix="" ; case ${{ matrix.job.target }} in *-pc-windows-*) EXE_suffix=".exe" ;; esac;
-        echo set-output name=EXE_suffix::${EXE_suffix}
-        echo ::set-output name=EXE_suffix::${EXE_suffix}
-        # parse commit reference info
-        REF_NAME=${GITHUB_REF#refs/*/}
-        unset REF_BRANCH ; case ${GITHUB_REF} in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;
-        unset REF_TAG ; case ${GITHUB_REF} in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;
-        REF_SHAS=${GITHUB_SHA:0:8}
-        echo set-output name=REF_NAME::${REF_NAME}
-        echo set-output name=REF_BRANCH::${REF_BRANCH}
-        echo set-output name=REF_TAG::${REF_TAG}
-        echo set-output name=REF_SHAS::${REF_SHAS}
-        echo ::set-output name=REF_NAME::${REF_NAME}
-        echo ::set-output name=REF_BRANCH::${REF_BRANCH}
-        echo ::set-output name=REF_TAG::${REF_TAG}
-        echo ::set-output name=REF_SHAS::${REF_SHAS}
-        # parse target
-        unset TARGET_ARCH ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) TARGET_ARCH=arm ;; i686-*) TARGET_ARCH=i686 ;; x86_64-*) TARGET_ARCH=x86_64 ;; esac;
-        echo set-output name=TARGET_ARCH::${TARGET_ARCH}
-        echo ::set-output name=TARGET_ARCH::${TARGET_ARCH}
-        unset TARGET_OS ; case ${{ matrix.job.target }} in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
-        echo set-output name=TARGET_OS::${TARGET_OS}
-        echo ::set-output name=TARGET_OS::${TARGET_OS}
-        # package name
-        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
-        PKG_BASENAME=${PROJECT_NAME}-${REF_TAG:-$REF_SHAS}-${{ matrix.job.target }}
-        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-        echo set-output name=PKG_suffix::${PKG_suffix}
-        echo set-output name=PKG_BASENAME::${PKG_BASENAME}
-        echo set-output name=PKG_NAME::${PKG_NAME}
-        echo ::set-output name=PKG_suffix::${PKG_suffix}
-        echo ::set-output name=PKG_BASENAME::${PKG_BASENAME}
-        echo ::set-output name=PKG_NAME::${PKG_NAME}
-        # deployable tag? (ie, leading "vM" or "M"; M == version number)
-        unset DEPLOY ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DEPLOY='true' ; fi
-        echo set-output name=DEPLOY::${DEPLOY:-<empty>/false}
-        echo ::set-output name=DEPLOY::${DEPLOY}
-        # DPKG architecture?
-        unset DPKG_ARCH
-        case ${{ matrix.job.target }} in
-          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
-          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
-          i686-*-linux-*) DPKG_ARCH=i686 ;;
-          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
-        esac;
-        echo set-output name=DPKG_ARCH::${DPKG_ARCH}
-        echo ::set-output name=DPKG_ARCH::${DPKG_ARCH}
-        # DPKG version?
-        unset DPKG_VERSION ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DPKG_VERSION=${REF_TAG/#[vV]/} ; fi
-        echo set-output name=DPKG_VERSION::${DPKG_VERSION}
-        echo ::set-output name=DPKG_VERSION::${DPKG_VERSION}
-        # DPKG base name/conflicts?
-        DPKG_BASENAME=${PROJECT_NAME}
-        DPKG_CONFLICTS=${PROJECT_NAME}-musl
-        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;
-        echo set-output name=DPKG_BASENAME::${DPKG_BASENAME}
-        echo set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}
-        echo ::set-output name=DPKG_BASENAME::${DPKG_BASENAME}
-        echo ::set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}
-        # DPKG name
-        unset DPKG_NAME;
-        if [[ -n $DPKG_ARCH && -n $DPKG_VERSION ]]; then DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb" ; fi
-        echo set-output name=DPKG_NAME::${DPKG_NAME}
-        echo ::set-output name=DPKG_NAME::${DPKG_NAME}
-        # target-specific options
-        # * CARGO_USE_CROSS (truthy)
-        CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
-        echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}
-        echo ::set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS}
-        # # * `arm` cannot be tested on ubuntu-* hosts (b/c testing is currently primarily done via comparison of target outputs with built-in outputs and the `arm` target is not executable on the host)
-        JOB_DO_TESTING="true"
-        case ${{ matrix.job.target }} in arm-*) unset JOB_DO_TESTING ;; esac;
-        echo set-output name=JOB_DO_TESTING::${JOB_DO_TESTING:-<empty>/false}
-        echo ::set-output name=JOB_DO_TESTING::${JOB_DO_TESTING}
-        # # * test only library unit tests and binary for arm-type targets
-        unset CARGO_TEST_OPTIONS
-        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;
-        echo set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
-        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
-        # * executable for `strip`?
-        STRIP="strip" ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;; aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;; *-pc-windows-msvc) STRIP="" ;; esac;
-        echo set-output name=STRIP::${STRIP}
-        echo ::set-output name=STRIP::${STRIP}
-    - name: Create all needed build/work directories
-      shell: bash
-      run: |
-        mkdir -p '${{ steps.vars.outputs.STAGING }}'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/autocomplete'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/dpkg'
+        echo "PROJECT_NAME=$(sed -n 's/^name = "\(.*\)"/\1/p' Cargo.toml)" >> $GITHUB_ENV
+        echo "PROJECT_VERSION=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
+        echo "PROJECT_MAINTAINER=$(sed -n 's/^authors = \["\(.*\)"\]/\1/p' Cargo.toml)" >> $GITHUB_ENV
+        echo "PROJECT_HOMEPAGE=$(sed -n 's/^homepage = "\(.*\)"/\1/p' Cargo.toml)" >> $GITHUB_ENV
+
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
      with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
+        toolchain: stable
        target: ${{ matrix.job.target }}
        override: true
        profile: minimal # minimal component installation (ie, no documentation)
-    - name: Info
+
+    - name: Show version information (Rust, cargo, GCC)
      shell: bash
      run: |
        gcc --version || true
@@ -218,63 +137,124 @@ jobs:
        rustup default
        cargo -V
        rustc -V
+
    - name: Build
      uses: actions-rs/cargo@v1
      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
+        use-cross: ${{ matrix.job.use-cross }}
        command: build
-        args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }}
-    - name: Test
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: test
-        args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }}
-    - name: bat test run
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: run
-        args: --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} -- --paging=never --color=always --theme=ansi-dark Cargo.toml src/config.rs
-    - name: Check features regex-onig
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig
-    - name: Check features regex-onig,git
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git
-    - name: Check features regex-onig,paging
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging
-    - name: Check features regex-onig,git,paging
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: check
-        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging
-    - name: Upload build artifacts
-      uses: actions/upload-artifact@master
-      with:
-        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
-        path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
-    - name: Package
+        args: --release --target=${{ matrix.job.target }}
+
+    - name: Strip debug information from executable
+      id: strip
      shell: bash
      run: |
-        ARCHIVE_DIR='${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
-        COPYRIGHT_YEARS="2018 - "$(date "+%Y")
-        # Binary
-        cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "$ARCHIVE_DIR"
+        # Figure out suffix of binary
+        EXE_suffix=""
+        case ${{ matrix.job.target }} in
+          *-pc-windows-*) EXE_suffix=".exe" ;;
+        esac;

-        # `strip` binary (if needed)
-        if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "$ARCHIVE_DIR/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi
+        # Figure out what strip tool to use if any
+        STRIP="strip"
+        case ${{ matrix.job.target }} in
+          arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;;
+          aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
+          *-pc-windows-msvc) STRIP="" ;;
+        esac;
+
+        # Setup paths
+        BIN_DIR="${{ env.CICD_INTERMEDIATES_DIR }}/stripped-release-bin/"
+        mkdir -p "${BIN_DIR}"
+        BIN_NAME="${{ env.PROJECT_NAME }}${EXE_suffix}"
+        BIN_PATH="${BIN_DIR}/${BIN_NAME}"
+
+        # Copy the release build binary to the result location
+        cp "target/${{ matrix.job.target }}/release/${BIN_NAME}" "${BIN_DIR}"
+
+        # Also strip if possible
+        if [ -n "${STRIP}" ]; then
+          "${STRIP}" "${BIN_PATH}"
+        fi
+
+        # Let subsequent steps know where to find the (stripped) bin
+        echo ::set-output name=BIN_PATH::${BIN_PATH}
+        echo ::set-output name=BIN_NAME::${BIN_NAME}
+
+    - name: Set testing options
+      id: test-options
+      shell: bash
+      run: |
+        # test only library unit tests and binary for arm-type targets
+        unset CARGO_TEST_OPTIONS
+        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;
+        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
+
+    - name: Run tests
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: test
+        args: --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
+
+    - name: Run bat
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: run
+        args: --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs
+
+    - name: Show diagnostics (bat --diagnostic)
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: run
+        args: --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs --diagnostic
+
+    - name: "Feature check: regex-onig"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig
+
+    - name: "Feature check: regex-onig,git"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git
+
+    - name: "Feature check: regex-onig,paging"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging
+
+    - name: "Feature check: regex-onig,git,paging"
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ matrix.job.use-cross }}
+        command: check
+        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging
+
+    - name: Create tarball
+      id: package
+      shell: bash
+      run: |
+        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
+        PKG_BASENAME=${PROJECT_NAME}-v${PROJECT_VERSION}-${{ matrix.job.target }}
+        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
+        echo ::set-output name=PKG_NAME::${PKG_NAME}
+
+        PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
+        ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
+        mkdir -p "${ARCHIVE_DIR}"
+        mkdir -p "${ARCHIVE_DIR}/autocomplete"
+
+        # Binary
+        cp "${{ steps.strip.outputs.BIN_PATH }}" "$ARCHIVE_DIR"

        # Man page
        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"
@@ -287,49 +267,62 @@ jobs:
        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.zsh"

        # base compressed package
-        pushd '${{ steps.vars.outputs.STAGING }}/' >/dev/null
+        pushd "${PKG_STAGING}/" >/dev/null
        case ${{ matrix.job.target }} in
-          *-pc-windows-*) 7z -y a '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* | tail -2 ;;
-          *) tar czf '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* ;;
+          *-pc-windows-*) 7z -y a "${PKG_NAME}" "${PKG_BASENAME}"/* | tail -2 ;;
+          *) tar czf "${PKG_NAME}" "${PKG_BASENAME}"/* ;;
        esac;
        popd >/dev/null

-        # Debian package
-        if [ -n "${{ steps.vars.outputs.DPKG_NAME }}" ]; then
-          DPKG_DIR="${{ steps.vars.outputs.STAGING }}/dpkg"
+        # Let subsequent steps know where to find the compressed package
+        echo ::set-output name=PKG_PATH::"${PKG_STAGING}/${PKG_NAME}"

-          # Binary
-          install -Dm755 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}"
-          if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi
+    - name: Create Debian package
+      id: debian-package
+      shell: bash
+      if: startsWith(matrix.job.os, 'ubuntu')
+      run: |
+        COPYRIGHT_YEARS="2018 - "$(date "+%Y")
+        DPKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/debian-package"
+        DPKG_DIR="${DPKG_STAGING}/dpkg"
+        mkdir -p "${DPKG_DIR}"

-          # Work out shared library dependencies
-          # dpkg-shlibdeps requires debian/control file. Dummy it and clean up
-          mkdir "./debian"
-          touch "./debian/control"
-          case ${{ matrix.job.target }} in
-            aarch64-*-linux-*) DEPENDS="$(dpkg-shlibdeps -l/usr/aarch64-linux-gnu/lib -O "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}" 2> /dev/null | sed 's/^shlibs:Depends=//')" ;;
-            arm-*-linux-*hf) DEPENDS="$(dpkg-shlibdeps -l/usr/arm-linux-gnueabihf/lib -O "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}" 2> /dev/null | sed 's/^shlibs:Depends=//')" ;;
-            i686-*-linux-*) DEPENDS="$(dpkg-shlibdeps -O "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}" 2> /dev/null | sed 's/^shlibs:Depends=//')" ;;
-            x86_64-*-linux-*) DEPENDS="$(dpkg-shlibdeps -O "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}" 2> /dev/null | sed 's/^shlibs:Depends=//')" ;;
-          esac;
-          rm -rf "./debian"
+        DPKG_BASENAME=${PROJECT_NAME}
+        DPKG_CONFLICTS=${PROJECT_NAME}-musl
+        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;
+        DPKG_VERSION=${PROJECT_VERSION}

-          # Man page
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
-          gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        unset DPKG_ARCH
+        case ${{ matrix.job.target }} in
+          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
+          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
+          i686-*-linux-*) DPKG_ARCH=i686 ;;
+          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
+          *) DPKG_ARCH=notset ;;
+        esac;

-          # Autocompletion files
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ env.PROJECT_NAME }}"
+        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
+        echo ::set-output name=DPKG_NAME::${DPKG_NAME}

-          # README and LICENSE
-          install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/README.md"
-          install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/LICENSE-MIT"
-          install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/LICENSE-APACHE"
-          install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/changelog"
-          gzip -n --best "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/changelog"
+        # Binary
+        install -Dm755 "${{ steps.strip.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.strip.outputs.BIN_NAME }}"

-          cat > "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/copyright" <<EOF
+        # Man page
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+
+        # Autocompletion files
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"
+        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ env.PROJECT_NAME }}"
+
+        # README and LICENSE
+        install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
+        install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"
+        install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"
+        install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
+        gzip -n --best "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
+
+        cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
        Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
        Upstream-Name: ${{ env.PROJECT_NAME }}
        Source: ${{ env.PROJECT_HOMEPAGE }}
@@ -340,117 +333,84 @@ jobs:
        License: Apache-2.0 or MIT

        License: Apache-2.0
-         On Debian systems, the complete text of the Apache-2.0 can be found in the
-         file /usr/share/common-licenses/Apache-2.0.
+          On Debian systems, the complete text of the Apache-2.0 can be found in the
+          file /usr/share/common-licenses/Apache-2.0.

        License: MIT
-         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.
+          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.
        EOF
-          chmod 644 "${DPKG_DIR}/usr/share/doc/${{ steps.vars.outputs.DPKG_BASENAME }}/copyright"
+          chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"

          # control file
          mkdir -p "${DPKG_DIR}/DEBIAN"
          cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
-        Package: ${{ steps.vars.outputs.DPKG_BASENAME }}
-        Version: ${{ steps.vars.outputs.DPKG_VERSION }}
+        Package: ${DPKG_BASENAME}
+        Version: ${DPKG_VERSION}
        Section: utils
        Priority: optional
        Maintainer: ${{ env.PROJECT_MAINTAINER }}
        Homepage: ${{ env.PROJECT_HOMEPAGE }}
-        Architecture: ${{ steps.vars.outputs.DPKG_ARCH }}
-        Depends: $DEPENDS
+        Architecture: ${DPKG_ARCH}
        Provides: ${{ env.PROJECT_NAME }}
-        Conflicts: ${{ steps.vars.outputs.DPKG_CONFLICTS }}
+        Conflicts: ${DPKG_CONFLICTS}
        Description: cat(1) clone with wings.
-         A cat(1) clone with syntax highlighting and Git integration.
+          A cat(1) clone with syntax highlighting and Git integration.
        EOF

-          # build dpkg
-          fakeroot dpkg-deb --build "${DPKG_DIR}" "${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}"
-        fi
-    - name: Publish archives and packages
-      uses: softprops/action-gh-release@v1
-      if: steps.vars.outputs.DEPLOY
-      with:
-        files: |
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
+        echo ::set-output name=DPKG_PATH::${DPKG_PATH}

-  coverage:
-    name: Code Coverage
-    runs-on: ${{ matrix.job.os }}
-    strategy:
-      fail-fast: true
-      matrix:
-        # job: [ { os: ubuntu-latest }, { os: macos-latest }, { os: windows-latest } ]
-        job:
-          - { os: ubuntu-latest , toolchain: nightly-2020-04-29 }
-          - { os: macos-latest , toolchain: nightly-2020-04-29 }
-          - { os: windows-latest , toolchain: nightly-2020-04-29-x86_64-pc-windows-gnu }
-    steps:
-    - uses: actions/checkout@v1
-    - name: Initialize workflow variables
-      id: vars
+        # build dpkg
+        fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
+
+    - name: "Artifact upload: tarball"
+      uses: actions/upload-artifact@master
+      with:
+        name: ${{ steps.package.outputs.PKG_NAME }}
+        path: ${{ steps.package.outputs.PKG_PATH }}
+
+    - name: "Artifact upload: Debian package"
+      uses: actions/upload-artifact@master
+      if: steps.debian-package.outputs.DPKG_NAME
+      with:
+        name: ${{ steps.debian-package.outputs.DPKG_NAME }}
+        path: ${{ steps.debian-package.outputs.DPKG_PATH }}
+
+    - name: Check for release
+      id: is-release
      shell: bash
      run: |
-        # toolchain
-        TOOLCHAIN="nightly" ## default to "nightly" toolchain
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        # * use requested TOOLCHAIN if specified
-        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
-        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
-        # target-specific options
-        # * CODECOV_FLAGS
-        CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
-        echo set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}
-        echo ::set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}
-    - name: rust toolchain ~ install
-      uses: actions-rs/toolchain@v1
+        unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
+        echo ::set-output name=IS_RELEASE::${IS_RELEASE}
+
+    - name: Publish archives and packages
+      uses: softprops/action-gh-release@v1
+      if: steps.is-release.outputs.IS_RELEASE
      with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
-        override: true
-        profile: minimal # minimal component installation (ie, no documentation)
-    - name: Test
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --no-fail-fast
+        files: |
+          ${{ steps.package.outputs.PKG_PATH }}
+          ${{ steps.debian-package.outputs.DPKG_PATH }}
      env:
-        CARGO_INCREMENTAL: '0'
-        RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads'
-    - name: Generate coverage data
-      id: coverage
-      uses: actions-rs/grcov@v0.1
-    - name: Upload coverage results (to Codecov.io)
-      uses: codecov/codecov-action@v1
-      with:
-        file: ${{ steps.coverage.outputs.report }}
-        flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
-        name: codecov-umbrella
-        fail_ci_if_error: false
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -185,9 +185,6 @@
 [submodule "assets/syntaxes/02_Extra/AsciiDoc"]
 	path = assets/syntaxes/02_Extra/AsciiDoc
 	url = https://github.com/asciidoctor/sublimetext-asciidoc.git
-[submodule "assets/themes/gruvbox"]
-	path = assets/themes/gruvbox
-	url = https://github.com/peaceant/gruvbox.git
 [submodule "assets/syntaxes/02_Extra/GLSL"]
 	path = assets/syntaxes/02_Extra/GLSL
 	url = https://github.com/euler0/sublime-glsl
@@ -197,3 +194,25 @@
 [submodule "assets/syntaxes/02_Extra/Apache"]
 	path = assets/syntaxes/02_Extra/Apache
 	url = https://github.com/colinta/ApacheConf.tmLanguage
+[submodule "assets/syntaxes/02_Extra/Ninja"]
+	path = assets/syntaxes/02_Extra/Ninja
+	url = https://github.com/pope/SublimeNinja.git
+[submodule "assets/syntaxes/02_Extra/Svelte"]
+	path = assets/syntaxes/02_Extra/Svelte
+	url = https://github.com/corneliusio/svelte-sublime
+[submodule "assets/themes/Coldark"]
+	path = assets/themes/Coldark
+	url = https://github.com/ArmandPhilippot/coldark-bat.git
+[submodule "assets/themes/gruvbox"]
+	path = assets/themes/gruvbox
+	url = https://github.com/subnut/gruvbox-tmTheme.git
+	branch = bat-source
+[submodule "assets/syntaxes/02_Extra/Lean"]
+	path = assets/syntaxes/02_Extra/Lean
+	url = https://github.com/leanprover/vscode-lean.git
+[submodule "assets/syntaxes/02_Extra/Zig"]
+	path = assets/syntaxes/02_Extra/Zig
+	url = https://github.com/ziglang/sublime-zig-language.git
+[submodule "assets/syntaxes/02_Extra/gnuplot"]
+	path = assets/syntaxes/02_Extra/gnuplot
+	url = https://github.com/hesstobi/sublime_gnuplot
@@ -1,18 +1,87 @@
 # unreleased

+
 ## Features

+- Use a pager when `bat --list-languages` is called, see #1394 (@stku1985)
+
 ## Bugfixes

+- If the last line doesn't end with a newline character, don't add it if `--style=plain`, see #1438 (@Enselic)
+- Only print themes hint in interactive mode (`bat --list-themes`), see #1439 (@rsteube)
+- Make ./tests/syntax-tests/regression_test.sh work on recent versions of macOS, see #1443 (@Enselic)
+- VimL syntax highlighting fix, see #1450 (@esensar)
+- Print an 'Invalid syntax theme settings' error message if a custom theme is broken, see #614 (@Enselic)
+- If plain mode is set and wrap is not explicitly opted in, long lines will no be truncated, see #1426
+- If `PAGER` (but not `BAT_PAGER` or `--pager`) is `more` or `most`, silently use `less` instead to ensure support for colors, see #1063 (@Enselic)
+- If `PAGER` is `bat`, silently use `less` to prevent recursion. For `BAT_PAGER` or `--pager`, exit with error, see #1413 (@Enselic)
+- Manpage highlighting fix, see #1511 (@keith-hall)
+- `BAT_CONFIG_PATH` ignored by `bat` if non-existent, see #1550 (@sharkdp)
+
 ## Other

+- Performance improvements, see #1421 (@LovecraftianHorror)
+- Added a new `--diagnostic` option to collect information for bug reports, see #1459 (@sharkdp)
+- Modified default theme colors to differentiate between a JSON key and a string value, see #1400 (@keith-hall)
+- Upped min required Rust version to 1.42
+
 ## Syntaxes

+- Added Zig syntax, see #1470 (@paulsmith)
+- Added Lean syntax, see #1446 (@Julian)
+- Added `.resource` extension for Robot Framework files, see #1386
+- Added `gnuplot` syntax, see #1431 (@sharkdp)
+- Highlight *.pac (Proxy auto-config) files as JavaScript, see #1515 (@sharkdp)
+
 ## New themes

+- `ansi` replaces `ansi-dark` and `ansi-light`, see #1104 and #1412 (@mk12). **Breaking change:** users that were previously using one of the `ansi-*` themes should switch to `ansi`.
+- The Gruvbox theme has been updated, see #1291 (@j0hnmeow). **Breaking change:** users that were previously using `gruvbox` or `gruvbox-white` should update and use `gruvbox-dark`/`gruvbox-light` instead.
+
 ## `bat` as a library

-## Packaging
+- The following `PrettyPrinter` methods have been removed (they were previously deprecated):
+   - `input_stdin_with_name`
+   - `input_from_bytes_with_name`
+   - `input_from_reader_with_name`
+   - `vcs_modification_markers` (if the `git` feature is not enabled)
+
+
+# v0.17.1
+
+## Bugfixes
+
+- Running `bat` without arguments fails ("output file is also an input"), see #1396
+
+
+# v0.17.0
+
+## Features
+
+- Added a new `--style` value, `rule`, which adds a simple horizontal ruled line between files, see #1276 (@tommilligan)
+- Pass `-S` ("chop long lines") to `less` if `--wrap=never` is set in `bat`, see #1255 (@gahag)
+
+## Bugfixes
+
+- Detect infinite loop when input and output are the same, see #1193 and #1197 (@niklasmohrin)
+- Throw an error when `bat` is being used as `pager`, see #1343 (@adrian-rivera)
+- Bash syntax highlighting not selected for `*.ebuild` and `*.eclass` files, see #1292 (@sharkdp)
+- Fix `zsh` completion when using `-p`, see #1320 (@xzfc)
+
+## Other
+
+- Add note to refer to see detailed help with `--help` (and vice versa with `-h`), see #1215 (@henil)
+- Add a `Contributors` section to `README`, see #1348 (@adrian-rivera)
+
+## Syntaxes
+
+- Manpage syntax highlighting has been improved, see #1315 (@keith-hall)
+- Add Svelte file syntax, see #1285 (@kjmph)
+
+## New themes
+
+- Coldark, see #1329 (@armandphilippot)
+

 # v0.16.0

@@ -0,0 +1,48 @@
+# Contributing
+
+Thank you for considering to contribute to `bat`!
+
+
+
+## Add an entry to the changelog
+
+If your contribution changes the behavior of `bat` (as opposed to a typo-fix
+in the documentation), please update the [`CHANGELOG.md`](CHANGELOG.md) file
+and describe your changes. This makes the release process much easier and
+therefore helps to get your changes into a new `bat` release faster.
+
+The top of the `CHANGELOG` contains a *"unreleased"* section with a few
+subsections (Features, Bugfixes, …). Please add your entry to the subsection
+that best describes your change.
+
+Entries follow this format:
+```
+- Short description of what has been changed, see #123 (@user)
+```
+Here, `#123` is the number of the original issue and/or your pull request.
+Please replace `@user` by your GitHub username.
+
+
+## Development
+
+Please check out the [Development](https://github.com/sharkdp/bat#development)
+section in the README.
+
+
+## Adding a new feature
+
+Please consider opening a
+[feature request ticket](https://github.com/sharkdp/bat/issues/new?assignees=&labels=feature-request&template=feature_request.md)
+first in order to give us a chance to discuss the feature first.
+
+
+## Adding new syntaxes/languages or themes
+
+Before you make a pull request that adds a new syntax or theme, please read
+the [Customization](https://github.com/sharkdp/bat#customization) section
+in the README first.
+
+If you really think that a particular syntax or theme should be added for all
+users, please read the corresponding
+[documentation](https://github.com/sharkdp/bat/blob/master/doc/assets.md)
+first.
@@ -1,17 +1,13 @@
 [package]
 authors = ["David Peter <mail@david-peter.de>"]
 categories = ["command-line-utilities"]
-description="A cat(1) clone with wings."
+description = "A cat(1) clone with wings."
 homepage = "https://github.com/sharkdp/bat"
 license = "MIT/Apache-2.0"
 name = "bat"
-readme = "README.md"
 repository = "https://github.com/sharkdp/bat"
-version = "0.16.0"
-exclude = [
-    "assets/syntaxes/*",
-    "assets/themes/*",
-]
+version = "0.18.0"
+exclude = ["assets/syntaxes/*", "assets/themes/*"]
 build = "build.rs"
 edition = '2018'

@@ -22,7 +18,7 @@ default = ["application"]
 application = [
    "atty",
    "clap",
-    "dirs",
+    "dirs-next",
    "git",
    "lazy_static",
    "paging",
@@ -31,6 +27,8 @@ application = [
 ]
 git = ["git2"] # Support indicating git modifications
 paging = ["shell-words"] # Support applying a pager on the output
+
+# You need to use one of these if you depend on bat as a library:
 regex-onig = ["syntect/regex-onig"] # Use the "oniguruma" regex engine
 regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine

@@ -38,8 +36,7 @@ regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine
 atty = { version = "0.2.14", optional = true }
 ansi_term = "^0.12.1"
 ansi_colours = "^1.0"
-console = "0.12.0"
-dirs = { version = "3.0", optional = true }
+console = "0.14.0"
 lazy_static = { version = "1.4", optional = true }
 wild = { version = "2.0", optional = true }
 content_inspector = "0.2.4"
@@ -51,6 +48,9 @@ serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.8"
 semver = "0.11"
 path_abs = { version = "0.5", default-features = false }
+clircle = "0.3"
+bugreport = "0.3"
+dirs-next = { version = "2.0.0", optional = true }

 [dependencies.git2]
 version = "0.13"
@@ -58,7 +58,7 @@ optional = true
 default-features = false

 [dependencies.syntect]
-version = "4.4.0"
+version = "4.5.0"
 default-features = false
 features = ["parsing", "yaml-load", "dump-load", "dump-create"]

@@ -73,9 +73,14 @@ version = "0.12"
 default-features = false

 [dev-dependencies]
-tempdir = "0.3"
-assert_cmd = "1.0.1"
-predicates = "1.0.5"
+assert_cmd = "1.0.2"
+serial_test = "0.5.1"
+predicates = "1.0.7"
+wait-timeout = "0.2.0"
+tempfile = "3.2.0"
+
+[target.'cfg(unix)'.dev-dependencies]
+nix = "0.19.1"

 [build-dependencies]
 clap = { version = "2.33", optional = true }
@@ -38,14 +38,14 @@ characters:

 ### Automatic paging

-`bat` can pipe its own output to a pager (e.g `less`) if the output is too large for one screen.
+By default, `bat` pipes its own output to a pager (e.g `less`) if the output is too large for one screen.
+If you would rather `bat` work like `cat` all the time (never page output), you can set `--paging=never` as an option, either on the command line or in your configuration file.
+If you intend to alias `cat` to `bat` in your shell configuration, you can use `alias cat='bat --paging=never'` to preserve the default behavior.

-### File concatenation
+#### File concatenation

-Oh.. you can also use it to concatenate files :wink:. Whenever
-`bat` detects a non-interactive terminal (i.e. when you pipe into another process
-or into a file), `bat` will act as a drop-in replacement for `cat` and
-fall back to printing the plain file contents.
+Even with a pager set, you can still use `bat` to concatenate files :wink:.
+Whenever `bat` detects a non-interactive terminal (i.e. when you pipe into another process or into a file), `bat` will act as a drop-in replacement for `cat` and fall back to printing the plain file contents, regardless of the `--pager` option's value.

 ## How to use

@@ -94,6 +94,16 @@ bat f - g  # output 'f', then stdin, then 'g'.

 ### Integration with other tools

+#### `fzf`
+
+You can use `bat` as a previewer for [`fzf`](https://github.com/junegunn/fzf). To do this,
+use `bat`s `--color=always` option to force colorized output. You can also use `--line-range`
+option to restrict the load times for long files:
+```bash
+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'
+```
+For more information, see [`fzf`s `README`](https://github.com/junegunn/fzf#preview-window).
+
 #### `find` or `fd`

 You can use the `-exec` option of `find` to preview all search results with `bat`:
@@ -131,7 +141,18 @@ highlighting:
 git show v0.6.0:src/main.rs | bat -l rs
 ```

-Note that syntax highlighting within diffs is currently not supported. If you are looking for this, check out [`delta`](https://github.com/dandavison/delta).
+#### `git diff`
+
+You can combine `bat` with `git diff` to view lines around code changes with proper syntax
+highlighting:
+```bash
+batdiff() {
+    git diff --name-only --diff-filter=d | xargs bat --diff
+}
+```
+If you prefer to use this as a separate tool, check out `batdiff` in [`bat-extras`](https://github.com/eth-p/bat-extras).
+
+If you are looking for more support for git and diff operations, check out [`delta`](https://github.com/dandavison/delta).

 #### `xclip`

@@ -152,6 +173,7 @@ bat main.cpp | xclip
 export MANPAGER="sh -c 'col -bx | bat -l man -p'"
 man 2 select
 ```
+(replace `bat` by `batcat` if you are on Debian or Ubuntu)

 It might also be necessary to set `MANROFFOPT="-c"` if you experience
 formatting problems.
@@ -169,7 +191,7 @@ The [`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.

 ## Installation

-[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)
+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)

 ### On Ubuntu (using `apt`)
 *... and other Debian-based Linux distributions.*
@@ -185,7 +207,7 @@ If your Ubuntu/Debian installation is new enough you can simply run:
 apt install bat
 ```

-If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
+**Important**: If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
 clash with another package](https://github.com/sharkdp/bat/issues/982)). You can set up a `bat -> batcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:
 ``` bash
 mkdir -p ~/.local/bin
@@ -200,7 +222,7 @@ the most recent release of `bat`, download the latest `.deb` package from the
 [release page](https://github.com/sharkdp/bat/releases) and install it via:

 ```bash
-sudo dpkg -i bat_0.16.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.0_amd64.deb  # adapt version number and architecture
 ```

 ### On Alpine Linux
@@ -245,6 +267,13 @@ You can install `bat` via xbps-install:
 xbps-install -S bat
 ```

+### On Termux
+
+You can install `bat` via pkg:
+```bash
+pkg install bat
+```
+
 ### On FreeBSD

 You can install a precompiled [`bat` package](https://www.freshports.org/textproc/bat) with pkg:
@@ -276,14 +305,21 @@ You can install `bat` with zypper:
 zypper install bat
 ```

-### On macOS
+### Via snap package

-You can install `bat` with [Homebrew](http://braumeister.org/formula/bat):
+There is currently no recommended snap package available.
+Existing packages may be available, but are not officially supported and may contain [issues](https://github.com/sharkdp/bat/issues/1519).
+
+### On macOS (or Linux) via Homebrew
+
+You can install `bat` with [Homebrew on MacOS](https://formulae.brew.sh/formula/bat) or [Homebrew on Linux](https://formulae.brew.sh/formula-linux/bat):

 ```bash
 brew install bat
 ```

+### On macOS via MacPorts
+
 Or install `bat` with [MacPorts](https://ports.macports.org/port/bat/summary):

 ```bash
@@ -327,14 +363,14 @@ binaries are also available: look for archives with `musl` in the file name.

 ### From source

-If you want to build `bat` from source, you need Rust 1.40 or
+If you want to build `bat` from source, you need Rust 1.42 or
 higher. You can then use `cargo` to build everything:

 ```bash
 cargo install --locked bat
 ```

-Note that addition files like the man page or shell completion
+Note that additional files like the man page or shell completion
 files can not be installed in this way. They will be generated by `cargo` and should be available in the cargo target folder (under `build`).

 ## Customization
@@ -361,12 +397,11 @@ You can also use a custom theme by following the

 ### 8-bit themes

-`bat` has four themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),
+`bat` has three themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),
 even when truecolor support is available:

- `ansi-dark` looks decent on any terminal with a dark background. It uses 3-bit colors: black, red,
-  green, yellow, blue, magenta, cyan, and white.
- `ansi-light` is like `ansi-dark`, but for terminals with a light background.
+- `ansi` looks decent on any terminal. It uses 3-bit colors: black, red, green,
+  yellow, blue, magenta, cyan, and white.
 - `base16` is designed for [base16](https://github.com/chriskempson/base16) terminal themes. It uses
  4-bit colors (3-bit colors plus bright variants) in accordance with the
  [base16 styling guidelines](https://github.com/chriskempson/base16/blob/master/styling.md).
@@ -389,35 +424,45 @@ variable to make these changes permanent or use `bat`s

 ### Adding new syntaxes / language definitions

+Should you find that a particular syntax is not available within `bat`, you can follow these
+instructions to easily add new syntaxes to your current `bat` installation.
+
 `bat` uses the excellent [`syntect`](https://github.com/trishume/syntect/)
 library for syntax highlighting. `syntect` can read any
 [Sublime Text `.sublime-syntax` file](https://www.sublimetext.com/docs/3/syntax.html)
-and theme. To add new syntax definitions, do the following.
+and theme.

-Create a folder with syntax definition files:
+A good resource for finding Sublime Syntax packages is [Package Control](https://packagecontrol.io/). Once you found a
+syntax:

-```bash
-mkdir -p "$(bat --config-dir)/syntaxes"
-cd "$(bat --config-dir)/syntaxes"
+1. Create a folder with syntax definition files:

-# Put new '.sublime-syntax' language definition files
-# in this folder (or its subdirectories), for example:
-git clone https://github.com/tellnobody1/sublime-purescript-syntax
-```
+   ```bash
+   mkdir -p "$(bat --config-dir)/syntaxes"
+   cd "$(bat --config-dir)/syntaxes"

-Now use the following command to parse these files into a binary cache:
+   # Put new '.sublime-syntax' language definition files
+   # in this folder (or its subdirectories), for example:
+   git clone https://github.com/tellnobody1/sublime-purescript-syntax
+   ```

-```bash
-bat cache --build
-```
+2. Now use the following command to parse these files into a binary cache:

-Finally, use `bat --list-languages` to check if the new languages are available.
+   ```bash
+   bat cache --build
+   ```

-If you ever want to go back to the default settings, call:
+3. Finally, use `bat --list-languages` to check if the new languages are available.

-```bash
-bat cache --clear
-```
+   If you ever want to go back to the default settings, call:
+
+   ```bash
+   bat cache --clear
+   ```
+
+4. If you think that a specific syntax should be included in `bat` by default, please
+   consider opening a "syntax request" ticket after reading the policies and
+   instructions [here](doc/assets.md): [Open Syntax Request](https://github.com/sharkdp/bat/issues/new?labels=syntax-request&template=syntax_request.md).

 ### Adding new themes

@@ -437,6 +482,33 @@ bat cache --build

 Finally, use `bat --list-themes` to check if the new themes are available.

+### Adding or changing file type associations
+
+You can add new (or change existing) file name patterns using the `--map-syntax`
+command line option. The option takes an argument of the form `pattern:syntax` where
+`pattern` is a glob pattern that is matched against the file name and
+the absolute file path. The `syntax` part is the full name of a supported language
+(use `bat --list-languages` for an overview).
+
+Note: You probably want to use this option as an entry in `bat`s configuration file instead
+of passing it on the command line (see below).
+
+Example: To use "INI" syntax highlighting for all files with a `.conf` file extension, use
+```bash
+--map-syntax='*.conf:INI'
+```
+
+Example: To open all files called `.ignore` (exact match) with the "Git Ignore" syntax, use:
+```bash
+--map-syntax='.ignore:Git Ignore'
+```
+
+Example: To open all `.conf` files in subfolders of `/etc/apache2` with the "Apache Conf"
+syntax, use (this mapping is already built in):
+```bash
+--map-syntax='/etc/apache2/**/*.conf:Apache Conf'
+```
+
 ### Using a different pager

 `bat` uses the pager that is specified in the `PAGER` environment variable. If this variable is not
@@ -488,6 +560,7 @@ and the `GitHub` theme when in the _light mode_.
 alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"
 ```

+
 ## Configuration file

 `bat` can also be customized with a configuration file. The location of the file is dependent
@@ -524,9 +597,6 @@ Example configuration file:

 # Use C++ syntax for .ino files
 --map-syntax "*.ino:C++"
-
-# Use ".gitignore"-style highlighting for ".ignore" files
--map-syntax ".ignore:Git Ignore"
 ```

 ## Using `bat` on Windows
@@ -621,17 +691,28 @@ cargo build --bins
 cargo test

 # Install (release version)
-cargo install --locked
+cargo install --path . --locked

 # Build a bat binary with modified syntaxes and themes
 bash assets/create.sh
-cargo install --locked --force
+cargo install --path . --locked --force
 ```

+If you want to build an application that uses `bat`s pretty-printing
+features as a library, check out the [the API documentation](https://docs.rs/bat/).
+Note that you have to use either `regex-onig` or `regex-fancy` as a feature
+when you depend on `bat` as a library.
+
+## Contributing
+
+Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.
+
 ## Maintainers

 - [sharkdp](https://github.com/sharkdp)
 - [eth-p](https://github.com/eth-p)
+- [keith-hall](https://github.com/keith-hall)
+- [Enselic](https://github.com/Enselic)

 ## Project goals and alternatives

@@ -1,52 +0,0 @@
-## Syntax Highlighting in bat
-
-`bat` uses the [syntect](https://github.com/trishume/syntect) library to highlight source
-code. As a basis, syntect uses [Sublime Text](https://www.sublimetext.com/) syntax definitions
-in the `.sublime-syntax` format.
-
-In order to add new syntaxes to `bat`, follow these steps:
-
-1. Find a Sublime Text syntax for the given language, preferably in a separate Git repository
-   which can be included as a submodule (under `assets/syntaxes`).
-
-2. If the Sublime Text syntax is only available as a `.tmLanguage` file, open the file in
-   Sublime Text and convert it to a `.sublime-syntax` file via *Tools* -> *Developer* ->
-   *New Syntax from XXX.tmLanguage...*. Save the new file in the `assets/syntaxes` folder.
-
-3. Run the `create.sh` script. It calls `bat cache --build` to parse all available
-   `.sublime-syntax` files and serialize them to a `syntaxes.bin` file (in this folder).
-
-4. Re-compile `bat`. At compilation time, the `syntaxes.bin` file will be stored inside the
-   `bat` binary.
-
-5. If you send a pull request with your changes, please do *not* include the changed `syntaxes.bin`
-   file. A new binary cache file will be created once before every new release of `bat`.
-
-### Troubleshooting
-
-Make sure that the local cache does not interfere with the internally stored syntaxes and
-themes (`bat cache --clear`).
-
-### Manual modifications
-
-The following files have been manually modified after converting from a `.tmLanguage` file:
-
-* `Apache.sublime_syntax`=> removed `.conf` and `.CONF` file types.
-* `Dart.sublime-syntax` => removed `#regex.dart` include.
-* `INI.sublime-syntax` => added `.hgrc`, `hgrc`, and `desktop` file types.
-* `Org mode.sublime-syntax` => removed `task` file type.
-* `SML.sublime_syntax` => removed `ml` file type.
-
-### Non-submodule additions
-
-* `Assembly (x86_64)` has been manually added from https://github.com/13xforever/x86-assembly-textmate-bundle due to `git clone` recursion problems
-* `Nim.sublime-syntax` has been added manually from https://github.com/getzola/zola/blob/master/sublime_syntaxes/Nim.sublime-syntax as there was no suitable Git repository for it. The original syntax seems to originate from https://github.com/Varriount/NimLime
-* `Rego.sublime-syntax` has been added manually from https://github.com/open-policy-agent/opa/blob/master/misc/syntax/sublime/rego.sublime-syntax
-   as it is not kept in a standalone repository. The file is generated from
-   https://github.com/open-policy-agent/opa/blob/master/misc/syntax/textmate/Rego.tmLanguage
-* `SML.sublime_syntax` has been added manually from
-   https://github.com/seanjames777/SML-Language-Definitiona as it is not
-   kept in a standalone repository. The file generated is from
-   https://github.com/seanjames777/SML-Language-Definition/blob/master/sml.tmLanguage
-* `Cabal.sublime_syntax` has been added manually from
-  https://github.com/SublimeHaskell/SublimeHaskell/ - we don't want to include the whole submodule because it includes other syntaxes ("Haskell improved") as well.
@@ -3,8 +3,8 @@
 local context state state_descr line
 typeset -A opt_args

-(( $+functions[_cache_subcommand] )) ||
-_cache_subcommand() {
+(( $+functions[_{{PROJECT_EXECUTABLE}}_cache_subcommand] )) ||
+_{{PROJECT_EXECUTABLE}}_cache_subcommand() {
    local -a args
    args=(
        '(-b --build -c --clear)'{-b,--build}'[Initialize or update the syntax/theme cache]'
@@ -19,12 +19,12 @@ _cache_subcommand() {
    _arguments -S -s $args
 }

-(( $+functions[_main] )) ||
-_main() {
+(( $+functions[_{{PROJECT_EXECUTABLE}}_main] )) ||
+_{{PROJECT_EXECUTABLE}}_main() {
    local -a args
    args=(
        '(-A --show-all)'{-A,--show-all}'[Show non-printable characters (space, tab, newline, ..)]'
-        {-p,--plain}'[Show plain style (alias for `--style=plain`)]:When `-p` is used twice (`-pp`), it also disables automatic paging (alias for `--style=plain --paging=never`)'
+        '*'{-p,--plain}'[Show plain style (alias for `--style=plain`), repeat twice to disable disable automatic paging (alias for `--paging=never`)]'
        '(-l --language)'{-l+,--language=}'[Set the language for syntax highlighting]:<language>:->language'
        '(-H --highlight-line)'{-H,--highlight-line}'[Highlight lines N through M]:<N\:M>...'
        '(--file-name)'--file-name'[Specify the name to display for a file]:<name>...:_files'
@@ -51,13 +51,13 @@ _main() {

    _arguments -S -s $args

-    case "$state" in 
+    case "$state" in
        language)
            local IFS=$'\n'
            local -a languages
            languages=( $({{PROJECT_EXECUTABLE}} --list-languages | awk -F':|,' '{ for (i = 1; i <= NF; ++i) printf("%s:%s\n", $i, $1) }') )

-            _describe 'language' languages 
+            _describe 'language' languages
        ;;

        theme)
@@ -79,15 +79,15 @@ if (( ${#words} == 2 )); then
    local -a subcommands
    subcommands=('cache:Modify the syntax-definition and theme cache')
    _describe subcommand subcommands
-    _main
+    _{{PROJECT_EXECUTABLE}}_main
 else
    case $words[2] in
        cache)
-            _cache_subcommand
+            _{{PROJECT_EXECUTABLE}}_cache_subcommand
        ;;

        *)
-            _main
+            _{{PROJECT_EXECUTABLE}}_main
        ;;
    esac
 fi
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail

 ASSET_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
@@ -40,7 +40,7 @@ language names and file extensions.
 .HP
 \fB\-H\fR, \fB\-\-highlight\-line\fR <N:M>...
 .IP
-Highlight the specified line ranges with a different background color For example:
+Highlight the specified line ranges with a different background color. For example:
 .RS
 .IP "\-\-highlight\-line 40"
 highlights line 40
@@ -52,6 +52,18 @@ highlights lines 1 to 40
 highlights lines 40 to the end of the file
 .RE
 .HP
+\fB\-\-file\-name\fR <name>...
+.IP
+Specify the name to display for a file. Useful when piping data to {{PROJECT_EXECUTABLE}} from STDIN when {{PROJECT_EXECUTABLE}} does not otherwise know the filename. Note that the provided file name is also used for syntax detection.
+.HP
+\fB\-d\fR, \fB\-\-diff\fR
+.IP
+Only show lines that have been added/removed/modified with respect to the Git index. Use '\-\-diff\-context=N' to control how much context you want to see.
+.HP
+\fB\-\-diff\-context\fR <N>...
+.IP
+Include N lines of context around added/removed/modified lines when using '\-\-diff'.
+.HP
 \fB\-\-tabs\fR <T>
 .IP
 Set the tab width to T spaces. Use a width of 0 to pass tabs through directly
@@ -90,7 +102,7 @@ values: *auto*, never, always.
 \fB\-f\fR, \fB\-\-force\-colorization\fR
 .IP
 Alias for '--decorations=always --color=always'. This is useful \
-if the output of bat is piped to another program, but you want \
+if the output of {{PROJECT_EXECUTABLE}} is piped to another program, but you want \
 to keep the colorization/decorations.
 .HP
 \fB\-\-paging\fR <when>
@@ -111,6 +123,7 @@ Map a glob pattern to an existing syntax name. The glob pattern is matched on th
 path and the filename. For example, to highlight *.build files with the Python syntax,
 use -m '*.build:Python'. To highlight files named '.myignore' with the Git Ignore
 syntax, use -m '.myignore:Git Ignore'.
+Note that the right-hand side is the *name* of the syntax, not a file extension.
 .HP
 \fB\-\-theme\fR <theme>
 .IP
@@ -129,7 +142,7 @@ Configure which elements (line numbers, file headers, grid borders, Git modifica
 of components to display (e.g. 'numbers,changes,grid') or a pre\-defined style ('full').
 To set a default style, add the '\-\-style=".."' option to the configuration file or
 export the BAT_STYLE environment variable (e.g.: export BAT_STYLE=".."). Possible
-values: *auto*, full, plain, changes, header, grid, numbers, snip.
+values: *auto*, full, plain, changes, header, grid, rule, numbers, snip.
 .HP
 \fB\-r\fR, \fB\-\-line\-range\fR <N:M>...
 .IP
@@ -174,12 +187,12 @@ is dependent on your operating system. To get the default path for your system,

 \fB{{PROJECT_EXECUTABLE}} --config-file\fR

-Alternatively, you can use the BAT_CONFIG_PATH environment variable to point bat to a non-default
+Alternatively, you can use the BAT_CONFIG_PATH environment variable to point {{PROJECT_EXECUTABLE}} to a non-default
 location of the configuration file.
 .SH "ADDING CUSTOM LANGUAGES"
 {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.sublime-syntax\fR language files, and can be
-customized to add additional languages to your local installation. To do this, add the \fB.sublime-snytax\fR language
-files to `\fB$({{PROJECT_EXECUTABLE}} --config-dir)/syntaxes\fR` and run `\fBbat cache --build\fR`.
+customized to add additional languages to your local installation. To do this, add the \fB.sublime-syntax\fR language
+files to `\fB$({{PROJECT_EXECUTABLE}} --config-dir)/syntaxes\fR` and run `\fB{{PROJECT_EXECUTABLE}} cache --build\fR`.

 \fBExample:\fR

@@ -199,9 +212,9 @@ git clone https://github.com/tellnobody1/sublime-purescript-syntax
 {{PROJECT_EXECUTABLE}} cache --build
 .RE

-Once the cache is built, the new language will be visible in `\fBbat --list-languages\fR`.
+Once the cache is built, the new language will be visible in `\fB{{PROJECT_EXECUTABLE}} --list-languages\fR`.
 .br
-If you ever want to remove the custom languages, you can clear the cache with `\fBbat cache --clear\fR`. 
+If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`. 

 .SH "ADDING CUSTOM THEMES"
 Similarly to custom languages, {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.tmTheme\fR themes.
@@ -0,0 +1,18 @@
+diff --git themes/sublime-monokai-extended/Monokai\ Extended.tmTheme themes/sublime-monokai-extended/Monokai\ Extended.tmTheme
+index 9c2aa3e..180cbbf 100644
+--- themes/sublime-monokai-extended/Monokai Extended.tmTheme	
+++ themes/sublime-monokai-extended/Monokai Extended.tmTheme	
+@@ -810,11 +810,11 @@
+       <key>name</key>
+       <string>JSON String</string>
+       <key>scope</key>
+-      <string>meta.structure.dictionary.json string.quoted.double.json</string>
+      <string>meta.mapping.key.json string.quoted.double.json</string>
+       <key>settings</key>
+       <dict>
+         <key>foreground</key>
+-        <string>#cfcfc2</string>
+        <string>#fd971f</string>
+       </dict>
+     </dict>
+     <dict>
@@ -0,0 +1,15 @@
+diff --git syntaxes/01_Packages/ShellScript/Bash.sublime-syntax syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
+index e973e319..a703cef8 100644
+--- syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
+++ syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
+@@ -30,8 +30,8 @@ file_extensions:
+   - .zshenv
+   - .zshrc
+   - PKGBUILD  # https://jlk.fjfi.cvut.cz/arch/manpages/man/PKGBUILD.5
+-  - .ebuild
+-  - .eclass
+  - ebuild
+  - eclass
+ 
+ first_line_match: |
+   (?x)
@@ -25,12 +25,13 @@ contexts:
      scope: comment.line.semicolon.ini
      captures:
        1: punctuation.definition.comment.ini
-    - match: '^\s*(\[)(.*?)(\])'
+    - match: '^\s*(\[)(.*?)(\])\s*(;.*)?$\n?'
      scope: meta.tag.section.ini
      captures:
        1: punctuation.definition.section.ini
        2: entity.section.ini
        3: punctuation.definition.section.ini
+        4: comment.definition.section.ini
    - match: '^(\s*(["'']?)(.+?)(\2)\s*(=))?\s*((["'']?)(.*?)(\7))\s*(;.*)?$\n?'
      scope: meta.declaration.ini
      captures:
@@ -0,0 +1,125 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Lean
+file_extensions:
+  - lean
+scope: source.lean
+contexts:
+  main:
+    - include: comments
+    - match: '\b(?<!\.)(inductive|coinductive|structure|theorem|axiom|axioms|abbreviation|lemma|definition|def|instance|class|constant)\b\s+(\{[^}]*\})?'
+      captures:
+        1: keyword.other.definitioncommand.lean
+      push:
+        - meta_scope: meta.definitioncommand.lean
+        - match: '(?=\bwith\b|\bextends\b|[:\|\(\[\{⦃<>])'
+          pop: true
+        - include: comments
+        - include: definitionName
+        - match: ","
+    - match: \b(Prop|Type|Sort)\b
+      scope: storage.type.lean
+    - match: '\battribute\b\s*\[[^\]]*\]'
+      scope: storage.modifier.lean
+    - match: '@\[[^\]]*\]'
+      scope: storage.modifier.lean
+    - match: \b(?<!\.)(private|meta|mutual|protected|noncomputable)\b
+      scope: keyword.control.definition.modifier.lean
+    - match: \b(sorry)\b
+      scope: invalid.illegal.lean
+    - match: '#print\s+(def|definition|inductive|instance|structure|axiom|axioms|class)\b'
+      scope: keyword.other.command.lean
+    - match: '#(print|eval|reduce|check|help|exit|find|where)\b'
+      scope: keyword.other.command.lean
+    - match: \b(?<!\.)(import|export|prelude|theory|definition|def|abbreviation|instance|renaming|hiding|exposing|parameter|parameters|begin|constant|constants|lemma|variable|variables|theorem|example|open|axiom|inductive|coinductive|with|structure|universe|universes|alias|precedence|reserve|postfix|prefix|infix|infixl|infixr|notation|end|using|namespace|section|local|set_option|extends|include|omit|class|classes|instances|raw|run_cmd|restate_axiom)(?!\.)\b
+      scope: keyword.other.lean
+    - match: \b(?<!\.)(calc|have|this|match|do|suffices|show|by|in|at|let|forall|fun|exists|assume|from|obtain|haveI|λ)(?!\.)\b
+      scope: keyword.other.lean
+    - match: «
+      push:
+        - meta_content_scope: entity.name.lean
+        - match: »
+          pop: true
+    - match: \b(?<!\.)(if|then|else)\b
+      scope: keyword.control.lean
+    - match: '"'
+      captures:
+        0: punctuation.definition.string.begin.lean
+      push:
+        - meta_scope: string.quoted.double.lean
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.lean
+          pop: true
+        - match: '\\[\\"nt'']'
+          scope: constant.character.escape.lean
+        - match: '\\x[0-9A-Fa-f][0-9A-Fa-f]'
+          scope: constant.character.escape.lean
+        - match: '\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'
+          scope: constant.character.escape.lean
+    - match: '''[^\\'']'''
+      scope: string.quoted.single.lean
+    - match: '''(\\(x..|u....|.))'''
+      scope: string.quoted.single.lean
+      captures:
+        1: constant.character.escape.lean
+    - match: '`+[^\[(]\S+'
+      scope: entity.name.lean
+    - match: '\b([0-9]+|0([xX][0-9a-fA-F]+))\b'
+      scope: constant.numeric.lean
+  blockComment:
+    - match: /-
+      push:
+        - meta_scope: comment.block.lean
+        - match: "-/"
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
+  comments:
+    - include: dashComment
+    - include: docComment
+    - include: stringBlock
+    - include: modDocComment
+    - include: blockComment
+  dashComment:
+    - match: (--)
+      captures:
+        0: punctuation.definition.comment.lean
+      push:
+        - meta_scope: comment.line.double-dash.lean
+        - match: $
+          pop: true
+        - include: scope:source.lean.markdown
+  definitionName:
+    - match: '\b[^:«»\(\)\{\}[:space:]=→λ∀?][^:«»\(\)\{\}[:space:]]*'
+      scope: entity.name.function.lean
+    - match: «
+      push:
+        - meta_content_scope: entity.name.function.lean
+        - match: »
+          pop: true
+  docComment:
+    - match: /--
+      push:
+        - meta_scope: comment.block.documentation.lean
+        - match: "-/"
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
+  modDocComment:
+    - match: /-!
+      push:
+        - meta_scope: comment.block.documentation.lean
+        - match: "-/"
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
+  stringBlock:
+    - match: /-"
+      push:
+        - meta_scope: comment.block.string.lean
+        - match: '"-/'
+          pop: true
+        - include: scope:source.lean.markdown
+        - include: blockComment
@@ -7,47 +7,165 @@ file_extensions:
 scope: source.man

 variables:
-  section_heading: '^\S.*$'
+  section_heading: '^(?!#)\S.*$'
+  command_line_option: '(--?[A-Za-z0-9][_A-Za-z0-9-]*)'

 contexts:
+  prototype:
+    # ignore syntax test lines
+    - match: '^#'
+      push:
+        - meta_scope: comment.syntax-test.man
+        - match: $\n?
+          pop: true
  main:
    - match: ^
      push: first_line

  first_line:
-    - match: '([A-Z0-9_\-]+)(\()([^)]+)(\))'
+    - match: '([A-Z0-9_\-]+)(\()([^)]+)(\))\s*'
      captures:
-        1: meta.preprocessor
-        2: keyword.operator
-        3: string.quoted.other
-        4: keyword.operator
-
-    - match: '$'
-      push: body
-
-  body:
-    - match: '^(SYNOPSIS|SYNTAX|SINTASSI|SKŁADNIA|СИНТАКСИС|書式)'
-      push: Packages/C/C.sublime-syntax
-      scope: markup.heading
-      with_prototype:
-        - match: '(?={{section_heading}})'
+        1: meta.preprocessor.man
+        2: keyword.operator.man
+        3: string.quoted.other.man
+        4: keyword.operator.man
+      push:
+        - match: (?:[\w'-]+|\s(?!\s))
+          scope: markup.heading.title.man
+        - match: \s\s
+          pop: true
+        - match: '(?=\S|$)'
          pop: true

-    - match: '^\S.*$'
-      scope: markup.heading
+    - match: '$'
+      set: body

-    - match: '\b([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
+  body:
+    # English, ..., ..., ..., Russian, ...
+
+    - match: '^(?:SYNOPSIS|SYNTAX|SINTASSI|SKŁADNIA|СИНТАКСИС|書式)'
+      scope: markup.heading.synopsis.man
+      embed: synopsis
+      escape: '(?={{section_heading}})'
+
+    - match: '^(?:USAGE)'
+      scope: markup.heading.synopsis.man
+      embed: synopsis
+      escape: '(?={{section_heading}})'
+
+    - match: '{{section_heading}}'
+      scope: markup.heading.other.man
+      embed: options # some man pages put command line options under the description heading
+      escape: '(?={{section_heading}})'
+
+  function-call:
+    - match: '\b([A-Za-z0-9_\-]+\.)?([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
      captures:
-        1: entity.name.function
-        2: keyword.operator
-        3: constant.numeric
-        4: keyword.operator
+        1: entity.name.function.man
+        2: entity.name.function.man
+        3: keyword.operator.man
+        4: constant.numeric.man
+        5: keyword.operator.man

+  env-var:
+    - match: '(\$)(?!\d)(\w+)\b'
+      captures:
+        1: punctuation.definition.variable.man
+        2: constant.other.man
+
+  options:
    # command-line options like --option=value, --some-flag, or -x
-    - match: '(?:[^a-zA-Z0-9_-]|^|\s)(--?[A-Za-z0-9][A-Za-z0-9-]*)(?:(=)?("?)([A-Za-z0-9]+)("?))?'
+    - match: '^[ ]{7}(?=-)'
+      push: expect-command-line-option
+    - match: '(?:[^a-zA-Z0-9_-]|^|\s){{command_line_option}}'
      captures:
-        1: entity.name
-        2: keyword.operator
-        3: punctuation.definition.string.begin
-        4: variable.parameter
-        3: punctuation.definition.string.end
+        1: entity.name.command-line-option
+      push:
+        - match: '='
+          scope: keyword.operator.man
+          set:
+            - match: '[^],.() ]+'
+              scope: variable.parameter.man
+              pop: true
+            - match: $
+              pop: true
+        - match: ''
+          pop: true
+    - include: function-call
+    - include: c-code
+    - include: env-var
+
+  expect-command-line-option:
+    - match: '[A-Za-z0-9-]+'
+      scope: entity.name.command-line-option.man
+    - match: '(\[)(=)'
+      captures:
+        1: punctuation.section.brackets.begin.man
+        2: keyword.operator.man
+      push: [command-line-option-or-pipe, expect-parameter]
+    - match: '\['
+      push:
+        - meta_scope: entity.name.command-line-option.man
+        - match: '\]'
+          pop: true
+    - match: '='
+      scope: keyword.operator.man
+      push: expect-parameter
+    - match: (?=.*\.)
+      pop: true
+    - match: '\s'
+      push: expect-parameter
+    - match: '(,)\s*'
+      captures:
+        1: punctuation.separator.man
+    - match: $|(?=\])
+      pop: true
+
+  expect-parameter:
+    - match: '[A-Za-z0-9-]+'
+      scope: variable.parameter.man
+    - match: (?=\s+\|)
+      pop: true
+    - match: \|
+      scope: keyword.operator.logical.man
+    - match: '\['
+      scope: punctuation.section.brackets.begin.man
+      push:
+        - match: '\]'
+          scope: punctuation.section.brackets.end.man
+          pop: true
+        - include: expect-parameter
+    - match: '$|(?=[],]|{{command_line_option}})'
+      pop: true
+
+  c-code:
+    - match: '^(?=\s+(?:#include\b|#define\b|/\*|struct\s+(\w+\s*)?\{))'
+      embed: scope:source.c
+      #embed_scope: source.c.embedded.man
+      #escape: ^(?!#|\1|\s*(?:$|/\*|#include\b|#define\b))
+      escape: ^(?=\s*(?:\(.*\.\)\s*$|[A-Z](?![A-Z])))
+
+  synopsis:
+    - include: c-code
+    - match: \[
+      scope: punctuation.section.brackets.begin.man
+      push: command-line-option-or-pipe
+    - include: options
+
+  command-line-option-or-pipe:
+    - match: (\|)\s*
+      captures:
+        1: keyword.operator.logical.man
+    #- match: (?={{command_line_option}})
+    - match: \w+-\w+
+    - match: (?=-)
+      push:
+        - match: (?=\s*\|)
+          pop: true
+        - include: expect-command-line-option
+    - match: \]
+      scope: punctuation.section.brackets.end.man
+      pop: true
+    - match: \[
+      scope: punctuation.section.brackets.begin.man
+      push: command-line-option-or-pipe
@@ -0,0 +1,52 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Ninja
+file_extensions:
+  - ninja
+scope: source.ninja
+contexts:
+  main:
+    - match: (#).*$\n?
+      comment: Comment line.
+      scope: comment.line.number-sign.ninja
+      captures:
+        1: punctuation.definition.comment.ninja
+    - match: ^(rule)\b
+      comment: Rule keyword and keywords for a rule.
+      captures:
+        1: keyword.other.ninja
+      push:
+        - match: ^(?=\S)
+          pop: true
+        - include: main
+        - match: \b(?:command|deps|depfile|description|generator|pool|restat|rspfile|rspfile_content)\b
+          scope: keyword.other.ninja
+    - match: ^(pool)\b
+      comment: Pool keyword and keywords for a pool.
+      captures:
+        1: keyword.other.ninja
+      push:
+        - match: ^(?=\S)
+          pop: true
+        - include: main
+        - match: \b(?:depth)\b
+          scope: keyword.other.ninja
+    - match: ^(?:build|rule|default|include|subninja)\b
+      comment: Other Keywords.
+      scope: keyword.other.ninja
+    - match: '(?:[=:]|\|{1,2})(?=\s)'
+      comment: Operators for variable assignment (=), rule definition (:), implicit (|) and order only (||) dependencies.
+      scope: keyword.operator.ninja
+    - match: \$$
+      comment: Line wrap.
+      scope: keyword.operator.ninja
+    - match: \$\$
+      comment: Dollar literal.
+      scope: keyword.operator.ninja
+    - match: '\$[[:alnum:]_-]+'
+      comment: Simple variables, e.g. $var.
+      scope: variable.other.ninja
+    - match: '\${[[:alnum:]_.-]+}'
+      comment: "Variables, e.g. ${some.var.name}."
+      scope: variable.other.ninja
@@ -1,9 +1,10 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
-name: Robot Framework syntax highlighting.
+name: Robot Framework
 file_extensions:
  - robot
+  - resource
 scope: source.robot
 contexts:
  main:
@@ -3084,6 +3084,13 @@ contexts:
          captures:
            0: meta.brace.square.ts
          pop: true
+        - match: \.\.\.
+          scope: keyword.operator.rest.ts
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([_$[:alpha:]][_$[:alnum:]]*)\s*(\?)?\s*(:)'
+          captures:
+            1: entity.name.label.ts
+            2: keyword.operator.optional.ts
+            3: punctuation.separator.label.ts
        - include: type
        - include: punctuation-comma
  typeof-operator:
@@ -1,91 +0,0 @@
-%YAML 1.2
---
-# http://www.sublimetext.com/docs/3/syntax.html
-name: VimL
-file_extensions:
-  - vim
-  - .vimrc
-scope: source.viml
-contexts:
-  main:
-    - include: comment
-    - include: string_quoted_double
-    - include: string_quoted_single
-    - include: string_regex
-    - include: inline_comment
-    - include: number_int
-    - include: number_hex
-    - include: keyword
-    - include: support_function
-    - include: support_variable
-    - include: support_type
-    - include: function_params
-    - include: function_definition
-    - include: function_call
-    - include: function
-    - include: variable
-    - include: expr
-  comment:
-    - match: ^\s*".*$
-      scope: comment.line.quotes.viml
-      captures:
-        1: punctuation.definition.comment.vim
-  expr:
-    - match: (\|\||&&|==(\?|#)?|(!|>|<)=(#|\?)?|(=|!)~(#|\?)?|(>|<)(#|\?)is|isnot|\.|\*|\\|%)
-      scope: storage.function.viml
-  function:
-    - match: \b(fu(n|nction)?|end(f|fu|fun|function)?)\b
-      scope: storage.function.viml
-  function_call:
-    - match: '(([sgbwtl]|)?:?[0-9a-zA-Z_#]+)(?=\()'
-      scope: support.function.any-method
-  function_definition:
-    - match: '^\s*(function)\s*!?\s+(?=(s:)?[0-9a-zA-Z_#]+\s*\()'
-      captures:
-        1: storage.function.viml
-      push:
-        - meta_scope: meta.function.viml
-        - match: (\()
-          captures:
-            1: punctuation.definition.parameters.begin.viml
-          pop: true
-        - match: "(s:)?[0-9a-zA-Z_#]+"
-          scope: entity.name.function.viml
-  function_params:
-    - match: '-\w+='
-      scope: support.type.viml
-  inline_comment:
-    - match: '(?!\$)(")(?!\{).*$\n?'
-      scope: comment.line.quotes.viml
-      captures:
-        1: punctuation.definition.comment.vim
-  keyword:
-    - match: \b(if|while|for|try|return|throw|end(if|for|while|try)?|au(g|group)|else(if|)?|do|in|catch|finally|:)\b
-      scope: keyword.control.viml
-  number_hex:
-    - match: "0x[0-9a-f]+"
-      scope: constant.numeric.hex
-  number_int:
-    - match: '-?\d+'
-      scope: constant.numeric.integer
-  string_quoted_double:
-    - match: '"(\\\\|\\"|\n[^\S\n]*\\|[^\n"])*"'
-      scope: string.quoted.double.viml
-  string_quoted_single:
-    - match: '''(''''|\n[^\S\n]*\\|[^\n''])*'''
-      scope: string.quoted.single.viml
-  string_regex:
-    - match: '/(\\\\|\\/|\n[^\S\n]*\\|[^\n/])*/'
-      scope: string.regexp.viml
-  support_function:
-    - match: \b(set(local|global)?|let|command|filetype|colorscheme|\w*map|\w*a(b|brev)?|syn|exe(c|cute)?|ec(ho|)?|au(tocmd|)?)\b
-      scope: support.function.viml
-  support_type:
-    - match: <.*?>
-      scope: support.type.viml
-  support_variable:
-    - match: '\b(am(enu|)?|(hl|inc)?search|[Bb]uf([Nn]ew[Ff]ile|[Rr]ead)?|[Ff]ile[Tt]ype)\b'
-      scope: support.variable.viml
-  variable:
-    - match: '([sSgGbBwWlLaAvV]:|@|$|&(?!&))\w*'
-      scope: variable.other.viml
@@ -0,0 +1,182 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: gnuplot
+file_extensions:
+  - gp
+  - gpl
+  - gnuplot
+  - gnu
+  - plot
+  - plt
+scope: source.gnuplot
+contexts:
+  main:
+    - include: number
+    - include: string_single
+    - include: string_double
+    - match: '\b(for)\b\s*(\[)'
+      comment: |
+        gnuplot iteration statement.
+                    There are two forms:
+                        numeric [n = 1:2{:inc}]
+                        string based [str in "x y z"]
+                        but both can also iterate over lists etc, so this is kept loose.
+      captures:
+        1: keyword.other.iteration.gnuplot
+        2: punctuation.definition.range.begin.gnuplot
+      push:
+        - meta_scope: meta.structure.iteration.gnuplot
+        - match: '\]'
+          captures:
+            0: punctuation.definition.range.end.gnuplot
+          pop: true
+        - include: number
+        - include: operator
+        - include: string_double
+        - include: string_single
+        - match: ":"
+          scope: punctuation.separator.range.gnuplot
+        - match: '\b([a-zA-Z]\w*)\b\s*(=|in)'
+          scope: variable-assignment.range.gnuplot
+        - match: '(?i:[^\s(pi|e)\]])'
+          scope: invalid.illegal.expected-range-separator.gnuplot
+    - match: '\['
+      comment: "gnuplot range statement [a:b]. Lots of things are legal, still more make no sense!"
+      captures:
+        0: punctuation.definition.range.begin.gnuplot
+      push:
+        - meta_scope: meta.structure.range.gnuplot
+        - match: '\]'
+          captures:
+            0: punctuation.definition.range.end.gnuplot
+          pop: true
+        - include: number
+        - include: operator
+        - match: ":"
+          scope: punctuation.separator.range.gnuplot
+        - match: '(?i:[^\s(pi|e)\]])'
+          scope: invalid.illegal.expected-range-separator.gnuplot
+    - match: \\.
+      scope: constant.character.escape.gnuplot
+    - match: '(?<!\$)(#)(?!\{).*$\n?'
+      scope: comment.line.number-sign.gnuplot
+      captures:
+        1: punctuation.definition.comment.gnuplot
+    - match: for
+      comment: introduce in gnuplot 4.3.
+      scope: keyword.other.iteration.gnuplot
+    - match: \b(angles|arrow|autoscale|bars|border|boxwidth|clabel|clip|cntrparam|colorbox|contour|decimalsign|dgrid3d|dummy|encoding|fit|format|grid|hidden3d|historysize|isosamples|key|label|locale|logscale|macros|bmargin|lmargin|rmargin|tmargin|mapping|mouse|multiplot|offsets|origin|output|palette|parametric|pm3d|pointsize|polar|print|rrange|trange|urange|vrange|samples|size|style|surface|tics|ticscale|ticslevel|timestamp|timefmt|title|view|xyplane|x2data|xdata|y2data|ydata|z2data|zdata|x2label|xlabel|y2label|ylabel|z2label|zlabel|x2range|xrange|y2range|yrange|z2range|zrange|mx2tics|mxtics|my2tics|mytics|mz2tics|mztics|nomx2tics|nomxtics|nomy2tics|nomytics|nomz2tics|nomztics|nox2tics|noxtics|noy2tics|noytics|noz2tics|noztics|x2tics|xtics|y2tics|ytics|z2tics|ztics|x2dtics|x2mtics|xdtics|xmtics|y2dtics|y2mtics|ydtics|ymtics|z2dtics|z2mtics|zdtics|zmtics|x2zeroaxis|xzeroaxis|y2zeroaxis|yzeroaxis|z2zeroaxis|zeroaxis|zzeroaxis|zero|)\b
+      scope: keyword.other.setting.gnuplot
+    - match: \b(cd|call|clear|exit|plot|splot|help|load|pause|quit|fit|replot|if|FIT_LIMIT|FIT_MAXITER|FIT_START_LAMBDA|FIT_LAMBDA_FACTOR|FIT_LOG|FIT_SCRIPT|print|pwd|reread|reset|save|show|test|!|functions|var)\b
+      comment: missuse of scopes alert! Just for pretty colours
+      scope: keyword.other.command.gnuplot
+    - match: \b(abs|acos|acosh|arg|asin|asinh|atan|atan2|atanh|besj0|besj1|besy0|besy1|ceil|cos|cosh|erf|erfc|exp|floor|gamma|ibeta|igamma|imag|int|inverf|invnorm|lambertw|lgamma|log|log10|norm|rand|real|sgn|sin|sinh|sqrt|tan|tanh)\b
+      scope: support.function.gnuplot
+    - match: \b(gprintf|sprintf|strlen|strstrt|substr|system|word|words)\b
+      scope: support.function.string.gnuplot
+    - match: \b(on|off|default|inside|outside|lmargin|rmargin|tmargin|bmargin|at|left|right|center|top|bottom|center|vertical|horizontal|Left|Right|noreverse|noinvert|samplen|spacing|width|height|noautotitle|columnheader|title|noenhanced|nobox|linestyle|ls|linetype|lt|linewidth|lw)\b
+      scope: constant.other.type.gnuplot
+    - match: \b(aed512|aed767|aifm|aqua|bitgraph|cgm|corel|dumb|dxf|eepic|emf|emtex|epslatex|epson_180dpi|epson_60dpi|epson_lx800|fig|gif|gpic|hp2623A|hp2648|hp500c|hpdj|hpgl|hpljii|hppj|imagen|jpeg|kc_tek40xx|km_tek40xx|latex|mf|mif|mp|nec_cp6|okidata|pbm|pcl5|pdf|png|postscript|pslatex|pstex|pstricks|qms|regis|selanar|starc|svg|tandy_60dpi|tek40xx|tek410x|texdraw|tgif|tkcanvas|tpic|unknown|vttek)\b
+      scope: constant.other.terminal.gnuplot
+    - match: \b(u(sing)?|t(it(le)?)?|notit(le)?|w(i(th)?)?|steps|fs(teps)?|notitle|l(i(nes)?)?|linespoints|via)\b
+      scope: keyword.modifier.gnuplot
+    - match: |-
+        (?x:
+          \b # Start with a word boundary
+          (?=\b[\w$]*(\(|.*=))  # Look-ahead for a bracket or equals
+          (?![^(]*\)) # negative look ahead for a closing bracket without an opening one. This stops a from matching in f(a)
+          (         # Group variable name
+            [A-Za-z]      # A letter
+            [\w$]*      # Any word chars or $
+          )         # That is it for the name.
+        )
+      comment: user defined function / variable
+      scope: variable.other.gnuplot
+    - match: \b(if)\b
+      scope: keyword.control.gnuplot
+    - match: \b(show)\b
+      captures:
+        0: keyword.other.command.gnuplot
+      push:
+        - meta_scope: keyword.line.show.gnuplot
+        - meta_content_scope: keyword.line.show.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+    - match: \b(set)\b\s*\b(terminal|term)\b
+      captures:
+        1: keyword.other.command.gnuplot
+        2: keyword.other.setting.gnuplot
+      push:
+        - meta_scope: keyword.line.set.terminal.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+    - match: \b(set)\b\s*\b(key)\b
+      captures:
+        1: keyword.other.command.gnuplot
+        2: keyword.other.setting.gnuplot
+      push:
+        - meta_scope: keyword.line.set.key.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+    - match: \b(set|unset)\b\s*(?!\b(terminal|key|for)\b)
+      captures:
+        1: keyword.other.command.gnuplot
+        2: keyword.other.setting.gnuplot
+      push:
+        - meta_scope: keyword.line.set.gnuplot
+        - meta_content_scope: keyword.line.set.gnuplot
+        - match: (?!\#)($\n?)
+          pop: true
+        - include: main
+  number:
+    - match: |-
+        (?x:         # turn on extended mode
+            -?         # an optional minus
+            (?:
+              0        # a zero
+              |        # ...or...
+              [1-9]    # a 1-9 character
+              \d*      # followed by zero or more digits
+            )
+            (?:
+              \.       # a period
+              \d+      # followed by one or more digits
+              (?:
+                [eE]   # an e character
+                [+-]?  # followed by an option +/-
+                \d+    # followed by one or more digits
+              )?       # make exponent optional
+            )?         # make decimal portion optional
+        )
+      comment: borrowed from textmate book
+      scope: constant.numeric.gnuplot
+  operator:
+    - match: \s*(==|~=|>|>=|<|<=|&|&&|:|\||\|\||\+|-|\*|\.\*|/|\./|\\|\.\\|\^|\.\^)\s*
+      comment: Operator symbols
+      scope: keyword.operator.symbols.matlab
+  string_double:
+    - match: '"'
+      captures:
+        0: punctuation.definition.string.begin.gnuplot
+      push:
+        - meta_scope: string.quoted.double.gnuplot
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.gnuplot
+          pop: true
+        - match: '\\[\$`"\\\n]'
+          scope: constant.character.escape.gnuplot
+  string_single:
+    - match: "'"
+      captures:
+        0: punctuation.definition.string.begin.gnuplot
+      push:
+        - meta_scope: string.quoted.single.gnuplot
+        - match: "'"
+          captures:
+            0: punctuation.definition.string.end.gnuplot
+          pop: true
@@ -0,0 +1,162 @@
+# SYNTAX TEST "Manpage.sublime-syntax"
+SOMETHING(8)                System Manager's Manual               SOMETHING(8)
+# ^^^^^ meta.preprocessor
+#                           ^^^^^^^^^^^^^^^^^^^^^^^ markup.heading.title
+#                                                                   ^^^^^^^ meta.preprocessor
+
+NAME
+#^^^ markup.heading.other
+       example - do something useful
+
+SYNOPSIS
+       example  [options]  [--home  DIR]  [--shell  SHELL]  [--no-create-home]
+#                          ^ punctuation.section.brackets.begin
+#                           ^^^^^^ entity.name.command-line-option
+#                                   ^^^ variable.parameter
+#                                      ^ punctuation.section.brackets.end
+#                                         ^ punctuation.section.brackets.begin
+#                                          ^^^^^^^ entity.name.command-line-option
+#                                                   ^^^^^ variable.parameter
+#                                                        ^ punctuation.section.brackets.end
+#                                                           ^ punctuation.section.brackets.begin
+#                                                            ^^^^^^^^^^^^^^^^ entity.name.command-line-option
+#                                                                            ^ punctuation.section.brackets.end
+                  [-u | --set-upstream] [-o <string> | --push-option=<string>]
+#                 ^ punctuation.section.brackets.begin
+#                  ^^ entity.name.command-line-option
+#                     ^ keyword.operator.logical
+#                       ^^^^^^^^^^^^^^ entity.name.command-line-option
+#                                     ^ punctuation.section.brackets.end
+#                                                      ^^^^^^^^^^^^^ entity.name.command-line-option
+                  [--force-with-lease[=<refname>[:<expect>]]]
+#                 ^ punctuation.section.brackets.begin
+#                  ^^^^^^^^^^^^^^^^^^ entity.name.command-line-option
+#                                    ^ punctuation.section.brackets.begin
+#                                     ^ keyword.operator
+#                                       ^^^^^^^ variable.parameter
+#                                               ^ punctuation.section.brackets.begin
+#                                                  ^^^^^^ variable.parameter
+#                                                         ^^^ punctuation.section.brackets.end
+
+       example --system [options]
+#              ^^^^^^^^ entity.name
+
+   COMMON OPTIONS
+       [--quiet] [--debug] [--help|-h]  [--version]  [--conf FILE]
+
+        /* According to POSIX.1-2001, POSIX.1-2008 */
+#       ^^ source.c comment.block punctuation.definition.comment
+       #include <sys/select.h>
+#      ^^^^^^^^ source.c meta.preprocessor.include keyword.control.import.include
+           struct timeval {
+#          ^^^^^^ source.c storage.type
+            
+               time_t         tv_sec;     /* seconds */
+               suseconds_t    tv_usec;    /* microseconds */
+           };
+
+
+
+DESCRIPTION
+       example does something useful in  relation  to the command line options
+       and configuration information in /etc/example.conf.
+
+OPTIONS
+       --conf FILE
+#      ^^^^^^ entity.name.command-line-option
+#^^^^^^ - variable - entity - markup
+#             ^^^^ variable.parameter
+              Use FILE instead of /etc/example.conf.
+#             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - variable - entity
+
+       --disabled-login
+              Do  not  run passwd to set the password.  The user won't be able
+              to use her account until the password is set.
+
+       --disabled-password
+              Like --disabled-login, but logins are still possible (for  exam-
+#                  ^^^^^^^^^^^^^^^^ entity.name
+#^^^^^^^^^^^^^^^^^^ - entity - variable - markup
+#                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - entity - variable - markup
+              ple using SSH RSA keys) but not using password authentication.
+
+       --help Display brief instructions.
+#      ^^^^^^ entity.name.command-line-option
+#             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - variable.parameter
+
+       --home DIR
+#      ^^^^^^ entity.name.command-line-option
+#             ^^^ variable.parameter
+#                ^ - variable - entity - markup
+              Use DIR as the user's home directory, rather  than  the  default
+              specified  by the configuration file.  If the directory does not
+              exist, it is created and skeleton files are copied.
+
+       --[no-]signed, --signed=(true|false|if-asked)
+#      ^^^^^^^^^^^^^ entity.name.command-line-option
+#                   ^ punctuation.separator
+#                     ^^^^^^^^ entity.name.command-line-option
+#                             ^ keyword.operator
+#                              ^ - variable
+#                               ^^^^ variable.parameter
+#                                   ^ keyword.operator.logical
+#                                    ^^^^^ variable.parameter
+#                                         ^ keyword.operator.logical
+#                                          ^^^^^^^^ variable.parameter
+#                                                  ^ - variable
+       --no-recurse-submodules, --recurse-submodules=check|on-demand|only|no
+#      ^^^^^^^^^^^^^^^^^^^^^^^ entity.name.command-line-option
+#                             ^ punctuation.separator
+#                               ^^^^^^^^^^^^^^^^^^^^ entity.name.command-line-option
+#                                                   ^ keyword.operator
+#                                                    ^^^^^ variable.parameter
+#                                                         ^ keyword.operator.logical
+#                                                          ^^^^^^^^^ variable.parameter
+#                                                                   ^ keyword.operator.logical
+#                                                                    ^^^^ variable.parameter
+#                                                                        ^ keyword.operator.logical
+#                                                                         ^^ variable.parameter
+           May be used to make sure all submodule commits used by the
+
+       -c, -C NUM, --context[=NUM]
+#      ^^ entity.name.command-line-option
+#        ^ punctuation.separator
+#          ^^ entity.name.command-line-option
+#             ^^^ variable.parameter
+#                ^ punctuation.separator
+#                  ^^^^^^^^^ entity.name.command-line-option
+#                           ^^^^^^^ - entity.name
+#                            ^ keyword.operator
+#                             ^^^ variable.parameter
+#                                ^^ - variable
+              output NUM (default 3) lines of copied context
+
+EXAMPLE
+       #include <stdio.h>
+#      ^^^^^^^^ source.c meta.preprocessor.include keyword.control.import.include
+
+    (This is not C code.)
+#   ^^^^^^^^^^^^^^^^^^^^^^ - source.c
+
+           struct timeval {
+               time_t      tv_sec;         /* seconds */
+               suseconds_t tv_usec;        /* microseconds */
+           };
+#           ^ source.c punctuation.terminator
+
+       The corresponding argument for pselect() has the following type:
+#^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - source.c
+           #define POLLIN_SET  (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN |
+                                EPOLLHUP | EPOLLERR)
+#                                                  ^ source.c meta.preprocessor.macro meta.group punctuation.section.group.end
+
+ENVIRONMENT
+       $SYSTEMD_LOG_LEVEL
+#      ^ punctuation.definition.variable
+#       ^^^^^^^^^^^^^^^^^ constant.other
+           systemd reads the log level from this environment variable. This
+           can be overridden with --log-level=.
+
+SEE ALSO
+       The systemd Homepage[11], systemd-system.conf(5), locale.conf(5)
+#                                ^^^^^^^^^^^^^^^^^^^ entity.name.function
@@ -1,504 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-    <dict>
-        <!--
-        The colors in this theme are encoded as #RRGGBBAA where RR is an ANSI
-        palette number from 00 to 0f, and AA is the special value 00 to indicate
-        that this encoding is being used.
-        -->
-        <key>author</key>
-        <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>
-        <key>name</key>
-        <string>ANSI Light</string>
-        <key>colorSpaceName</key>
-        <string>sRGB</string>
-        <key>settings</key>
-        <array>
-            <dict>
-                <key>settings</key>
-                <dict>
-                    <key>background</key>
-                    <string>#07000000</string>
-                    <key>caret</key>
-                    <string>#00000000</string>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                    <key>invisibles</key>
-                    <string>#00000000</string>
-                    <key>lineHighlight</key>
-                    <string>#00000000</string>
-                    <key>selection</key>
-                    <string>#00000000</string>
-                    <key>gutter</key>
-                    <string>#07000000</string>
-                    <key>gutterForeground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Text</string>
-                <key>scope</key>
-                <string>variable.parameter.function</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Comments</string>
-                <key>scope</key>
-                <string>comment, punctuation.definition.comment</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Punctuation</string>
-                <key>scope</key>
-                <string>punctuation.definition.string, punctuation.definition.variable, punctuation.definition.string, punctuation.definition.parameters, punctuation.definition.string, punctuation.definition.array</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Delimiters</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Operators</string>
-                <key>scope</key>
-                <string>keyword.operator</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Keywords</string>
-                <key>scope</key>
-                <string>keyword</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Variables</string>
-                <key>scope</key>
-                <string>variable</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Functions</string>
-                <key>scope</key>
-                <string>entity.name.function, meta.require, support.function.any-method</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Labels</string>
-                <key>scope</key>
-                <string>entity.name.label</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Classes</string>
-                <key>scope</key>
-                <string>support.class, entity.name.class, entity.name.type.class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Classes</string>
-                <key>scope</key>
-                <string>meta.class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Methods</string>
-                <key>scope</key>
-                <string>keyword.other.special-method</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Storage</string>
-                <key>scope</key>
-                <string>storage</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Support</string>
-                <key>scope</key>
-                <string>support.function</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Strings, Inherited Class</string>
-                <key>scope</key>
-                <string>string, constant.other.symbol, entity.other.inherited-class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Integers</string>
-                <key>scope</key>
-                <string>constant.numeric</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Floats</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Boolean</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Constants</string>
-                <key>scope</key>
-                <string>constant</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Tags</string>
-                <key>scope</key>
-                <string>entity.name.tag</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#01000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Attributes</string>
-                <key>scope</key>
-                <string>entity.other.attribute-name</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Attribute IDs</string>
-                <key>scope</key>
-                <string>entity.other.attribute-name.id, punctuation.definition.entity</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Selector</string>
-                <key>scope</key>
-                <string>meta.selector</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Values</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Headings</string>
-                <key>scope</key>
-                <string>markup.heading punctuation.definition.heading, entity.name.section</string>
-                <key>settings</key>
-                <dict>
-                    <key>fontStyle</key>
-                    <string></string>
-                    <key>foreground</key>
-                    <string>#04000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Units</string>
-                <key>scope</key>
-                <string>keyword.other.unit</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Bold</string>
-                <key>scope</key>
-                <string>markup.bold, punctuation.definition.bold</string>
-                <key>settings</key>
-                <dict>
-                    <key>fontStyle</key>
-                    <string>bold</string>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Italic</string>
-                <key>scope</key>
-                <string>markup.italic, punctuation.definition.italic</string>
-                <key>settings</key>
-                <dict>
-                    <key>fontStyle</key>
-                    <string>italic</string>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Code</string>
-                <key>scope</key>
-                <string>markup.raw.inline</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Link Text</string>
-                <key>scope</key>
-                <string>string.other.link, punctuation.definition.string.end.markdown, punctuation.definition.string.begin.markdown</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#01000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Link Url</string>
-                <key>scope</key>
-                <string>meta.link</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Quotes</string>
-                <key>scope</key>
-                <string>markup.quote</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#03000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Inserted</string>
-                <key>scope</key>
-                <string>markup.inserted</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#02000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Deleted</string>
-                <key>scope</key>
-                <string>markup.deleted</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#01000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Changed</string>
-                <key>scope</key>
-                <string>markup.changed</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Colors</string>
-                <key>scope</key>
-                <string>constant.other.color</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Regular Expressions</string>
-                <key>scope</key>
-                <string>string.regexp</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Escape Characters</string>
-                <key>scope</key>
-                <string>constant.character.escape</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#06000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Embedded</string>
-                <key>scope</key>
-                <string>punctuation.section.embedded, variable.interpolation</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#05000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Illegal</string>
-                <key>scope</key>
-                <string>invalid.illegal</string>
-                <key>settings</key>
-                <dict>
-                    <key>background</key>
-                    <string>#01000000</string>
-                    <key>foreground</key>
-                    <string>#00000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Broken</string>
-                <key>scope</key>
-                <string>invalid.broken</string>
-                <key>settings</key>
-                <dict>
-                    <key>background</key>
-                    <string>#03000000</string>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-        </array>
-        <key>uuid</key>
-        <string>uuid</string>
-    </dict>
-</plist>
@@ -3,14 +3,14 @@
 <plist version="1.0">
    <dict>
        <!--
-        The colors in this theme are encoded as #RRGGBBAA where RR is an ANSI
-        palette number from 00 to 0f, and AA is the special value 00 to indicate
-        that this encoding is being used.
+        The colors in this theme are encoded as #RRGGBBAA where:
+        * If AA is 00, then RR is an ANSI palette number from 00 to 07.
+        * If AA is 01, the terminal's default fg/bg color is used.
        -->
        <key>author</key>
        <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>
        <key>name</key>
-        <string>ANSI Dark</string>
+        <string>ANSI</string>
        <key>colorSpaceName</key>
        <string>sRGB</string>
        <key>settings</key>
@@ -19,32 +19,17 @@
                <key>settings</key>
                <dict>
                    <key>background</key>
-                    <string>#00000000</string>
-                    <key>caret</key>
-                    <string>#07000000</string>
+                    <string>#00000001</string>
                    <key>foreground</key>
-                    <string>#07000000</string>
-                    <key>invisibles</key>
-                    <string>#07000000</string>
-                    <key>lineHighlight</key>
-                    <string>#07000000</string>
-                    <key>selection</key>
-                    <string>#07000000</string>
+                    <string>#00000001</string>
+                    <!--
+                    Explicitly set the gutter color since bat falls back to a
+                    hardcoded DEFAULT_GUTTER_COLOR otherwise.
+                    -->
                    <key>gutter</key>
-                    <string>#00000000</string>
+                    <string>#00000001</string>
                    <key>gutterForeground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Text</string>
-                <key>scope</key>
-                <string>variable.parameter.function</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
+                    <string>#00000001</string>
                </dict>
            </dict>
            <dict>
@@ -58,39 +43,6 @@
                    <string>#02000000</string>
                </dict>
            </dict>
-            <dict>
-                <key>name</key>
-                <string>Punctuation</string>
-                <key>scope</key>
-                <string>punctuation.definition.string, punctuation.definition.variable, punctuation.definition.string, punctuation.definition.parameters, punctuation.definition.string, punctuation.definition.array</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Delimiters</string>
-                <key>scope</key>
-                <string>none</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
-            <dict>
-                <key>name</key>
-                <string>Operators</string>
-                <key>scope</key>
-                <string>keyword.operator</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
            <dict>
                <key>name</key>
                <string>Keywords</string>
@@ -102,17 +54,6 @@
                    <string>#05000000</string>
                </dict>
            </dict>
-            <dict>
-                <key>name</key>
-                <string>Variables</string>
-                <key>scope</key>
-                <string>variable</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
            <dict>
                <key>name</key>
                <string>Functions</string>
@@ -146,17 +87,6 @@
                    <string>#03000000</string>
                </dict>
            </dict>
-            <dict>
-                <key>name</key>
-                <string>Classes</string>
-                <key>scope</key>
-                <string>meta.class</string>
-                <key>settings</key>
-                <dict>
-                    <key>foreground</key>
-                    <string>#07000000</string>
-                </dict>
-            </dict>
            <dict>
                <key>name</key>
                <string>Methods</string>
@@ -480,8 +410,6 @@
                <dict>
                    <key>background</key>
                    <string>#01000000</string>
-                    <key>foreground</key>
-                    <string>#07000000</string>
                </dict>
            </dict>
            <dict>
@@ -493,8 +421,6 @@
                <dict>
                    <key>background</key>
                    <string>#03000000</string>
-                    <key>foreground</key>
-                    <string>#00000000</string>
                </dict>
            </dict>
        </array>
@@ -58,7 +58,8 @@ _bat_:run() {
 	_out "$BAT" --version
 	_out env | grep '^BAT_\|^PAGER='

-	local cache_dir="$($BAT --cache-dir)"
+	local cache_dir
+	cache_dir="$($BAT --cache-dir)"
 	if [[ -f "${cache_dir}/syntaxes.bin" ]]; then
 		_print_command "$BAT" "--list-languages"
 		echo "Found custom syntax set."
@@ -79,8 +80,8 @@ _bat_config_:run() {
 _bat_wrapper_:run() {
 	_bat_wrapper_:detect_wrapper() {
 		local bat="$1"
-		if file "$(which "${bat}")" | grep "text executable" &> /dev/null; then
-			_out_fence cat "$(which "${bat}")"
+		if file "$(command -v "${bat}")" | grep "text executable" &> /dev/null; then
+			_out_fence cat "$(command -v "${bat}")"
 			return
 		fi

@@ -104,7 +105,8 @@ _bat_wrapper_function_:run() {
 				fi ;;

 			*bash* | *zsh*)
-				local type="$("$SHELL" --login -i -c "type ${command}" 2>&1)"
+				local type
+				type="$("$SHELL" --login -i -c "type ${command}" 2>&1)"
 				if grep 'function' <<< "$type" &> /dev/null; then
 					_out_fence "$SHELL" --login -i -c "declare -f ${command}"
 					return
@@ -39,13 +39,13 @@

 ### 自動ページング

-出力が1つの画面に対して大きすぎる場合、`bat` は自身の出力を `less` にパイプで繋げることが可能です。
+出力が1つの画面に対して大きすぎる場合、`bat` は自身の出力をページャー(例えば `less`) にパイプで繋げます。

 ### ファイルの連結

 あなたはさらにファイルを連結させるために使うことも可能です:wink:。
-`bat` は非対話型のターミナルを検出すると、
-いつでも `cat` の完全互換として振る舞い、
+`bat` は非対話型のターミナルを検出すると(すなわち他のプロセスにパイプしたりファイル出力していると)、
+`bat` は `cat` の完全互換として振る舞い、
 プレーンなファイルを表示します。

 ## 使い方
@@ -62,7 +62,9 @@
 > bat src/*.rs
 ```

-標準入力から自動的に構文を決定させたい場合
+標準入力から自動的に構文を決定させたい場合(ハイライトされるのは、
+たいていは `#!/bin/sh` のようなシバンを利用して、
+ファイルの一行目から構文を決定できる場合のみです)

 ```bash
 > curl -s https://sh.rustup.rs | bat
@@ -152,7 +154,7 @@ man 2 select
 ```

 フォーマットの問題が発生した場合は
-`MANROFFOPT = "-c"` を設定する必要もあります。
+`MANROFFOPT="-c"` を設定する必要もあります。

 これを新しいコマンドにバンドルしたい場合は [`batman`](https://github.com/eth-p/bat-extras/blob/master/doc/batman.md) も使用できます。

@@ -189,7 +191,7 @@ ln -s /usr/bin/batcat ~/.local/bin/bat
 batの最新リリースを実行する場合、または Ubuntu/Debian の古いバージョンを使用している場合は、[release page](https://github.com/sharkdp/bat/releases) から最新の `.deb` パッケージをダウンロードし、
 次の方法でインストールします:
 ```bash
-sudo dpkg -i bat_0.16.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.0_amd64.deb  # adapt version number and architecture
 ```

 ### On Alpine Linux
@@ -170,7 +170,7 @@ apt install bat
 만약 최근 릴리즈된 bat을 사용을 원하거나 buntu/Debian 예전 버전을 사용하는 경우, [릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 다음과 같이 `.deb` 패키지를 받아 설치 할 수도 있습니다:

 ```bash
-sudo dpkg -i bat_0.16.0_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.0_amd64.deb  # adapt version number and architecture
 ```

 ### On Alpine Linux
@@ -185,7 +185,7 @@ ln -s /usr/bin/batcat ~/.local/bin/bat
 [release page](https://github.com/sharkdp/bat/releases) и установить так:

 ```bash
-sudo dpkg -i bat_0.16.0_amd64.deb  # измените архитектуру и версию
+sudo dpkg -i bat_0.18.0_amd64.deb  # измените архитектуру и версию
 ```

 ### Alpine Linux
@@ -341,7 +341,7 @@ ansible-galaxy install aeimer.install_bat

 ### Из исходников

-Если вы желаете установить `bat` из исходников, вам понадобится Rust 1.40 или выше. После этого используйте `cargo`, чтобы все скомпилировать:
+Если вы желаете установить `bat` из исходников, вам понадобится Rust 1.42 или выше. После этого используйте `cargo`, чтобы все скомпилировать:

 ```bash
 cargo install --locked bat
@@ -9,7 +9,7 @@ if you are not looking for a program like `bat`, this comparison might not be fo
 | Drop-in `cat` replacement                    | :heavy_check_mark: [*](https://github.com/sharkdp/bat/issues/134)   | :x:                              | :x:                                                                 | (:heavy_check_mark:)                     | :x:                                                            | :x: [*](https://github.com/rstacruz/hicat/issues/6) | :x:                                                 | :x:                                                 |
 | Git integration                              | :heavy_check_mark:                                                  | :x:                              | :x:                                                                 | :x:                                      | :x:                                                            | :x:                                                 | :x:                                                 | :x:                                                 |
 | Automatic paging                             | :heavy_check_mark:                                                  | :x:                              | :x:                                                                 | :x:                                      | :x:                                                            | :heavy_check_mark:                                  | :x:                                                 | :x:                                                 |
-| Languages (circa)                            | 110                                                                 | 300                              | 200                                                                 | 7                                        | 80                                                             | 130                                                 | 30                                                  | 130                                                 |
+| Languages (circa)                            | 150                                                                 | 300                              | 200                                                                 | 7                                        | 80                                                             | 130                                                 | 30                                                  | 130                                                 |
 | Extensible (languages, themes)               | :heavy_check_mark:                                                  | (:heavy_check_mark:)             | (:heavy_check_mark:)                                                | :x:                                      | (:heavy_check_mark:)                                           | :x:                                                 | :x:                                                 | :x:                                                 |
 | Advanced highlighting (e.g. nested syntaxes) | :heavy_check_mark:                                                  | :heavy_check_mark:               | (:heavy_check_mark:) ?                                              | :x:                                      | :heavy_check_mark:                                             | :heavy_check_mark:                                  | :heavy_check_mark:                                  | :heavy_check_mark:                                  |
 | Execution time [ms] (`jquery-3.3.1.js`)      | 624                                                                 | 789                              | 400                                                                 | 80                                       | 300                                                            | 316                                                 | 157                                                 | 695                                                 |
@@ -0,0 +1,97 @@
+## Adding new builtin languages for syntax highlighting
+
+Should you find that a particular syntax is not available within `bat` and think it should be included in `bat` by default, you can follow the instructions outlined below.
+
+`bat` uses the excellent [syntect](https://github.com/trishume/syntect) library to highlight source
+code. As a basis, syntect uses [Sublime Text](https://www.sublimetext.com/) syntax definitions
+in the `.sublime-syntax` format.
+
+**Important:** Before proceeding, verify that the syntax you wish to add meets the [criteria for inclusion](#Criteria-for-inclusion-of-new-syntaxes).
+
+1. Find a Sublime Text syntax for the given language, preferably in a separate Git repository
+   which can be included as a submodule (under `assets/syntaxes`).
+
+2. If the Sublime Text syntax is only available as a `.tmLanguage` file, open the file in
+   Sublime Text and convert it to a `.sublime-syntax` file via *Tools* -> *Developer* ->
+   *New Syntax from XXX.tmLanguage...*. Save the new file in the `assets/syntaxes` folder.
+
+3. Run the `assets/create.sh` script. It calls `bat cache --build` to parse all available
+   `.sublime-syntax` files and serialize them to a `syntaxes.bin` file.
+
+4. Re-compile `bat`. At compilation time, the `syntaxes.bin` file will be stored inside the
+   `bat` binary.
+
+5. Use `bat --list-languages` to check if the new languages are available.
+
+6. Add a syntax test for the new language. See [below](#Syntax-tests) for details.
+
+7. If you send a pull request with your changes, please do *not* include the changed `syntaxes.bin`
+   file. A new binary cache file will be created once before every new release of `bat`.
+
+### Syntax tests
+
+`bat` has a set of syntax highlighting regression tests in `tests/syntax-tests`. The main idea is
+make sure that we do not run into issues we had in the past where either (1) syntax highlighting
+for some language is suddenly not working anymore or (2) `bat` suddenly crashes for some input (due
+to `regex` incompatibilities between `syntect` and Sublime Text).
+
+In order to add a new test file, please follow these steps (let's take "Ruby" as an example):
+
+1. Make sure that you are running the **latest version of `bat`** and that `bat` is available on
+   the path. If you are creating a syntax test for a new builtin syntax (see above), make sure that
+   your version of `bat` already has the new syntax builtin.
+2. Find an example Ruby source file or write one yourself. If possible, the file should aim to be
+   "comprehensive" (i.e. include a lot of the possible syntax), but this is not strictly necessary.
+   A simple file is better than none at all. Also, the files shouldn't be gigantic.
+3. Save the file in `tests/syntax-tests/source/Ruby` (adapt for your language). The file name could
+   be `test.rb` (adapt extension) but can also be adapted if that is necessary in order for `bat` to
+   highlight it correctly (e.g. `Makefile`).
+4. If you have copied the file from somewhere else, please make sure that the file *may* be copied
+   under the respective license and that the license is compatible with `bat`s license. If it
+   requires attribution, please add a `LICENSE.md` in the same folder with a text like this:
+    ```
+    The `test.rb` file has been added from [enter source here] under the following license:
+
+    [add license text here]
+    ```
+5. Go to `tests/syntax-tests` and run the `update.sh` Bash script. A new file should be generated
+   in the `highlighted` folder (e.g. `highlighted/Ruby/test.rb`).
+6. Use `cat` or `bat --language=txt` to display the content of this file and make sure that the
+   syntax highlighting looks correct.
+7. `git add` the new files in the `source` folder as well as the autogenerated files in the
+   `highlighted` folder.
+
+### Troubleshooting
+
+Make sure that the local cache does not interfere with the internally stored syntaxes and
+themes (`bat cache --clear`).
+
+## Criteria for inclusion of new syntaxes
+
+* More than 10,000 downloads on packagecontrol.io/
+
+### Manual modifications
+
+The following files have been manually modified after converting from a `.tmLanguage` file:
+
+* `Apache.sublime_syntax`=> removed `.conf` and `.CONF` file types.
+* `Dart.sublime-syntax` => removed `#regex.dart` include.
+* `INI.sublime-syntax` => added `.hgrc`, `hgrc`, and `desktop` file types and support for comments after section headers
+* `Org mode.sublime-syntax` => removed `task` file type.
+* `SML.sublime_syntax` => removed `ml` file type.
+* `Robot.sublime_syntax` => changed name to "Robot Framework", added `.resource` extension
+
+### Non-submodule additions
+
+* `Assembly (x86_64)` has been manually added from https://github.com/13xforever/x86-assembly-textmate-bundle due to `git clone` recursion problems
+* `Nim.sublime-syntax` has been added manually from https://github.com/getzola/zola/blob/master/sublime_syntaxes/Nim.sublime-syntax as there was no suitable Git repository for it. The original syntax seems to originate from https://github.com/Varriount/NimLime
+* `Rego.sublime-syntax` has been added manually from https://github.com/open-policy-agent/opa/blob/master/misc/syntax/sublime/rego.sublime-syntax
+   as it is not kept in a standalone repository. The file is generated from
+   https://github.com/open-policy-agent/opa/blob/master/misc/syntax/textmate/Rego.tmLanguage
+* `SML.sublime_syntax` has been added manually from
+   https://github.com/seanjames777/SML-Language-Definitiona as it is not
+   kept in a standalone repository. The file generated is from
+   https://github.com/seanjames777/SML-Language-Definition/blob/master/sml.tmLanguage
+* `Cabal.sublime_syntax` has been added manually from
+  https://github.com/SublimeHaskell/SublimeHaskell/ - we don't want to include the whole submodule because it includes other syntaxes ("Haskell improved") as well.
+* `Lean.sublime-syntax` has been added manually from https://github.com/leanprover/vscode-lean/blob/master/syntaxes/lean.json via conversion.
@@ -45,7 +45,7 @@
   showguides="true"
   inkscape:guide-bbox="true" />
    <rect
-   style="opacity:1;fill:#f2f2f2;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.14294769px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none"
+   style="opacity:0.5;fill:#e5e5e5;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.14294769px;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;marker:none"
   id="rect1929"
   width="1000"
   height="286.64285"
@@ -11,6 +11,7 @@ use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};
 use path_abs::PathAbs;

 use crate::assets_metadata::AssetsMetadata;
+use crate::bat_warning;
 use crate::error::*;
 use crate::input::{InputReader, OpenedInput, OpenedInputKind};
 use crate::syntax_mapping::{MappingTarget, SyntaxMapping};
@@ -37,9 +38,16 @@ impl HighlightingAssets {
        };

        let theme_dir = source_dir.join("themes");
-
-        let res = theme_set.add_from_folder(&theme_dir);
-        if res.is_err() {
+        if theme_dir.exists() {
+            let res = theme_set.add_from_folder(&theme_dir);
+            if let Err(err) = res {
+                println!(
+                    "Failed to load one or more themes from '{}' (reason: '{}')",
+                    theme_dir.to_string_lossy(),
+                    err,
+                );
+            }
+        } else {
            println!(
                "No themes were found in '{}', using the default set",
                theme_dir.to_string_lossy()
@@ -189,13 +197,12 @@ impl HighlightingAssets {
        match self.theme_set.themes.get(theme) {
            Some(theme) => theme,
            None => {
+                if theme == "ansi-light" || theme == "ansi-dark" {
+                    bat_warning!("Theme '{}' is deprecated, using 'ansi' instead.", theme);
+                    return self.get_theme("ansi");
+                }
                if theme != "" {
-                    use ansi_term::Colour::Yellow;
-                    eprintln!(
-                        "{}: Unknown theme '{}', using default.",
-                        Yellow.paint("[bat warning]"),
-                        theme
-                    );
+                    bat_warning!("Unknown theme '{}', using default.", theme)
                }
                &self.theme_set.themes[self.fallback_theme.unwrap_or_else(|| Self::default_theme())]
            }
@@ -290,7 +297,7 @@ mod tests {

    use std::fs::File;
    use std::io::Write;
-    use tempdir::TempDir;
+    use tempfile::TempDir;

    use crate::input::Input;

@@ -305,8 +312,7 @@ mod tests {
            SyntaxDetectionTest {
                assets: HighlightingAssets::from_binary(),
                syntax_mapping: SyntaxMapping::builtin(),
-                temp_dir: TempDir::new("bat_syntax_detection_tests")
-                    .expect("creation of temporary directory"),
+                temp_dir: TempDir::new().expect("creation of temporary directory"),
            }
        }

@@ -323,7 +329,7 @@ mod tests {

            let input = Input::ordinary_file(file_path.as_os_str());
            let dummy_stdin: &[u8] = &[];
-            let mut opened_input = input.open(dummy_stdin).unwrap();
+            let mut opened_input = input.open(dummy_stdin, None).unwrap();

            self.assets
                .get_syntax(None, &mut opened_input, &self.syntax_mapping)
@@ -337,7 +343,7 @@ mod tests {
            let input = Input::from_reader(Box::new(BufReader::new(first_line.as_bytes())))
                .with_name(Some(file_path.as_os_str()));
            let dummy_stdin: &[u8] = &[];
-            let mut opened_input = input.open(dummy_stdin).unwrap();
+            let mut opened_input = input.open(dummy_stdin, None).unwrap();

            self.assets
                .get_syntax(None, &mut opened_input, &self.syntax_mapping)
@@ -361,7 +367,7 @@ mod tests {

        fn syntax_for_stdin_with_content(&self, file_name: &str, content: &[u8]) -> String {
            let input = Input::stdin().with_name(Some(OsStr::new(file_name)));
-            let mut opened_input = input.open(content).unwrap();
+            let mut opened_input = input.open(content, None).unwrap();

            self.assets
                .get_syntax(None, &mut opened_input, &self.syntax_mapping)
@@ -517,7 +523,7 @@ mod tests {

        let input = Input::ordinary_file(file_path_symlink.as_os_str());
        let dummy_stdin: &[u8] = &[];
-        let mut opened_input = input.open(dummy_stdin).unwrap();
+        let mut opened_input = input.open(dummy_stdin, None).unwrap();

        assert_eq!(
            test.assets
@@ -16,6 +16,7 @@ use console::Term;
 use crate::input::{new_file_input, new_stdin_input};
 use bat::{
    assets::HighlightingAssets,
+    bat_warning,
    config::{Config, VisibleLines},
    error::*,
    input::Input,
@@ -82,10 +83,9 @@ impl App {
            Some("always") => PagingMode::Always,
            Some("never") => PagingMode::Never,
            Some("auto") | None => {
-                if self.matches.occurrences_of("plain") > 1 {
-                    // If we have -pp as an option when in auto mode, the pager should be disabled.
-                    PagingMode::Never
-                } else if self.matches.is_present("no-paging") {
+                // If we have -pp as an option when in auto mode, the pager should be disabled.
+                let extra_plain = self.matches.occurrences_of("plain") > 1;
+                if extra_plain || self.matches.is_present("no-paging") {
                    PagingMode::Never
                } else if inputs.iter().any(Input::is_stdin) {
                    // If we are reading from stdin, only enable paging if we write to an
@@ -150,10 +150,10 @@ impl App {
            wrapping_mode: if self.interactive_output || maybe_term_width.is_some() {
                match self.matches.value_of("wrap") {
                    Some("character") => WrappingMode::Character,
-                    Some("never") => WrappingMode::NoWrapping,
+                    Some("never") => WrappingMode::NoWrapping(true),
                    Some("auto") | None => {
                        if style_components.plain() {
-                            WrappingMode::NoWrapping
+                            WrappingMode::NoWrapping(false)
                        } else {
                            WrappingMode::Character
                        }
@@ -163,15 +163,14 @@ impl App {
            } else {
                // We don't have the tty width when piping to another program.
                // There's no point in wrapping when this is the case.
-                WrappingMode::NoWrapping
+                WrappingMode::NoWrapping(false)
            },
            colored_output: self.matches.is_present("force-colorization")
                || match self.matches.value_of("color") {
                    Some("always") => true,
                    Some("never") => false,
-                    Some("auto") | _ => {
-                        env::var_os("NO_COLOR").is_none() && self.interactive_output
-                    }
+                    Some("auto") => env::var_os("NO_COLOR").is_none() && self.interactive_output,
+                    _ => unreachable!("other values for --color are not allowed"),
                },
            paging_mode,
            term_width: maybe_term_width.unwrap_or(Term::stdout().size().1 as usize),
@@ -226,17 +225,14 @@ impl App {
            style_components,
            syntax_mapping,
            pager: self.matches.value_of("pager"),
-            use_italic_text: match self.matches.value_of("italic-text") {
-                Some("always") => true,
-                _ => false,
-            },
+            use_italic_text: self.matches.value_of("italic-text") == Some("always"),
            highlighted_lines: self
                .matches
                .values_of("highlight-line")
                .map(|ws| ws.map(LineRange::from).collect())
                .transpose()?
                .map(LineRanges::from)
-                .map(|lr| HighlightedLineRanges(lr))
+                .map(HighlightedLineRanges)
                .unwrap_or_default(),
        })
    }
@@ -288,8 +284,8 @@ impl App {

    fn style_components(&self) -> Result<StyleComponents> {
        let matches = &self.matches;
-        Ok(StyleComponents(
-            if matches.value_of("decorations") == Some("never") {
+        let mut styled_components =
+            StyleComponents(if matches.value_of("decorations") == Some("never") {
                HashSet::new()
            } else if matches.is_present("number") {
                [StyleComponent::LineNumbers].iter().cloned().collect()
@@ -323,7 +319,13 @@ impl App {
                        acc.extend(components.iter().cloned());
                        acc
                    })
-            },
-        ))
+            });
+
+        // If `grid` is set, remove `rule` as it is a subset of `grid`, and print a warning.
+        if styled_components.grid() && styled_components.0.remove(&StyleComponent::Rule) {
+            bat_warning!("Style 'rule' is a subset of style 'grid', 'rule' will not be visible.");
+        }
+
+        Ok(styled_components)
    }
 }
@@ -24,6 +24,10 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
            "A cat(1) clone with wings.\n\n\
             Use '--help' instead of '-h' to see a more detailed version of the help text.",
        )
+        .after_help(
+            "Note: `bat -h` prints a short and concise overview while `bat --help` gives all \
+                 details.",
+        )
        .long_about("A cat(1) clone with syntax highlighting and Git integration.")
        .arg(
            Arg::with_name("FILE")
@@ -324,7 +328,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                    "Map a glob pattern to an existing syntax name. The glob pattern is matched \
                     on the full path and the filename. For example, to highlight *.build files \
                     with the Python syntax, use -m '*.build:Python'. To highlight files named \
-                     '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'.",
+                     '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'. Note \
+                     that the right-hand side is the *name* of the syntax, not a file extension.",
                )
                .takes_value(true),
        )
@@ -363,7 +368,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                .validator(|val| {
                    let mut invalid_vals = val.split(',').filter(|style| {
                        !&[
-                            "auto", "full", "plain", "header", "grid", "numbers", "snip",
+                            "auto", "full", "plain", "header", "grid", "rule", "numbers", "snip",
                            #[cfg(feature = "git")]
                                "changes",
                        ]
@@ -378,7 +383,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                })
                .help(
                    "Comma-separated list of style elements to display \
-                     (*auto*, full, plain, changes, header, grid, numbers, snip).",
+                     (*auto*, full, plain, changes, header, grid, rule, numbers, snip).",
                )
                .long_help(
                    "Configure which elements (line numbers, file headers, grid \
@@ -396,6 +401,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                     * header: show filenames before the content.\n  \
                     * grid: vertical/horizontal lines to separate side bar\n          \
                       and the header from the content.\n  \
+                     * rule: horizontal lines to delimit files.\n  \
                     * numbers: show line numbers in the side bar.\n  \
                     * snip: draw separation lines between distinct line ranges.",
                ),
@@ -472,6 +478,13 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {
                .hidden(true)
                .help("Show bat's cache directory."),
        )
+        .arg(
+            Arg::with_name("diagnostic")
+                .long("diagnostic")
+                .alias("diagnostics")
+                .hidden_short_help(true)
+                .help("Show diagnostic information for bug reports.")
+        )
        .help_message("Print this help message.")
        .version_message("Show version information.");

@@ -10,13 +10,12 @@ pub fn config_file() -> PathBuf {
    env::var("BAT_CONFIG_PATH")
        .ok()
        .map(PathBuf::from)
-        .filter(|config_path| config_path.is_file())
        .unwrap_or_else(|| PROJECT_DIRS.config_dir().join("config"))
 }

 pub fn generate_config_file() -> bat::error::Result<()> {
    let config_file = config_file();
-    if config_file.exists() {
+    if config_file.is_file() {
        println!(
            "A config file already exists at: {}",
            config_file.to_string_lossy()
@@ -44,8 +43,7 @@ pub fn generate_config_file() -> bat::error::Result<()> {
        }
    }

-    let default_config =
-        r#"# This is `bat`s configuration file. Each line either contains a comment or
+    let default_config = r#"# This is `bat`s configuration file. Each line either contains a comment or
 # a command-line option that you want to pass to `bat` by default. You can
 # run `bat --help` to get a list of all possible configuration options.

@@ -72,7 +70,14 @@ pub fn generate_config_file() -> bat::error::Result<()> {
 #--map-syntax ".ignore:Git Ignore"
 "#;

-    fs::write(&config_file, default_config)?;
+    fs::write(&config_file, default_config).map_err(|e| {
+        format!(
+            "Failed to create config file at '{}': {}",
+            config_file.to_string_lossy(),
+            e
+        )
+    })?;
+
    println!(
        "Success! Config file written to {}",
        config_file.to_string_lossy()
@@ -86,7 +91,7 @@ pub fn get_args_from_config_file() -> Result<Vec<OsString>, shell_words::ParseEr
        .ok()
        .map(|content| get_args_from_str(&content))
        .transpose()?
-        .unwrap_or_else(|| vec![]))
+        .unwrap_or_else(Vec::new))
 }

 pub fn get_args_from_env_var() -> Option<Result<Vec<OsString>, shell_words::ParseError>> {
@@ -19,10 +19,10 @@ impl BatProjectDirs {
        let config_dir_op = env::var_os("XDG_CONFIG_HOME")
            .map(PathBuf::from)
            .filter(|p| p.is_absolute())
-            .or_else(|| dirs::home_dir().map(|d| d.join(".config")));
+            .or_else(|| dirs_next::home_dir().map(|d| d.join(".config")));

        #[cfg(not(target_os = "macos"))]
-        let config_dir_op = dirs::config_dir();
+        let config_dir_op = dirs_next::config_dir();

        let config_dir = config_dir_op.map(|d| d.join("bat"))?;

@@ -43,10 +43,10 @@ impl BatProjectDirs {
        let cache_dir_op = env::var_os("XDG_CACHE_HOME")
            .map(PathBuf::from)
            .filter(|p| p.is_absolute())
-            .or_else(|| dirs::home_dir().map(|d| d.join(".cache")));
+            .or_else(|| dirs_next::home_dir().map(|d| d.join(".cache")));

        #[cfg(not(target_os = "macos"))]
-        let cache_dir_op = dirs::cache_dir();
+        let cache_dir_op = dirs_next::cache_dir();

        cache_dir_op.map(|d| d.join("bat"))
    }
@@ -2,7 +2,7 @@ use bat::input::Input;
 use std::ffi::OsStr;

 pub fn new_file_input<'a>(file: &'a OsStr, name: Option<&'a OsStr>) -> Input<'a> {
-    named(Input::ordinary_file(file), name.or_else(|| Some(file)))
+    named(Input::ordinary_file(file), name.or(Some(file)))
 }

 pub fn new_stdin_input(name: Option<&OsStr>) -> Input {
@@ -35,7 +35,7 @@ use bat::{
    error::*,
    input::Input,
    style::{StyleComponent, StyleComponents},
-    MappingTarget,
+    MappingTarget, PagingMode,
 };

 const THEME_PREVIEW_DATA: &[u8] = include_bytes!("../../../assets/theme_preview.rs");
@@ -78,7 +78,9 @@ fn get_syntax_mapping_to_paths<'a>(
    map
 }

-pub fn list_languages(config: &Config) -> Result<()> {
+pub fn get_languages(config: &Config) -> Result<String> {
+    let mut result: String = String::new();
+
    let assets = assets_from_cache_or_binary()?;
    let mut languages = assets
        .syntaxes()
@@ -119,12 +121,9 @@ pub fn list_languages(config: &Config) -> Result<()> {
        }
    }

-    let stdout = io::stdout();
-    let mut stdout = stdout.lock();
-
    if config.loop_through {
        for lang in languages {
-            writeln!(stdout, "{}:{}", lang.name, lang.file_extensions.join(","))?;
+            result += &format!("{}:{}\n", lang.name, lang.file_extensions.join(","));
        }
    } else {
        let longest = languages
@@ -145,7 +144,7 @@ pub fn list_languages(config: &Config) -> Result<()> {
        };

        for lang in languages {
-            write!(stdout, "{:width$}{}", lang.name, separator, width = longest)?;
+            result += &format!("{:width$}{}", lang.name, separator, width = longest);

            // Number of characters on this line so far, wrap before `desired_width`
            let mut num_chars = 0;
@@ -156,20 +155,20 @@ pub fn list_languages(config: &Config) -> Result<()> {
                let new_chars = word.len() + comma_separator.len();
                if num_chars + new_chars >= desired_width {
                    num_chars = 0;
-                    write!(stdout, "\n{:width$}{}", "", separator, width = longest)?;
+                    result += &format!("\n{:width$}{}", "", separator, width = longest);
                }

                num_chars += new_chars;
-                write!(stdout, "{}", style.paint(&word[..]))?;
+                result += &format!("{}", style.paint(&word[..]));
                if extension.peek().is_some() {
-                    write!(stdout, "{}", comma_separator)?;
+                    result += comma_separator;
                }
            }
-            writeln!(stdout)?;
+            result += "\n";
        }
    }

-    Ok(())
+    Ok(result)
 }

 fn theme_preview_file<'a>() -> Input<'a> {
@@ -200,6 +199,14 @@ pub fn list_themes(cfg: &Config) -> Result<()> {
                .ok();
            writeln!(stdout)?;
        }
+        writeln!(
+            stdout,
+            "Further themes can be installed to '{}', \
+            and are added to the cache with `bat cache --build`. \
+            For more information, see:\n\n  \
+            https://github.com/sharkdp/bat#adding-new-themes",
+            PROJECT_DIRS.config_dir().join("themes").to_string_lossy()
+        )?;
    } else {
        for theme in assets.themes() {
            writeln!(stdout, "{}", theme)?;
@@ -220,6 +227,39 @@ fn run_controller(inputs: Vec<Input>, config: &Config) -> Result<bool> {
 fn run() -> Result<bool> {
    let app = App::new()?;

+    if app.matches.is_present("diagnostic") {
+        use bugreport::{bugreport, collector::*, format::Markdown};
+        let pager = bat::config::get_pager_executable(app.matches.value_of("pager"))
+            .unwrap_or_else(|| "less".to_owned()); // FIXME: Avoid non-canonical path to "less".
+
+        bugreport!()
+            .info(SoftwareVersion::default())
+            .info(OperatingSystem::default())
+            .info(CommandLine::default())
+            .info(EnvironmentVariables::list(&[
+                "SHELL",
+                "PAGER",
+                "BAT_PAGER",
+                "BAT_CACHE_PATH",
+                "BAT_CONFIG_PATH",
+                "BAT_OPTS",
+                "BAT_STYLE",
+                "BAT_TABS",
+                "BAT_THEME",
+                "XDG_CONFIG_HOME",
+                "XDG_CACHE_HOME",
+                "COLORTERM",
+                "NO_COLOR",
+                "MANPAGER",
+            ]))
+            .info(FileContent::new("Config file", config_file()))
+            .info(CompileTimeInformation::default())
+            .info(CommandOutput::new("Less version", pager, &["--version"]))
+            .print::<Markdown>();
+
+        return Ok(true);
+    }
+
    match app.matches.subcommand() {
        ("cache", Some(cache_matches)) => {
            // If there is a file named 'cache' in the current working directory,
@@ -240,8 +280,14 @@ fn run() -> Result<bool> {
            let config = app.config(&inputs)?;

            if app.matches.is_present("list-languages") {
-                list_languages(&config)?;
-                Ok(true)
+                let languages: String = get_languages(&config)?;
+                let inputs: Vec<Input> = vec![Input::from_reader(Box::new(languages.as_bytes()))];
+                let plain_config = Config {
+                    style_components: StyleComponents::new(StyleComponent::Plain.components(false)),
+                    paging_mode: PagingMode::QuitIfOneScreen,
+                    ..Default::default()
+                };
+                run_controller(inputs, &plain_config)
            } else if app.matches.is_present("list-themes") {
                list_themes(&config)?;
                Ok(true)
@@ -84,6 +84,15 @@ pub struct Config<'a> {
    pub highlighted_lines: HighlightedLineRanges,
 }

+#[cfg(all(feature = "application", feature = "paging"))]
+pub fn get_pager_executable(config_pager: Option<&str>) -> Option<String> {
+    if let Ok(Some(pager)) = crate::pager::get_pager(config_pager) {
+        Some(pager.bin)
+    } else {
+        None
+    }
+}
+
 #[test]
 fn default_config_should_include_all_lines() {
    use crate::line_range::RangeCheckResult;
@@ -14,6 +14,8 @@ use crate::output::OutputType;
 use crate::paging::PagingMode;
 use crate::printer::{InteractivePrinter, Printer, SimplePrinter};

+use clircle::Clircle;
+
 pub struct Controller<'a> {
    config: &'a Config<'a>,
    assets: &'a HighlightingAssets,
@@ -54,7 +56,10 @@ impl<'b> Controller<'b> {
                    paging_mode = PagingMode::Never;
                }
            }
-            output_type = OutputType::from_mode(paging_mode, self.config.pager)?;
+
+            let wrapping_mode = self.config.wrapping_mode;
+
+            output_type = OutputType::from_mode(paging_mode, wrapping_mode, self.config.pager)?;
        }

        #[cfg(not(feature = "paging"))]
@@ -63,6 +68,12 @@ impl<'b> Controller<'b> {
        }

        let attached_to_pager = output_type.is_pager();
+        let stdout_identifier = if cfg!(windows) || attached_to_pager {
+            None
+        } else {
+            clircle::Identifier::stdout()
+        };
+
        let writer = output_type.handle()?;
        let mut no_errors: bool = true;

@@ -76,7 +87,7 @@ impl<'b> Controller<'b> {
        };

        for (index, input) in inputs.into_iter().enumerate() {
-            match input.open(io::stdin().lock()) {
+            match input.open(io::stdin().lock(), stdout_identifier.as_ref()) {
                Err(error) => {
                    print_error(&error, writer);
                    no_errors = false;
@@ -144,7 +155,7 @@ impl<'b> Controller<'b> {
        Ok(no_errors)
    }

-    fn print_file<'a>(
+    fn print_file(
        &self,
        printer: &mut dyn Printer,
        writer: &mut dyn Write,
@@ -194,6 +205,8 @@ impl<'b> Controller<'b> {
        let mut first_range: bool = true;
        let mut mid_range: bool = false;

+        let style_snip = self.config.style_components.snip();
+
        while reader.read_line(&mut line_buffer)? {
            match line_ranges.check(line_number) {
                RangeCheckResult::BeforeOrBetweenRanges => {
@@ -204,7 +217,7 @@ impl<'b> Controller<'b> {
                }

                RangeCheckResult::InRange => {
-                    if self.config.style_components.snip() {
+                    if style_snip {
                        if first_range {
                            first_range = false;
                            mid_range = true;
@@ -20,6 +20,10 @@ error_chain! {
            description("unknown syntax"),
            display("unknown syntax: '{}'", name)
        }
+        InvalidPagerValueBat {
+            description("invalid value `bat` for pager property"),
+            display("Use of bat as a pager is disallowed in order to avoid infinite recursion problems")
+        }
    }
 }

@@ -1,7 +1,9 @@
+use std::convert::TryFrom;
 use std::ffi::{OsStr, OsString};
 use std::fs::File;
 use std::io::{self, BufRead, BufReader, Read};

+use clircle::{Clircle, Identifier};
 use content_inspector::{self, ContentType};

 use crate::error::*;
@@ -135,17 +137,12 @@ impl<'a> Input<'a> {
    }

    pub fn is_stdin(&self) -> bool {
-        if let InputKind::StdIn = self.kind {
-            true
-        } else {
-            false
-        }
+        matches!(self.kind, InputKind::StdIn)
    }

    pub fn with_name(mut self, provided_name: Option<&OsStr>) -> Self {
-        match provided_name {
-            Some(name) => self.description.name = name.to_string_lossy().to_string(),
-            None => {}
+        if let Some(name) = provided_name {
+            self.description.name = name.to_string_lossy().to_string()
        }

        self.metadata.user_provided_name = provided_name.map(|n| n.to_owned());
@@ -160,25 +157,55 @@ impl<'a> Input<'a> {
        &mut self.description
    }

-    pub(crate) fn open<R: BufRead + 'a>(self, stdin: R) -> Result<OpenedInput<'a>> {
+    pub(crate) fn open<R: BufRead + 'a>(
+        self,
+        stdin: R,
+        stdout_identifier: Option<&Identifier>,
+    ) -> Result<OpenedInput<'a>> {
        let description = self.description().clone();
        match self.kind {
-            InputKind::StdIn => Ok(OpenedInput {
-                kind: OpenedInputKind::StdIn,
-                description,
-                metadata: self.metadata,
-                reader: InputReader::new(stdin),
-            }),
+            InputKind::StdIn => {
+                if let Some(stdout) = stdout_identifier {
+                    let input_identifier = Identifier::try_from(clircle::Stdio::Stdin)
+                        .map_err(|e| format!("Stdin: Error identifying file: {}", e))?;
+                    if stdout.surely_conflicts_with(&input_identifier) {
+                        return Err("IO circle detected. The input from stdin is also an output. Aborting to avoid infinite loop.".into());
+                    }
+                }
+
+                Ok(OpenedInput {
+                    kind: OpenedInputKind::StdIn,
+                    description,
+                    metadata: self.metadata,
+                    reader: InputReader::new(stdin),
+                })
+            }
+
            InputKind::OrdinaryFile(path) => Ok(OpenedInput {
                kind: OpenedInputKind::OrdinaryFile(path.clone()),
                description,
                metadata: self.metadata,
                reader: {
-                    let file = File::open(&path)
+                    let mut file = File::open(&path)
                        .map_err(|e| format!("'{}': {}", path.to_string_lossy(), e))?;
                    if file.metadata()?.is_dir() {
                        return Err(format!("'{}' is a directory.", path.to_string_lossy()).into());
                    }
+
+                    if let Some(stdout) = stdout_identifier {
+                        let input_identifier = Identifier::try_from(file).map_err(|e| {
+                            format!("{}: Error identifying file: {}", path.to_string_lossy(), e)
+                        })?;
+                        if stdout.surely_conflicts_with(&input_identifier) {
+                            return Err(format!(
+                                "IO circle detected. The input from '{}' is also an output. Aborting to avoid infinite loop.",
+                                path.to_string_lossy()
+                            )
+                            .into());
+                        }
+                        file = input_identifier.into_inner().expect("The file was lost in the clircle::Identifier, this should not have happended...");
+                    }
+
                    InputReader::new(BufReader::new(file))
                },
            }),
@@ -1,9 +1,10 @@
 #![cfg(feature = "paging")]

+use std::ffi::OsStr;
 use std::process::Command;

-pub fn retrieve_less_version() -> Option<usize> {
-    let cmd = Command::new("less").arg("--version").output().ok()?;
+pub fn retrieve_less_version(less_path: &dyn AsRef<OsStr>) -> Option<usize> {
+    let cmd = Command::new(less_path).arg("--version").output().ok()?;
    parse_less_version(&cmd.stdout)
 }

@@ -19,6 +19,8 @@
 //!     .unwrap();
 //! ```

+mod macros;
+
 pub mod assets;
 pub mod assets_metadata;
 pub mod config;
@@ -31,6 +33,8 @@ mod less;
 pub mod line_range;
 mod output;
 #[cfg(feature = "paging")]
+mod pager;
+#[cfg(feature = "paging")]
 pub(crate) mod paging;
 mod preprocessor;
 mod pretty_printer;
@@ -0,0 +1,7 @@
+#[macro_export]
+macro_rules! bat_warning {
+    ($($arg:tt)*) => ({
+        use ansi_term::Colour::Yellow;
+        eprintln!("{}: {}", Yellow.paint("[bat warning]"), format!($($arg)*));
+    })
+}
@@ -7,6 +7,15 @@ use crate::error::*;
 use crate::less::retrieve_less_version;
 #[cfg(feature = "paging")]
 use crate::paging::PagingMode;
+#[cfg(feature = "paging")]
+use crate::wrapping::WrappingMode;
+
+#[cfg(feature = "paging")]
+#[derive(Debug, PartialEq)]
+enum SingleScreenAction {
+    Quit,
+    Nothing,
+}

 #[derive(Debug)]
 pub enum OutputType {
@@ -17,108 +26,93 @@ pub enum OutputType {

 impl OutputType {
    #[cfg(feature = "paging")]
-    pub fn from_mode(mode: PagingMode, pager: Option<&str>) -> Result<Self> {
+    pub fn from_mode(
+        paging_mode: PagingMode,
+        wrapping_mode: WrappingMode,
+        pager: Option<&str>,
+    ) -> Result<Self> {
        use self::PagingMode::*;
-        Ok(match mode {
-            Always => OutputType::try_pager(false, pager)?,
-            QuitIfOneScreen => OutputType::try_pager(true, pager)?,
+        Ok(match paging_mode {
+            Always => OutputType::try_pager(SingleScreenAction::Nothing, wrapping_mode, pager)?,
+            QuitIfOneScreen => {
+                OutputType::try_pager(SingleScreenAction::Quit, wrapping_mode, pager)?
+            }
            _ => OutputType::stdout(),
        })
    }

    /// Try to launch the pager. Fall back to stdout in case of errors.
    #[cfg(feature = "paging")]
-    fn try_pager(quit_if_one_screen: bool, pager_from_config: Option<&str>) -> Result<Self> {
-        use std::env;
-        use std::ffi::OsString;
-        use std::path::PathBuf;
+    fn try_pager(
+        single_screen_action: SingleScreenAction,
+        wrapping_mode: WrappingMode,
+        pager_from_config: Option<&str>,
+    ) -> Result<Self> {
+        use crate::pager::{self, PagerKind, PagerSource};
        use std::process::{Command, Stdio};

-        let mut replace_arguments_to_less = false;
+        let pager_opt =
+            pager::get_pager(pager_from_config).chain_err(|| "Could not parse pager command.")?;

-        let pager_from_env = match (env::var("BAT_PAGER"), env::var("PAGER")) {
-            (Ok(bat_pager), _) => Some(bat_pager),
-            (_, Ok(pager)) => {
-                // less needs to be called with the '-R' option in order to properly interpret the
-                // ANSI color sequences printed by bat. If someone has set PAGER="less -F", we
-                // therefore need to overwrite the arguments and add '-R'.
-                //
-                // We only do this for PAGER (as it is not specific to 'bat'), not for BAT_PAGER
-                // or bats '--pager' command line option.
-                replace_arguments_to_less = true;
-                Some(pager)
-            }
-            _ => None,
+        let pager = match pager_opt {
+            Some(pager) => pager,
+            None => return Ok(OutputType::stdout()),
        };

-        let pager_from_config = pager_from_config.map(|p| p.to_string());
-
-        if pager_from_config.is_some() {
-            replace_arguments_to_less = false;
+        if pager.kind == PagerKind::Bat {
+            return Err(ErrorKind::InvalidPagerValueBat.into());
        }

-        let pager = pager_from_config
-            .or(pager_from_env)
-            .unwrap_or_else(|| String::from("less"));
+        let mut p = Command::new(&pager.bin);
+        let args = pager.args;

-        let pagerflags =
-            shell_words::split(&pager).chain_err(|| "Could not parse pager command.")?;
+        if pager.kind == PagerKind::Less {
+            // less needs to be called with the '-R' option in order to properly interpret the
+            // ANSI color sequences printed by bat. If someone has set PAGER="less -F", we
+            // therefore need to overwrite the arguments and add '-R'.
+            //
+            // We only do this for PAGER (as it is not specific to 'bat'), not for BAT_PAGER
+            // or bats '--pager' command line option.
+            let replace_arguments_to_less = pager.source == PagerSource::EnvVarPager;

-        match pagerflags.split_first() {
-            Some((pager_name, args)) => {
-                let mut pager_path = PathBuf::from(pager_name);
-
-                if pager_path.file_stem() == Some(&OsString::from("bat")) {
-                    pager_path = PathBuf::from("less");
+            if args.is_empty() || replace_arguments_to_less {
+                p.arg("--RAW-CONTROL-CHARS");
+                if single_screen_action == SingleScreenAction::Quit {
+                    p.arg("--quit-if-one-screen");
                }

-                let is_less = pager_path.file_stem() == Some(&OsString::from("less"));
+                if wrapping_mode == WrappingMode::NoWrapping(true) {
+                    p.arg("--chop-long-lines");
+                }

-                let mut process = if is_less {
-                    let mut p = Command::new(&pager_path);
-                    if args.is_empty() || replace_arguments_to_less {
-                        p.arg("--RAW-CONTROL-CHARS");
-                        if quit_if_one_screen {
-                            p.arg("--quit-if-one-screen");
-                        }
-
-                        // Passing '--no-init' fixes a bug with '--quit-if-one-screen' in older
-                        // versions of 'less'. Unfortunately, it also breaks mouse-wheel support.
-                        //
-                        // See: http://www.greenwoodsoftware.com/less/news.530.html
-                        //
-                        // For newer versions (530 or 558 on Windows), we omit '--no-init' as it
-                        // is not needed anymore.
-                        match retrieve_less_version() {
-                            None => {
-                                p.arg("--no-init");
-                            }
-                            Some(version)
-                                if (version < 530 || (cfg!(windows) && version < 558)) =>
-                            {
-                                p.arg("--no-init");
-                            }
-                            _ => {}
-                        }
-                    } else {
-                        p.args(args);
+                // Passing '--no-init' fixes a bug with '--quit-if-one-screen' in older
+                // versions of 'less'. Unfortunately, it also breaks mouse-wheel support.
+                //
+                // See: http://www.greenwoodsoftware.com/less/news.530.html
+                //
+                // For newer versions (530 or 558 on Windows), we omit '--no-init' as it
+                // is not needed anymore.
+                match retrieve_less_version(&pager.bin) {
+                    None => {
+                        p.arg("--no-init");
                    }
-                    p.env("LESSCHARSET", "UTF-8");
-                    p
-                } else {
-                    let mut p = Command::new(&pager_path);
-                    p.args(args);
-                    p
-                };
-
-                Ok(process
-                    .stdin(Stdio::piped())
-                    .spawn()
-                    .map(OutputType::Pager)
-                    .unwrap_or_else(|_| OutputType::stdout()))
+                    Some(version) if (version < 530 || (cfg!(windows) && version < 558)) => {
+                        p.arg("--no-init");
+                    }
+                    _ => {}
+                }
+            } else {
+                p.args(args);
            }
-            None => Ok(OutputType::stdout()),
-        }
+            p.env("LESSCHARSET", "UTF-8");
+        } else {
+            p.args(args);
+        };
+
+        Ok(p.stdin(Stdio::piped())
+            .spawn()
+            .map(OutputType::Pager)
+            .unwrap_or_else(|_| OutputType::stdout()))
    }

    pub(crate) fn stdout() -> Self {
@@ -127,11 +121,7 @@ impl OutputType {

    #[cfg(feature = "paging")]
    pub(crate) fn is_pager(&self) -> bool {
-        if let OutputType::Pager(_) = self {
-            true
-        } else {
-            false
-        }
+        matches!(self, OutputType::Pager(_))
    }

    #[cfg(not(feature = "paging"))]
@@ -0,0 +1,123 @@
+use shell_words::ParseError;
+use std::env;
+
+/// If we use a pager, this enum tells us from where we were told to use it.
+#[derive(Debug, PartialEq)]
+pub(crate) enum PagerSource {
+    /// From --config
+    Config,
+
+    /// From the env var BAT_PAGER
+    EnvVarBatPager,
+
+    /// From the env var PAGER
+    EnvVarPager,
+
+    /// No pager was specified, default is used
+    Default,
+}
+
+/// We know about some pagers, for example 'less'. This is a list of all pagers we know about
+#[derive(Debug, PartialEq)]
+pub(crate) enum PagerKind {
+    /// bat
+    Bat,
+
+    /// less
+    Less,
+
+    /// more
+    More,
+
+    /// most
+    Most,
+
+    /// A pager we don't know about
+    Unknown,
+}
+
+impl PagerKind {
+    fn from_bin(bin: &str) -> PagerKind {
+        use std::path::Path;
+
+        match Path::new(bin)
+            .file_stem()
+            .map(|s| s.to_string_lossy())
+            .as_deref()
+        {
+            Some("bat") => PagerKind::Bat,
+            Some("less") => PagerKind::Less,
+            Some("more") => PagerKind::More,
+            Some("most") => PagerKind::Most,
+            _ => PagerKind::Unknown,
+        }
+    }
+}
+
+/// A pager such as 'less', and from where we got it.
+#[derive(Debug)]
+pub(crate) struct Pager {
+    /// The pager binary
+    pub bin: String,
+
+    /// The pager binary arguments (that we might tweak)
+    pub args: Vec<String>,
+
+    /// What pager this is
+    pub kind: PagerKind,
+
+    /// From where this pager comes
+    pub source: PagerSource,
+}
+
+impl Pager {
+    fn new(bin: &str, args: &[String], kind: PagerKind, source: PagerSource) -> Pager {
+        Pager {
+            bin: String::from(bin),
+            args: args.to_vec(),
+            kind,
+            source,
+        }
+    }
+}
+
+/// Returns what pager to use, after looking at both config and environment variables.
+pub(crate) fn get_pager(config_pager: Option<&str>) -> Result<Option<Pager>, ParseError> {
+    let bat_pager = env::var("BAT_PAGER");
+    let pager = env::var("PAGER");
+
+    let (cmd, source) = match (config_pager, &bat_pager, &pager) {
+        (Some(config_pager), _, _) => (config_pager, PagerSource::Config),
+        (_, Ok(bat_pager), _) => (bat_pager.as_str(), PagerSource::EnvVarBatPager),
+        (_, _, Ok(pager)) => (pager.as_str(), PagerSource::EnvVarPager),
+        _ => ("less", PagerSource::Default),
+    };
+
+    let parts = shell_words::split(cmd)?;
+    match parts.split_first() {
+        Some((bin, args)) => {
+            let kind = PagerKind::from_bin(bin);
+
+            let use_less_instead = match (&source, &kind) {
+                // 'more' and 'most' do not supports colors; automatically use 'less' instead
+                // if the problematic pager came from the generic PAGER env var
+                (PagerSource::EnvVarPager, PagerKind::More) => true,
+                (PagerSource::EnvVarPager, PagerKind::Most) => true,
+
+                // If PAGER=bat, silently use 'less' instead to prevent recursion ...
+                (PagerSource::EnvVarPager, PagerKind::Bat) => true,
+
+                // Never silently use less if BAT_PAGER or --pager has been specified
+                _ => false,
+            };
+
+            Ok(Some(if use_less_instead {
+                let no_args = vec![];
+                Pager::new("less", &no_args, PagerKind::Less, PagerSource::EnvVarPager)
+            } else {
+                Pager::new(bin, args, kind, source)
+            }))
+        }
+        None => Ok(None),
+    }
+}
@@ -72,7 +72,7 @@ pub fn replace_nonprintable(input: &[u8], tab_width: usize) -> String {
                    }
                }
                // line feed
-                '\x0A' => output.push('␊'),
+                '\x0A' => output.push_str("␊\x0A"),
                // carriage return
                '\x0D' => output.push('␍'),
                // null
@@ -23,6 +23,7 @@ struct ActiveStyleComponents {
    header: bool,
    vcs_modification_markers: bool,
    grid: bool,
+    rule: bool,
    line_numbers: bool,
    snip: bool,
 }
@@ -89,48 +90,17 @@ impl<'a> PrettyPrinter<'a> {
        self
    }

-    /// Add STDIN as an input (with customized name)
-    #[deprecated]
-    pub fn input_stdin_with_name(&mut self, name: impl AsRef<OsStr>) -> &mut Self {
-        self.inputs
-            .push(Input::from_stdin().name(name).kind("File"));
-        self
-    }
-
    /// Add a byte string as an input
    pub fn input_from_bytes(&mut self, content: &'a [u8]) -> &mut Self {
        self.input_from_reader(content)
    }

-    /// Add a byte string as an input (with customized name)
-    #[deprecated]
-    #[allow(deprecated)]
-    pub fn input_from_bytes_with_name(
-        &mut self,
-        content: &'a [u8],
-        name: impl AsRef<OsStr>,
-    ) -> &mut Self {
-        self.input_from_reader_with_name(content, name)
-    }
-
    /// Add a custom reader as an input
    pub fn input_from_reader<R: Read + 'a>(&mut self, reader: R) -> &mut Self {
        self.inputs.push(Input::from_reader(reader));
        self
    }

-    /// Add a custom reader as an input (with customized name)
-    #[deprecated]
-    pub fn input_from_reader_with_name<R: Read + 'a>(
-        &mut self,
-        reader: R,
-        name: impl AsRef<OsStr>,
-    ) -> &mut Self {
-        self.inputs
-            .push(Input::from_reader(reader).name(name).kind("File"));
-        self
-    }
-
    /// Specify the syntax file which should be used (default: auto-detect)
    pub fn language(&mut self, language: &'a str) -> &mut Self {
        self.config.language = Some(language);
@@ -179,21 +149,17 @@ impl<'a> PrettyPrinter<'a> {
        self
    }

+    /// Whether to paint a horizontal rule to delimit files
+    pub fn rule(&mut self, yes: bool) -> &mut Self {
+        self.active_style_components.rule = yes;
+        self
+    }
+
    /// Whether to show modification markers for VCS changes. This has no effect if
    /// the `git` feature is not activated.
-    #[cfg_attr(
-        not(feature = "git"),
-        deprecated(
-            note = "Using vcs_modification_markers without the 'git' feature has no effect. \
-                    The function will be removed (for non-'git' use cases) in the future."
-        )
-    )]
-    #[allow(unused_variables)]
+    #[cfg(feature = "git")]
    pub fn vcs_modification_markers(&mut self, yes: bool) -> &mut Self {
-        #[cfg(feature = "git")]
-        {
-            self.active_style_components.vcs_modification_markers = yes;
-        }
+        self.active_style_components.vcs_modification_markers = yes;
        self
    }

@@ -285,6 +251,9 @@ impl<'a> PrettyPrinter<'a> {
        if self.active_style_components.grid {
            style_components.push(StyleComponent::Grid);
        }
+        if self.active_style_components.rule {
+            style_components.push(StyleComponent::Rule);
+        }
        if self.active_style_components.header {
            style_components.push(StyleComponent::Header);
        }
@@ -310,6 +279,12 @@ impl<'a> PrettyPrinter<'a> {
    }
 }

+impl Default for PrettyPrinter<'_> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// An input source for the pretty printer.
 pub struct Input<'a> {
    input: input::Input<'a>,
@@ -328,7 +303,7 @@ impl<'a> Input<'a> {

    /// A new input from bytes.
    pub fn from_bytes(bytes: &'a [u8]) -> Self {
-        Input::from_reader(bytes).into()
+        Input::from_reader(bytes)
    }

    /// A new input from STDIN.
@@ -91,9 +91,6 @@ impl<'a> Printer for SimplePrinter<'a> {
            if self.config.show_nonprintable {
                let line = replace_nonprintable(line_buffer, self.config.tab_width);
                write!(handle, "{}", line)?;
-                if line_buffer.last() == Some(&b'\n') {
-                    writeln!(handle)?;
-                }
            } else {
                handle.write_all(line_buffer)?
            };
@@ -200,13 +197,18 @@ impl<'a> InteractivePrinter<'a> {
        })
    }

+    fn print_horizontal_line_term(&mut self, handle: &mut dyn Write, style: Style) -> Result<()> {
+        writeln!(
+            handle,
+            "{}",
+            style.paint("─".repeat(self.config.term_width))
+        )?;
+        Ok(())
+    }
+
    fn print_horizontal_line(&mut self, handle: &mut dyn Write, grid_char: char) -> Result<()> {
        if self.panel_width == 0 {
-            writeln!(
-                handle,
-                "{}",
-                self.colors.grid.paint("─".repeat(self.config.term_width))
-            )?;
+            self.print_horizontal_line_term(handle, self.colors.grid)?;
        } else {
            let hline = "─".repeat(self.config.term_width - (self.panel_width + 1));
            let hline = format!("{}{}{}", "─".repeat(self.panel_width), grid_char, hline);
@@ -251,6 +253,10 @@ impl<'a> Printer for InteractivePrinter<'a> {
        input: &OpenedInput,
        add_header_padding: bool,
    ) -> Result<()> {
+        if add_header_padding && self.config.style_components.rule() {
+            self.print_horizontal_line_term(handle, self.colors.rule)?;
+        }
+
        if !self.config.style_components.header() {
            if Some(ContentType::BINARY) == self.content_type && !self.config.show_nonprintable {
                writeln!(
@@ -279,7 +285,8 @@ impl<'a> Printer for InteractivePrinter<'a> {
                    .paint(if self.panel_width > 0 { "│ " } else { "" }),
            )?;
        } else {
-            if add_header_padding {
+            // Only pad space between files, if we haven't already drawn a horizontal rule
+            if add_header_padding && !self.config.style_components.rule() {
                writeln!(handle)?;
            }
            write!(handle, "{}", " ".repeat(self.panel_width))?;
@@ -301,7 +308,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
            description
                .kind()
                .map(|kind| format!("{}: ", kind))
-                .unwrap_or("".into()),
+                .unwrap_or_else(|| "".into()),
            self.colors.filename.paint(description.title()),
            mode
        )?;
@@ -417,7 +424,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
        }

        // Line contents.
-        if self.config.wrapping_mode == WrappingMode::NoWrapping {
+        if matches!(self.config.wrapping_mode, WrappingMode::NoWrapping(_)) {
            let true_color = self.config.true_color;
            let colored_output = self.config.colored_output;
            let italics = self.config.use_italic_text;
@@ -441,7 +448,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
                if text.len() != text_trimmed.len() {
                    if let Some(background_color) = background_color {
                        let mut ansi_style = Style::default();
-                        ansi_style.background = Some(to_ansi_color(background_color, true_color));
+                        ansi_style.background = to_ansi_color(background_color, true_color);
                        let width = if cursor_total <= cursor_max {
                            cursor_max - cursor_total + 1
                        } else {
@@ -453,7 +460,7 @@ impl<'a> Printer for InteractivePrinter<'a> {
                }
            }

-            if line.bytes().next_back() != Some(b'\n') {
+            if !self.config.style_components.plain() && line.bytes().next_back() != Some(b'\n') {
                writeln!(handle)?;
            }
        } else {
@@ -582,8 +589,7 @@ impl<'a> Printer for InteractivePrinter<'a> {

            if let Some(background_color) = background_color {
                let mut ansi_style = Style::default();
-                ansi_style.background =
-                    Some(to_ansi_color(background_color, self.config.true_color));
+                ansi_style.background = to_ansi_color(background_color, self.config.true_color);

                write!(
                    handle,
@@ -603,6 +609,7 @@ const DEFAULT_GUTTER_COLOR: u8 = 238;
 #[derive(Debug, Default)]
 pub struct Colors {
    pub grid: Style,
+    pub rule: Style,
    pub filename: Style,
    pub git_added: Style,
    pub git_removed: Style,
@@ -616,19 +623,27 @@ impl Colors {
    }

    fn colored(theme: &Theme, true_color: bool) -> Self {
-        let gutter_color = theme
-            .settings
-            .gutter_foreground
-            .map(|c| to_ansi_color(c, true_color))
-            .unwrap_or(Fixed(DEFAULT_GUTTER_COLOR));
+        let gutter_style = Style {
+            foreground: match theme.settings.gutter_foreground {
+                // If the theme provides a gutter foreground color, use it.
+                // Note: It might be the special value #00000001, in which case
+                // to_ansi_color returns None and we use an empty Style
+                // (resulting in the terminal's default foreground color).
+                Some(c) => to_ansi_color(c, true_color),
+                // Otherwise, use a specific fallback color.
+                None => Some(Fixed(DEFAULT_GUTTER_COLOR)),
+            },
+            ..Style::default()
+        };

        Colors {
-            grid: gutter_color.normal(),
+            grid: gutter_style,
+            rule: gutter_style,
            filename: Style::new().bold(),
            git_added: Green.normal(),
            git_removed: Red.normal(),
            git_modified: Yellow.normal(),
-            line_number: gutter_color.normal(),
+            line_number: gutter_style,
        }
    }
 }
@@ -9,6 +9,7 @@ pub enum StyleComponent {
    #[cfg(feature = "git")]
    Changes,
    Grid,
+    Rule,
    Header,
    LineNumbers,
    Snip,
@@ -29,6 +30,7 @@ impl StyleComponent {
            #[cfg(feature = "git")]
            StyleComponent::Changes => &[StyleComponent::Changes],
            StyleComponent::Grid => &[StyleComponent::Grid],
+            StyleComponent::Rule => &[StyleComponent::Rule],
            StyleComponent::Header => &[StyleComponent::Header],
            StyleComponent::LineNumbers => &[StyleComponent::LineNumbers],
            StyleComponent::Snip => &[StyleComponent::Snip],
@@ -54,6 +56,7 @@ impl FromStr for StyleComponent {
            #[cfg(feature = "git")]
            "changes" => Ok(StyleComponent::Changes),
            "grid" => Ok(StyleComponent::Grid),
+            "rule" => Ok(StyleComponent::Rule),
            "header" => Ok(StyleComponent::Header),
            "numbers" => Ok(StyleComponent::LineNumbers),
            "snip" => Ok(StyleComponent::Snip),
@@ -81,6 +84,10 @@ impl StyleComponents {
        self.0.contains(&StyleComponent::Grid)
    }

+    pub fn rule(&self) -> bool {
+        self.0.contains(&StyleComponent::Rule)
+    }
+
    pub fn header(&self) -> bool {
        self.0.contains(&StyleComponent::Header)
    }
@@ -42,6 +42,9 @@ impl<'a> SyntaxMapping<'a> {
                MappingTarget::MapTo("Bourne Again Shell (bash)"),
            )
            .unwrap();
+        mapping
+            .insert("*.pac", MappingTarget::MapTo("JavaScript (Babel)"))
+            .unwrap();

        // See #1008
        mapping
@@ -54,6 +57,11 @@ impl<'a> SyntaxMapping<'a> {
            .insert("*.conf", MappingTarget::MapToUnknown)
            .unwrap();

+        // Re-insert a mapping for resolv.conf, see #1510
+        mapping
+            .insert("resolv.conf", MappingTarget::MapTo("resolv"))
+            .unwrap();
+
        for glob in &[
            "/etc/nginx/**/*.conf",
            "/etc/nginx/sites-*/**/*",
@@ -3,13 +3,13 @@ use ansi_term::{self, Style};

 use syntect::highlighting::{self, FontStyle};

-pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> ansi_term::Color {
+pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> Option<ansi_term::Color> {
    if color.a == 0 {
        // Themes can specify one of the user-configurable terminal colors by
        // encoding them as #RRGGBBAA with AA set to 00 (transparent) and RR set
-        // to the 8-bit color palette number. The built-in themes ansi-light,
-        // ansi-dark, base16, and base16-256 use this.
-        match color.r {
+        // to the 8-bit color palette number. The built-in themes ansi, base16,
+        // and base16-256 use this.
+        Some(match color.r {
            // For the first 8 colors, use the Color enum to produce ANSI escape
            // sequences using codes 30-37 (foreground) and 40-47 (background).
            // For example, red foreground is \x1b[31m. This works on terminals
@@ -31,11 +31,18 @@ pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> ansi_term:
            // 90-97 (foreground) and 100-107 (background), we should use those
            // for values 0x08 to 0x0f and only use Fixed for 0x10 to 0xff.
            n => Fixed(n),
-        }
+        })
+    } else if color.a == 1 {
+        // Themes can specify the terminal's default foreground/background color
+        // (i.e. no escape sequence) using the encoding #RRGGBBAA with AA set to
+        // 01. The built-in theme ansi uses this.
+        None
    } else if true_color {
-        RGB(color.r, color.g, color.b)
+        Some(RGB(color.r, color.g, color.b))
    } else {
-        Fixed(ansi_colours::ansi256_from_rgb((color.r, color.g, color.b)))
+        Some(Fixed(ansi_colours::ansi256_from_rgb((
+            color.r, color.g, color.b,
+        ))))
    }
 }

@@ -54,7 +61,10 @@ pub fn as_terminal_escaped(
    let mut style = if !colored {
        Style::default()
    } else {
-        let mut color = Style::from(to_ansi_color(style.foreground, true_color));
+        let mut color = Style {
+            foreground: to_ansi_color(style.foreground, true_color),
+            ..Style::default()
+        };
        if style.font_style.contains(FontStyle::BOLD) {
            color = color.bold();
        }
@@ -67,6 +77,6 @@ pub fn as_terminal_escaped(
        color
    };

-    style.background = background_color.map(|c| to_ansi_color(c, true_color));
+    style.background = background_color.and_then(|c| to_ansi_color(c, true_color));
    style.paint(text).to_string()
 }
@@ -1,11 +1,12 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum WrappingMode {
    Character,
-    NoWrapping,
+    // The bool specifies whether wrapping has been explicitly disabled by the user via --wrap=never
+    NoWrapping(bool),
 }

 impl Default for WrappingMode {
    fn default() -> Self {
-        WrappingMode::NoWrapping
+        WrappingMode::NoWrapping(false)
    }
 }
@@ -1,10 +1,8 @@
 # force LF EOLs for test fixtures
 examples/** text=auto eol=lf
 snapshots/** text=auto eol=lf
-
-# BAT/CMD files always need CRLF EOLs
-*.[Bb][Aa][Tt] text eol=crlf
-*.[Cc][Mm][Dd] text eol=crlf
+syntax-tests/source/** text=auto eol=lf
+syntax-tests/highlighted/** text=auto eol=lf

 examples/* linguist-vendored
 snapshots/* linguist-vendored
@@ -1,17 +1,21 @@
 use bat::assets::HighlightingAssets;

 /// This test ensures that we are not accidentally removing themes due to submodule updates.
+/// It is 'ignore'd by default because it requires themes.bin to be up-to-date.
 #[test]
+#[ignore]
 fn all_themes_are_present() {
    let assets = HighlightingAssets::from_binary();

    let mut themes: Vec<_> = assets.themes().collect();
-    themes.sort();
+    themes.sort_unstable();

    assert_eq!(
        themes,
        vec![
            "1337",
+            "Coldark-Cold",
+            "Coldark-Dark",
            "DarkNeon",
            "Dracula",
            "GitHub",
@@ -26,13 +30,11 @@ fn all_themes_are_present() {
            "Solarized (light)",
            "Sublime Snazzy",
            "TwoDark",
-            "ansi-dark",
-            "ansi-light",
+            "ansi",
            "base16",
            "base16-256",
-            "gruvbox",
+            "gruvbox-dark",
            "gruvbox-light",
-            "gruvbox-white",
            "zenburn"
        ]
    );
@@ -1,6 +1,8 @@
-#!/bin/bash
+#!/usr/bin/env bash

-if ! which hyperfine > /dev/null 2>&1; then
+cd "$(dirname "${BASH_SOURCE[0]}")" || exit
+
+if ! command -v hyperfine > /dev/null 2>&1; then
    echo "'hyperfine' does not seem to be installed."
    echo "You can get it here: https://github.com/sharkdp/hyperfine"
    exit 1
@@ -1,26 +1,72 @@
-#!/bin/bash
+#!/usr/bin/env bash
+cd "$(dirname "${BASH_SOURCE[0]}")" || exit

-if ! which hyperfine > /dev/null 2>&1; then
+# Check that Hyperfine is installed.
+if ! command -v hyperfine > /dev/null 2>&1; then
    echo "'hyperfine' does not seem to be installed."
    echo "You can get it here: https://github.com/sharkdp/hyperfine"
    exit 1
 fi

+# Determine the target directories.
+get_target_dir() {
+	if [[ -f "$HOME/.cargo/config" ]]; then
+		grep 'target-dir[[:space:]]*=' "$HOME/.cargo/config" \
+			| sed 's/^[[:space:]]*target-dir[[:space:]]*=//; s/^[[:space:]]*"//; s/"[[:space:]]*$//' \
+			&& return 0
+	fi
+	
+	echo "../../target"
+}
+
+TARGET_DIR="$(get_target_dir)"
+TARGET_DEBUG="${TARGET_DIR}/debug/bat"
+TARGET_RELEASE="${TARGET_DIR}/release/bat"
+
+# Determine which target to benchmark.
+BAT=''
+for arg in "$@"; do
+	case "$arg" in
+		--system)  BAT="bat" ;;
+		--debug)   BAT="$TARGET_DEBUG" ;;
+		--release) BAT="$TARGET_RELEASE" ;;
+		--bat=*)   BAT="${arg:6}" ;;
+	esac
+done
+
+if [[ -z "$BAT" ]]; then
+	echo "A build of 'bat' must be specified for benchmarking."
+	echo "You can use '--system', '--debug', or '--release'."
+	exit 1
+fi
+
+# Ensure that the target is built.
+if ! command -v "$BAT" &>/dev/null; then
+	echo "Could not find the build of bat to benchmark."
+	case "$BAT" in
+		"bat")             echo "Make you sure to symlink 'batcat' as 'bat'." ;;
+		"$TARGET_DEBUG")   echo "Make you sure to 'cargo build' first." ;;
+		"$TARGET_RELEASE") echo "Make you sure to 'cargo build --release' first." ;;
+	esac
+	exit 1
+fi
+
+# Run the benchmark.
 echo "### Startup time"
 echo

-hyperfine --warmup 3 bat
+hyperfine --warmup 3 "$BAT"

 echo
 echo "### Plain text"
 echo

-hyperfine --warmup 3 "bat --language txt --paging=never 'test-src/jquery-3.3.1.js'"
+hyperfine --warmup 3 "$(printf "%q" "$BAT") --language txt --paging=never 'test-src/jquery-3.3.1.js'"

 echo
 echo "### Time to syntax-highlight large files"
 echo

 for SRC in test-src/*; do
-    hyperfine --warmup 3 "bat --style=full --color=always --paging=never '$SRC'"
+    hyperfine --warmup 3 "$(printf "%q" "$BAT") --style=full --color=always --paging=never $(printf "%q" "$SRC")"
 done
@@ -1,11 +1,37 @@
-use assert_cmd::Command;
+use assert_cmd::cargo::CommandCargoExt;
 use predicates::{prelude::predicate, str::PredicateStrExt};
+use serial_test::serial;
 use std::path::Path;
+use std::process::Command;
 use std::str::from_utf8;
+use tempfile::tempdir;
+
+#[cfg(unix)]
+mod unix {
+    pub use std::fs::File;
+    pub use std::io::{self, Write};
+    pub use std::os::unix::io::FromRawFd;
+    pub use std::path::PathBuf;
+    pub use std::process::Stdio;
+    pub use std::thread;
+    pub use std::time::Duration;
+
+    pub use assert_cmd::assert::OutputAssertExt;
+    pub use nix::pty::{openpty, OpenptyResult};
+    pub use wait_timeout::ChildExt;
+
+    pub const SAFE_CHILD_PROCESS_CREATION_TIME: Duration = Duration::from_millis(100);
+    pub const CHILD_WAIT_TIMEOUT: Duration = Duration::from_secs(15);
+}
+#[cfg(unix)]
+use unix::*;
+
+mod utils;
+use utils::mocked_pagers;

 const EXAMPLES_DIR: &str = "tests/examples";

-fn bat_with_config() -> Command {
+fn bat_raw_command_with_config() -> Command {
    let mut cmd = Command::cargo_bin("bat").unwrap();
    cmd.current_dir("tests/examples");
    cmd.env_remove("PAGER");
@@ -17,12 +43,20 @@ fn bat_with_config() -> Command {
    cmd
 }

-fn bat() -> Command {
-    let mut cmd = bat_with_config();
+fn bat_raw_command() -> Command {
+    let mut cmd = bat_raw_command_with_config();
    cmd.arg("--no-config");
    cmd
 }

+fn bat_with_config() -> assert_cmd::Command {
+    assert_cmd::Command::from_std(bat_raw_command_with_config())
+}
+
+fn bat() -> assert_cmd::Command {
+    assert_cmd::Command::from_std(bat_raw_command())
+}
+
 #[test]
 fn basic() {
    bat()
@@ -189,6 +223,122 @@ fn line_range_multiple() {
        .stdout("line 1\nline 2\nline 4\n");
 }

+#[cfg(unix)]
+fn setup_temp_file(content: &[u8]) -> io::Result<(PathBuf, tempfile::TempDir)> {
+    let dir = tempfile::tempdir().expect("Couldn't create tempdir");
+    let path = dir.path().join("temp_file");
+    File::create(&path)?.write_all(content)?;
+    Ok((path, dir))
+}
+
+#[cfg(unix)]
+#[test]
+fn basic_io_cycle() -> io::Result<()> {
+    let (filename, dir) = setup_temp_file(b"I am not empty")?;
+
+    let file_out = Stdio::from(File::create(&filename)?);
+    let res = bat_raw_command()
+        .arg("test.txt")
+        .arg(&filename)
+        .stdout(file_out)
+        .assert();
+    drop(dir);
+    res.failure();
+    Ok(())
+}
+
+#[cfg(unix)]
+#[test]
+fn first_file_cyclic_is_ok() -> io::Result<()> {
+    let (filename, dir) = setup_temp_file(b"I am not empty")?;
+
+    let file_out = Stdio::from(File::create(&filename)?);
+    let res = bat_raw_command()
+        .arg(&filename)
+        .arg("test.txt")
+        .stdout(file_out)
+        .assert();
+    drop(dir);
+    res.success();
+    Ok(())
+}
+
+#[cfg(unix)]
+#[test]
+fn empty_file_cycle_is_ok() -> io::Result<()> {
+    let (filename, dir) = setup_temp_file(b"I am not empty")?;
+
+    let file_out = Stdio::from(File::create(&filename)?);
+    let res = bat_raw_command()
+        .arg("empty.txt")
+        .arg(&filename)
+        .stdout(file_out)
+        .assert();
+    drop(dir);
+    res.success();
+    Ok(())
+}
+
+#[cfg(unix)]
+#[test]
+fn stdin_to_stdout_cycle() -> io::Result<()> {
+    let (filename, dir) = setup_temp_file(b"I am not empty")?;
+    let file_in = Stdio::from(File::open(&filename)?);
+    let file_out = Stdio::from(File::create(&filename)?);
+    let res = bat_raw_command()
+        .arg("test.txt")
+        .arg("-")
+        .stdin(file_in)
+        .stdout(file_out)
+        .assert();
+    drop(dir);
+    res.failure();
+    Ok(())
+}
+
+#[cfg(unix)]
+#[test]
+fn no_args_doesnt_break() {
+    // To simulate bat getting started from the shell, a process is created with stdin and stdout
+    // as the slave end of a pseudo terminal. Although both point to the same "file", bat should
+    // not exit, because in this case it is safe to read and write to the same fd, which is why
+    // this test exists.
+    let OpenptyResult { master, slave } = openpty(None, None).expect("Couldn't open pty.");
+    let mut master = unsafe { File::from_raw_fd(master) };
+    let stdin = unsafe { Stdio::from_raw_fd(slave) };
+    let stdout = unsafe { Stdio::from_raw_fd(slave) };
+
+    let mut child = bat_raw_command()
+        .stdin(stdin)
+        .stdout(stdout)
+        .spawn()
+        .expect("Failed to start.");
+
+    // Some time for the child process to start and to make sure, that we can poll the exit status.
+    // Although this waiting period is not necessary, it is best to keep it in and be absolutely
+    // sure, that the try_wait does not error later.
+    thread::sleep(SAFE_CHILD_PROCESS_CREATION_TIME);
+
+    // The child process should be running and waiting for input,
+    // therefore no exit status should be available.
+    let exit_status = child
+        .try_wait()
+        .expect("Error polling exit status, this should never happen.");
+    assert!(exit_status.is_none());
+
+    // Write Ctrl-D (end of transmission) to the pty.
+    master
+        .write_all(&[0x04])
+        .expect("Couldn't write EOT character to master end.");
+
+    let exit_status = child
+        .wait_timeout(CHILD_WAIT_TIMEOUT)
+        .expect("Error polling exit status, this should never happen.")
+        .expect("Exit status not set, but the child should have exited already.");
+
+    assert!(exit_status.success());
+}
+
 #[test]
 fn tabs_numbers() {
    bat()
@@ -405,6 +555,117 @@ fn pager_disable() {
        .stdout(predicate::eq("hello world\n").normalize());
 }

+#[test]
+fn env_var_pager_value_bat() {
+    bat()
+        .env("PAGER", "bat")
+        .arg("--paging=always")
+        .arg("test.txt")
+        .assert()
+        .success()
+        .stdout(predicate::eq("hello world\n").normalize());
+}
+
+#[test]
+fn env_var_bat_pager_value_bat() {
+    bat()
+        .env("BAT_PAGER", "bat")
+        .arg("--paging=always")
+        .arg("test.txt")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("bat as a pager is disallowed"));
+}
+
+#[test]
+fn pager_value_bat() {
+    bat()
+        .arg("--pager=bat")
+        .arg("--paging=always")
+        .arg("test.txt")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("bat as a pager is disallowed"));
+}
+
+/// We shall use less instead of most if PAGER is used since PAGER
+/// is a generic env var
+#[test]
+#[serial] // Because of PATH
+fn pager_most_from_pager_env_var() {
+    mocked_pagers::with_mocked_versions_of_more_and_most_in_path(|| {
+        // If the output is not "I am most" then we know 'most' is not used
+        bat()
+            .env("PAGER", mocked_pagers::from("most"))
+            .arg("--paging=always")
+            .arg("test.txt")
+            .assert()
+            .success()
+            .stdout(predicate::eq("hello world\n").normalize());
+    });
+}
+
+/// If the bat-specific BAT_PAGER is used, obey the wish of the user
+/// and allow 'most'
+#[test]
+#[serial] // Because of PATH
+fn pager_most_from_bat_pager_env_var() {
+    mocked_pagers::with_mocked_versions_of_more_and_most_in_path(|| {
+        bat()
+            .env("BAT_PAGER", mocked_pagers::from("most"))
+            .arg("--paging=always")
+            .arg("test.txt")
+            .assert()
+            .success()
+            .stdout(predicate::str::contains("I am most"));
+    });
+}
+
+/// Same reasoning with --pager as with BAT_PAGER
+#[test]
+#[serial] // Because of PATH
+fn pager_most_from_pager_arg() {
+    mocked_pagers::with_mocked_versions_of_more_and_most_in_path(|| {
+        bat()
+            .arg("--paging=always")
+            .arg(format!("--pager={}", mocked_pagers::from("most")))
+            .arg("test.txt")
+            .assert()
+            .success()
+            .stdout(predicate::str::contains("I am most"));
+    });
+}
+
+/// Make sure the logic for 'most' applies even if an argument is passed
+#[test]
+#[serial] // Because of PATH
+fn pager_most_with_arg() {
+    mocked_pagers::with_mocked_versions_of_more_and_most_in_path(|| {
+        bat()
+            .env("PAGER", format!("{} -w", mocked_pagers::from("most")))
+            .arg("--paging=always")
+            .arg("test.txt")
+            .assert()
+            .success()
+            .stdout(predicate::eq("hello world\n").normalize());
+    });
+}
+
+/// Sanity check that 'more' is treated like 'most'
+#[test]
+#[serial] // Because of PATH
+fn pager_more() {
+    mocked_pagers::with_mocked_versions_of_more_and_most_in_path(|| {
+        bat()
+            .env("PAGER", mocked_pagers::from("more"))
+            .arg("--paging=always")
+            .arg("test.txt")
+            .assert()
+            .success()
+            .stdout(predicate::eq("hello world\n").normalize());
+    });
+}
+
 #[test]
 fn alias_pager_disable() {
    bat()
@@ -428,6 +689,17 @@ fn alias_pager_disable_long_overrides_short() {
        .stdout(predicate::eq("pager-output\n").normalize());
 }

+#[test]
+fn pager_failed_to_parse() {
+    bat()
+        .env("BAT_PAGER", "mismatched-quotes 'a")
+        .arg("--paging=always")
+        .arg("test.txt")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("Could not parse pager command"));
+}
+
 #[test]
 fn config_location_test() {
    bat_with_config()
@@ -436,6 +708,33 @@ fn config_location_test() {
        .assert()
        .success()
        .stdout("bat.conf\n");
+
+    bat_with_config()
+        .env("BAT_CONFIG_PATH", "not-existing.conf")
+        .arg("--config-file")
+        .assert()
+        .success()
+        .stdout("not-existing.conf\n");
+}
+
+#[test]
+fn config_location_when_generating() {
+    let tmp_dir = tempdir().expect("can create temporary directory");
+    let tmp_config_path = tmp_dir.path().join("should-be-created.conf");
+
+    // Create the file with bat
+    bat_with_config()
+        .env("BAT_CONFIG_PATH", tmp_config_path.to_str().unwrap())
+        .arg("--generate-config-file")
+        .assert()
+        .success()
+        .stdout(
+            predicate::str::is_match("Success! Config file written to .*should-be-created.conf\n")
+                .unwrap(),
+        );
+
+    // Now we expect the file to exist. If it exists, we assume contents are correct
+    assert!(tmp_config_path.exists());
 }

 #[test]
@@ -570,6 +869,18 @@ fn empty_file_leads_to_empty_output_with_grid_enabled() {
        .stdout("");
 }

+#[test]
+fn empty_file_leads_to_empty_output_with_rule_enabled() {
+    bat()
+        .arg("empty.txt")
+        .arg("--style=rule")
+        .arg("--decorations=always")
+        .arg("--terminal-width=80")
+        .assert()
+        .success()
+        .stdout("");
+}
+
 #[test]
 fn filename_basic() {
    bat()
@@ -668,6 +979,48 @@ fn header_padding() {
        .stderr("");
 }

+#[test]
+fn header_padding_rule() {
+    bat()
+        .arg("--decorations=always")
+        .arg("--style=header,rule")
+        .arg("--terminal-width=80")
+        .arg("test.txt")
+        .arg("single-line.txt")
+        .assert()
+        .stdout(
+            "File: test.txt
+hello world
+────────────────────────────────────────────────────────────────────────────────
+File: single-line.txt
+Single Line
+",
+        )
+        .stderr("");
+}
+
+#[test]
+fn grid_overrides_rule() {
+    bat()
+        .arg("--decorations=always")
+        .arg("--style=grid,rule")
+        .arg("--terminal-width=80")
+        .arg("test.txt")
+        .arg("single-line.txt")
+        .assert()
+        .stdout(
+            "\
+────────────────────────────────────────────────────────────────────────────────
+hello world
+────────────────────────────────────────────────────────────────────────────────
+────────────────────────────────────────────────────────────────────────────────
+Single Line
+────────────────────────────────────────────────────────────────────────────────
+",
+        )
+        .stderr("\x1b[33m[bat warning]\x1b[0m: Style 'rule' is a subset of style 'grid', 'rule' will not be visible.\n");
+}
+
 #[cfg(target_os = "linux")]
 #[test]
 fn file_with_invalid_utf8_filename() {
@@ -676,9 +1029,7 @@ fn file_with_invalid_utf8_filename() {
    use std::io::Write;
    use std::os::unix::ffi::OsStrExt;

-    use tempdir::TempDir;
-
-    let tmp_dir = TempDir::new("bat_test").expect("can create temporary directory");
+    let tmp_dir = tempdir().expect("can create temporary directory");
    let file_path = tmp_dir
        .path()
        .join(OsStr::from_bytes(b"test-invalid-utf8-\xC3(.rs"));
@@ -749,3 +1100,41 @@ fn show_all_mode() {
        .stdout("hello·world␊\n├──┤␍␀␇␈␛")
        .stderr("");
 }
+
+#[test]
+fn plain_mode_does_not_add_nonexisting_newline() {
+    bat()
+        .arg("--paging=never")
+        .arg("--color=never")
+        .arg("--decorations=always")
+        .arg("--style=plain")
+        .arg("single-line.txt")
+        .assert()
+        .success()
+        .stdout("Single Line");
+}
+
+// Regression test for https://github.com/sharkdp/bat/issues/299
+#[test]
+fn grid_for_file_without_newline() {
+    bat()
+        .arg("--paging=never")
+        .arg("--color=never")
+        .arg("--terminal-width=80")
+        .arg("--wrap=never")
+        .arg("--decorations=always")
+        .arg("--style=full")
+        .arg("single-line.txt")
+        .assert()
+        .success()
+        .stdout(
+            "\
+───────┬────────────────────────────────────────────────────────────────────────
+       │ File: single-line.txt
+───────┼────────────────────────────────────────────────────────────────────────
+   1   │ Single Line
+───────┴────────────────────────────────────────────────────────────────────────
+",
+        )
+        .stderr("");
+}
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+echo I am more
@@ -0,0 +1 @@
+ECHO I am more
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+echo I am most
@@ -0,0 +1 @@
+ECHO I am most
@@ -7,7 +7,7 @@ macro_rules! snapshot_tests {
        $(
            #[test]
            fn $test_name() {
-                let bat_tester = BatTester::new();
+                let bat_tester = BatTester::default();
                bat_tester.test_snapshot(stringify!($test_name), $style);
            }
        )*
@@ -19,17 +19,27 @@ snapshot_tests! {
    grid:                        "grid",
    header:                      "header",
    numbers:                     "numbers",
+    rule:                        "rule",
    changes_grid:                "changes,grid",
    changes_header:              "changes,header",
    changes_numbers:             "changes,numbers",
+    changes_rule:                "changes,rule",
    grid_header:                 "grid,header",
    grid_numbers:                "grid,numbers",
+    grid_rule:                   "grid,rule",
    header_numbers:              "header,numbers",
+    header_rule:                 "header,rule",
    changes_grid_header:         "changes,grid,header",
    changes_grid_numbers:        "changes,grid,numbers",
+    changes_grid_rule:           "changes,grid,rule",
    changes_header_numbers:      "changes,header,numbers",
+    changes_header_rule:         "changes,header,rule",
    grid_header_numbers:         "grid,header,numbers",
+    grid_header_rule:            "grid,header,rule",
+    header_numbers_rule:         "header,numbers,rule",
    changes_grid_header_numbers: "changes,grid,header,numbers",
+    changes_grid_header_rule:    "changes,grid,header,rule",
+    changes_grid_header_numbers_rule: "changes,grid,header,numbers,rule",
    full:                        "full",
    plain:                       "plain",
 }
@@ -7,7 +7,7 @@ import shutil


 def generate_snapshots():
-    single_styles = ["changes", "grid", "header", "numbers"]
+    single_styles = ["changes", "grid", "header", "numbers", "rule"]
    collective_styles = ["full", "plain"]

    for num in range(len(single_styles)):
@@ -0,0 +1,26 @@
+───────┬────────────────────────────────────────────────────────────────────────
+       │ File: sample.rs
+───────┼────────────────────────────────────────────────────────────────────────
+   1   │ struct Rectangle {
+   2   │     width: u32,
+   3   │     height: u32,
+   4   │ }
+   5   │ 
+   6 _ │ fn main() {
+   7   │     let rect1 = Rectangle { width: 30, height: 50 };
+   8   │ 
+   9   │     println!(
+  10 ~ │         "The perimeter of the rectangle is {} pixels.",
+  11 ~ │         perimeter(&rect1)
+  12   │     );
+  13 + │     println!(r#"This line contains invalid utf8:  "�����"#;
+  14   │ }
+  15   │ 
+  16   │ fn area(rectangle: &Rectangle) -> u32 {
+  17   │     rectangle.width * rectangle.height
+  18   │ }
+  19 + │ 
+  20 + │ fn perimeter(rectangle: &Rectangle) -> u32 {
+  21 + │     (rectangle.width + rectangle.height) * 2
+  22 + │ }
+───────┴────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,26 @@
+──┬─────────────────────────────────────────────────────────────────────────────
+  │ File: sample.rs
+──┼─────────────────────────────────────────────────────────────────────────────
+  │ struct Rectangle {
+  │     width: u32,
+  │     height: u32,
+  │ }
+  │ 
+_ │ fn main() {
+  │     let rect1 = Rectangle { width: 30, height: 50 };
+  │ 
+  │     println!(
+~ │         "The perimeter of the rectangle is {} pixels.",
+~ │         perimeter(&rect1)
+  │     );
+ │     println!(r#"This line contains invalid utf8:  "�����"#;
+  │ }
+  │ 
+  │ fn area(rectangle: &Rectangle) -> u32 {
+  │     rectangle.width * rectangle.height
+  │ }
+ │ 
+ │ fn perimeter(rectangle: &Rectangle) -> u32 {
+ │     (rectangle.width + rectangle.height) * 2
+ │ }
+──┴─────────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,24 @@
+───────┬────────────────────────────────────────────────────────────────────────
+   1   │ struct Rectangle {
+   2   │     width: u32,
+   3   │     height: u32,
+   4   │ }
+   5   │ 
+   6 _ │ fn main() {
+   7   │     let rect1 = Rectangle { width: 30, height: 50 };
+   8   │ 
+   9   │     println!(
+  10 ~ │         "The perimeter of the rectangle is {} pixels.",
+  11 ~ │         perimeter(&rect1)
+  12   │     );
+  13 + │     println!(r#"This line contains invalid utf8:  "�����"#;
+  14   │ }
+  15   │ 
+  16   │ fn area(rectangle: &Rectangle) -> u32 {
+  17   │     rectangle.width * rectangle.height
+  18   │ }
+  19 + │ 
+  20 + │ fn perimeter(rectangle: &Rectangle) -> u32 {
+  21 + │     (rectangle.width + rectangle.height) * 2
+  22 + │ }
+───────┴────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,24 @@
+──┬─────────────────────────────────────────────────────────────────────────────
+  │ struct Rectangle {
+  │     width: u32,
+  │     height: u32,
+  │ }
+  │ 
+_ │ fn main() {
+  │     let rect1 = Rectangle { width: 30, height: 50 };
+  │ 
+  │     println!(
+~ │         "The perimeter of the rectangle is {} pixels.",
+~ │         perimeter(&rect1)
+  │     );
+ │     println!(r#"This line contains invalid utf8:  "�����"#;
+  │ }
+  │ 
+  │ fn area(rectangle: &Rectangle) -> u32 {
+  │     rectangle.width * rectangle.height
+  │ }
+ │ 
+ │ fn perimeter(rectangle: &Rectangle) -> u32 {
+ │     (rectangle.width + rectangle.height) * 2
+ │ }
+──┴─────────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,23 @@
+       File: sample.rs
+   1   struct Rectangle {
+   2       width: u32,
+   3       height: u32,
+   4   }
+   5   
+   6 _ fn main() {
+   7       let rect1 = Rectangle { width: 30, height: 50 };
+   8   
+   9       println!(
+  10 ~         "The perimeter of the rectangle is {} pixels.",
+  11 ~         perimeter(&rect1)
+  12       );
+  13 +     println!(r#"This line contains invalid utf8:  "�����"#;
+  14   }
+  15   
+  16   fn area(rectangle: &Rectangle) -> u32 {
+  17       rectangle.width * rectangle.height
+  18   }
+  19 + 
+  20 + fn perimeter(rectangle: &Rectangle) -> u32 {
+  21 +     (rectangle.width + rectangle.height) * 2
+  22 + }
@@ -0,0 +1,23 @@
+  File: sample.rs
+  struct Rectangle {
+      width: u32,
+      height: u32,
+  }
+  
+_ fn main() {
+      let rect1 = Rectangle { width: 30, height: 50 };
+  
+      println!(
+~         "The perimeter of the rectangle is {} pixels.",
+~         perimeter(&rect1)
+      );
+     println!(r#"This line contains invalid utf8:  "�����"#;
+  }
+  
+  fn area(rectangle: &Rectangle) -> u32 {
+      rectangle.width * rectangle.height
+  }
+ 
+ fn perimeter(rectangle: &Rectangle) -> u32 {
+     (rectangle.width + rectangle.height) * 2
+ }
@@ -0,0 +1,22 @@
+   1   struct Rectangle {
+   2       width: u32,
+   3       height: u32,
+   4   }
+   5   
+   6 _ fn main() {
+   7       let rect1 = Rectangle { width: 30, height: 50 };
+   8   
+   9       println!(
+  10 ~         "The perimeter of the rectangle is {} pixels.",
+  11 ~         perimeter(&rect1)
+  12       );
+  13 +     println!(r#"This line contains invalid utf8:  "�����"#;
+  14   }
+  15   
+  16   fn area(rectangle: &Rectangle) -> u32 {
+  17       rectangle.width * rectangle.height
+  18   }
+  19 + 
+  20 + fn perimeter(rectangle: &Rectangle) -> u32 {
+  21 +     (rectangle.width + rectangle.height) * 2
+  22 + }
@@ -0,0 +1,22 @@
+  struct Rectangle {
+      width: u32,
+      height: u32,
+  }
+  
+_ fn main() {
+      let rect1 = Rectangle { width: 30, height: 50 };
+  
+      println!(
+~         "The perimeter of the rectangle is {} pixels.",
+~         perimeter(&rect1)
+      );
+     println!(r#"This line contains invalid utf8:  "�����"#;
+  }
+  
+  fn area(rectangle: &Rectangle) -> u32 {
+      rectangle.width * rectangle.height
+  }
+ 
+ fn perimeter(rectangle: &Rectangle) -> u32 {
+     (rectangle.width + rectangle.height) * 2
+ }
@@ -0,0 +1,26 @@
+─────┬──────────────────────────────────────────────────────────────────────────
+     │ File: sample.rs
+─────┼──────────────────────────────────────────────────────────────────────────
+   1 │ struct Rectangle {
+   2 │     width: u32,
+   3 │     height: u32,
+   4 │ }
+   5 │ 
+   6 │ fn main() {
+   7 │     let rect1 = Rectangle { width: 30, height: 50 };
+   8 │ 
+   9 │     println!(
+  10 │         "The perimeter of the rectangle is {} pixels.",
+  11 │         perimeter(&rect1)
+  12 │     );
+  13 │     println!(r#"This line contains invalid utf8:  "�����"#;
+  14 │ }
+  15 │ 
+  16 │ fn area(rectangle: &Rectangle) -> u32 {
+  17 │     rectangle.width * rectangle.height
+  18 │ }
+  19 │ 
+  20 │ fn perimeter(rectangle: &Rectangle) -> u32 {
+  21 │     (rectangle.width + rectangle.height) * 2
+  22 │ }
+─────┴──────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,26 @@
+────────────────────────────────────────────────────────────────────────────────
+File: sample.rs
+────────────────────────────────────────────────────────────────────────────────
+struct Rectangle {
+    width: u32,
+    height: u32,
+}
+
+fn main() {
+    let rect1 = Rectangle { width: 30, height: 50 };
+
+    println!(
+        "The perimeter of the rectangle is {} pixels.",
+        perimeter(&rect1)
+    );
+    println!(r#"This line contains invalid utf8:  "�����"#;
+}
+
+fn area(rectangle: &Rectangle) -> u32 {
+    rectangle.width * rectangle.height
+}
+
+fn perimeter(rectangle: &Rectangle) -> u32 {
+    (rectangle.width + rectangle.height) * 2
+}
+────────────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,24 @@
+─────┬──────────────────────────────────────────────────────────────────────────
+   1 │ struct Rectangle {
+   2 │     width: u32,
+   3 │     height: u32,
+   4 │ }
+   5 │ 
+   6 │ fn main() {
+   7 │     let rect1 = Rectangle { width: 30, height: 50 };
+   8 │ 
+   9 │     println!(
+  10 │         "The perimeter of the rectangle is {} pixels.",
+  11 │         perimeter(&rect1)
+  12 │     );
+  13 │     println!(r#"This line contains invalid utf8:  "�����"#;
+  14 │ }
+  15 │ 
+  16 │ fn area(rectangle: &Rectangle) -> u32 {
+  17 │     rectangle.width * rectangle.height
+  18 │ }
+  19 │ 
+  20 │ fn perimeter(rectangle: &Rectangle) -> u32 {
+  21 │     (rectangle.width + rectangle.height) * 2
+  22 │ }
+─────┴──────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,24 @@
+────────────────────────────────────────────────────────────────────────────────
+struct Rectangle {
+    width: u32,
+    height: u32,
+}
+
+fn main() {
+    let rect1 = Rectangle { width: 30, height: 50 };
+
+    println!(
+        "The perimeter of the rectangle is {} pixels.",
+        perimeter(&rect1)
+    );
+    println!(r#"This line contains invalid utf8:  "�����"#;
+}
+
+fn area(rectangle: &Rectangle) -> u32 {
+    rectangle.width * rectangle.height
+}
+
+fn perimeter(rectangle: &Rectangle) -> u32 {
+    (rectangle.width + rectangle.height) * 2
+}
+────────────────────────────────────────────────────────────────────────────────
--- a/Show More
+++ b/Show More