docs: fix example in custom_compose_hooks

example uses embed whereas the keyword should be embedded_pty

Signed-off-by: Guillaume Ranquet <granquet@baylibre.com>

.cargo/config.toml

@@ -1,2 +0,0 @@
-[env]
-PCRE2_SYS_STATIC = "1"

.gitea/Makefile.build

@@ -0,0 +1,37 @@
+# SPDX-License-Identifier: EUPL-1.2
+#
+# Makefile for: "Build and run Tests" workflow, in .gitea/workflows/build.yaml
+
+.POSIX:
+.SUFFIXES:
+CARGO_INCREMENTAL ?= 0
+CARGO_NET_RETRY ?= 10
+CARGO_REGISTRIES_CRATES_IO_PROTOCOL ?= sparse
+RUSTFLAGS ?= -D warnings -W unreachable-pub -W rust-2021-compatibility -C debuginfo=0
+RUSTUP_MAX_RETRIES ?= 10
+RUST_BACKTRACE ?= short
+
+.PHONY: all
+all: cargo-check cargo-test-compiles cargo-test rustdoc-build rustdoc-test
+	@printf "All completed.\n"
+
+.PHONY: cargo-check
+cargo-check:
+	@printf "cargo-check\n"
+	cargo check --all-features --all --tests --examples --benches --bins
+.PHONY: cargo-test-compiles
+cargo-test-compiles:
+	@printf "cargo-test-compiles\n"
+	cargo test --all --no-fail-fast --all-features --no-run --locked
+.PHONY: cargo-test
+cargo-test:
+	@printf "cargo-test\n"
+	cargo nextest run --all --no-fail-fast --all-features --future-incompat-report -E 'not (test(smtp::test::test_smtp))'
+.PHONY: rustdoc-build
+rustdoc-build:
+	@printf "rustdoc-build\n"
+	env DISPLAY= WAYLAND_DISPLAY= make build-rustdoc
+.PHONY: rustdoc-test
+rustdoc-test:
+	@printf "rustdoc-test\n"
+	make test-docs

.gitea/Makefile.lint

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: EUPL-1.2
+#
+# Makefile for: "Run cargo lints" workflow, in .gitea/workflows/lints.yaml
+
+.POSIX:
+.SUFFIXES:
+CARGO_INCREMENTAL ?= 0
+CARGO_NET_RETRY ?= 10
+CARGO_REGISTRIES_CRATES_IO_PROTOCOL ?= sparse
+RUSTFLAGS ?= -D warnings -W unreachable-pub -W rust-2021-compatibility -C debuginfo=0
+RUSTUP_MAX_RETRIES ?= 10
+RUST_BACKTRACE ?= short
+NIGHTLY_EXISTS=`((cargo +nightly 2> /dev/null 1> /dev/null) && echo 0)|| echo 1)`
+GIT=env GIT_CONFIG_GLOBAL="" GIT_CONFIG_SYSTEM="" GIT_CONFIG_NOSYSTEM=1 git
+
+.PHONY: all
+all: cargo-msrv rustfmt clippy cargo-derivefmt-melib cargo-derivefmt-meli cargo-derivefmt-tools
+	@printf "All checks completed.\n"
+
+# Check both melib and meli in the same Make target, because if melib does not
+# satisfy MSRV then meli won't either, since it depends on melib.
+.PHONY: cargo-msrv
+cargo-msrv:
+	@printf "cargo-msrv\n"
+	cargo msrv --output-format json --log-level trace --log-target stdout --path meli verify -- cargo check --all-targets
+	cargo msrv --output-format json --log-level trace --log-target stdout --path melib verify -- cargo check --all-targets
+
+.PHONY: rustfmt
+rustfmt:
+	@printf "rustfmt\n"
+	@((if [ "${NIGHTLY_EXISTS}" -eq 0 ]; then printf "running rustfmt with nightly toolchain\n"; else printf "running rustfmt with active toolchain\n"; fi))
+	@((if [ "${NIGHTLY_EXISTS}" -eq 0 ]; then cargo +nightly fmt --check --all; else cargo fmt --check --all; fi))
+
+.PHONY: clippy
+clippy:
+	@printf "clippy\n"
+	cargo clippy --no-deps --all-features --all --tests --examples --benches --bins
+
+.PHONY: cargo-derivefmt-melib
+cargo-derivefmt-melib:
+	@printf "cargo-derivefmt-melib\n"
+	@printf "Checking that derives are sorted alphabetically...\n"
+	cargo derivefmt --manifest-path ./melib/Cargo.toml
+	@$(GIT) checkout --quiet meli/src/conf/overrides.rs
+	@($(GIT) diff --quiet ./melib && $(GIT) diff --cached --quiet ./melib && printf "All ./melib derives are sorted alphabetically.\n") || (printf "Some derives in the ./melib crate are not sorted alphabetically, see diff:\n"; $(GIT) diff HEAD; exit 1)
+
+.PHONY: cargo-derivefmt-meli
+cargo-derivefmt-meli:
+	@printf "cargo-derivefmt-meli\n"
+	@printf "Checking that derives are sorted alphabetically...\n"
+	cargo derivefmt --manifest-path ./meli/Cargo.toml
+	@$(GIT) checkout --quiet meli/src/conf/overrides.rs
+	@($(GIT) diff --quiet ./meli && $(GIT) diff --cached --quiet ./meli && printf "All ./meli derives are sorted alphabetically.\n") || (printf "Some derives in the ./meli crate are not sorted alphabetically, see diff:\n"; $(GIT) diff HEAD; exit 1)
+
+.PHONY: cargo-derivefmt-tools
+cargo-derivefmt-tools:
+	@printf "cargo-derivefmt-tools\n"
+	@printf "Checking that derives are sorted alphabetically...\n"
+	cargo derivefmt --manifest-path ./tools/Cargo.toml
+	@$(GIT) checkout --quiet meli/src/conf/overrides.rs
+	@($(GIT) diff --quiet ./tools && $(GIT) diff --cached --quiet ./tools && printf "All ./tools derives are sorted alphabetically.\n") || (printf "Some derives in the ./tools crate are not sorted alphabetically, see diff:\n"; $(GIT) diff HEAD; exit 1)

.gitea/Makefile.manifest-lint

@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: EUPL-1.2
+#
+# Makefile for: "Build and run Tests" workflow, in .gitea/workflows/build.yaml
+
+.POSIX:
+.SUFFIXES:
+CARGO_INCREMENTAL ?= 0
+CARGO_NET_RETRY ?= 10
+CARGO_REGISTRIES_CRATES_IO_PROTOCOL ?= sparse
+RUSTFLAGS ?= -D warnings -W unreachable-pub -W rust-2021-compatibility -C debuginfo=0
+RUSTUP_MAX_RETRIES ?= 10
+RUST_BACKTRACE ?= short
+
+.PHONY: all
+all: cargo-sort check-debian-changelog
+	@printf "All checks completed.\n"
+
+.PHONY: cargo-sort
+cargo-sort:
+	@printf "cargo-sort\n"
+	cargo-sort --check --check-format --grouped --order package,bin,lib,dependencies,features,build-dependencies,dev-dependencies,workspace fuzz
+	cargo-sort --check --check-format --grouped --order package,bin,lib,dependencies,features,build-dependencies,dev-dependencies,workspace tools
+	cargo-sort --check --check-format --grouped --order package,bin,lib,dependencies,features,build-dependencies,dev-dependencies,workspace --workspace
+
+.PHONY: check-debian-changelog
+check-debian-changelog:
+	@printf "Check debian/changelog is up-to-date.\n"
+	./scripts/check_debian_changelog.sh

.gitea/check_dco.sh

@@ -0,0 +1,109 @@
+#!/usr/bin/env sh
+# SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+# Lint with shellcheck -s sh -S style check_dco.sh
+
+# Notes:
+# ======
+#
+# - We need to make sure git commands do not read from any existing configs to
+#   prevent surprises like default trailers being added.
+# - we need to pass `--always` to `git-format-patch` to check even empty
+#   commits despite them not being something we would merge. This tripped me up
+#   when debugging this workflow because I tested it with empty commits. My
+#   fault.
+
+export GIT_CONFIG_GLOBAL=""
+export GIT_CONFIG_SYSTEM=""
+export GIT_CONFIG_NOSYSTEM=1
+
+ensure_env_var() {
+  set | grep -q "^${1}=" || (printf "Environment variable %s missing from process environment, exiting.\n" "${1}"; exit "${2}")
+}
+
+ensure_env_var "GITHUB_BASE_REF" 1 || exit $?
+ensure_env_var "GITHUB_HEAD_REF" 2 || exit $?
+
+# contains_correct_signoff() {
+#   author=$(git log --author="$1" --pretty="%an <%ae>" -1)
+#   git format-patch --always --stdout "${1}^..${1}" | git interpret-trailers --parse | grep -q "^Signed-off-by: ${author}"
+# }
+contains_signoff() {
+  GIT_CONFIG_GLOBAL="" git format-patch --always -1 --stdout "${1}" | git interpret-trailers  --parse | grep -q "^Signed-off-by: "
+}
+
+get_commit_sha() {
+  if OUT=$(git rev-parse "${1}"); then
+    printf "%s" "${OUT}"
+    return
+  fi
+  printf "Could not git-rev-parse %s, falling back to HEAD...\n" "${1}" 1>&2
+  git rev-parse HEAD
+}
+
+echo "Debug workflow info:"
+echo "Base ref GITHUB_BASE_REF=${GITHUB_BASE_REF}"
+echo "Head ref GITHUB_HEAD_REF=${GITHUB_HEAD_REF}"
+BASE_REF=$(get_commit_sha "${GITHUB_BASE_REF}")
+HEAD_REF=$(get_commit_sha "${GITHUB_HEAD_REF}")
+echo "Processed base ref BASE_REF=${BASE_REF}"
+echo "Processed head ref HEAD_REF=${HEAD_REF}"
+
+RANGE="${BASE_REF}..${HEAD_REF}"
+echo "Range to examine is RANGE=${RANGE}"
+
+if ! SHA_LIST=$(git rev-list "${RANGE}"); then
+  printf "Could not get commit range %s with git rev-list, bailing out...\n" "${RANGE}"
+  exit 0
+fi
+
+echo "SHA list to examine is SHA_LIST="
+echo "---------------------------------------------------------------------"
+echo "${SHA_LIST}"
+echo "---------------------------------------------------------------------"
+echo ""
+echo "Starting checks..."
+
+output=$(printf "%s" "${SHA_LIST}" | while read -r commit_sha; do
+  contains_signoff_result=""
+
+  contains_signoff "${commit_sha}"; contains_signoff_result="$?"
+  if [ "${contains_signoff_result}" -ne 0 ]; then
+    printf "Commit does not contain Signed-off-by git trailer: %s\n\n" "${commit_sha}"
+    echo "patch was:"
+    echo "---------------------------------------------------------------------"
+    GIT_CONFIG_GLOBAL="" git format-patch --always -1 --stdout "${commit_sha}"
+    echo "---------------------------------------------------------------------"
+    echo "trailers were:"
+    echo "---------------------------------------------------------------------"
+    GIT_CONFIG_GLOBAL="" git format-patch --always -1 --stdout "${commit_sha}" | git interpret-trailers  --parse
+    echo "---------------------------------------------------------------------"
+    echo "commit was:"
+    echo "---------------------------------------------------------------------"
+    git log --no-decorate --pretty=oneline --abbrev-commit -n 1 "${commit_sha}"
+    echo "---------------------------------------------------------------------"
+  fi
+done)
+
+if [ "${output}" = "" ]; then
+  exit 0
+fi
+
+echo "One or more of your commits in this Pull Request lack the Developer Certificate of Origin "
+echo "which is more commonly known as DCO or the \"Signed-off-by: \" trailer line in the "
+echo "git commit message."
+echo "For information, documentation, help, check: https://wiki.linuxfoundation.org/dco"
+
+echo "The reported errors were:"
+printf "%s\n" "${output}" 1>&2
+
+echo ""
+echo "Solution:"
+echo ""
+echo "- end all your commits with a 'Signed-off-by: User <user@localhost>' line, "
+echo "  with your own display name and email address."
+echo "- Make sure the signoff is separated by the commit message body with an empty line."
+echo "- Make sure the signoff is the last line in your commit message."
+echo "- Lastly, make sure the signoff matches your git commit author name and email identity."
+
+exit 1

.gitea/workflows/build.yaml

@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: EUPL-1.2
+name: Build and run Tests
+
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
+  RUSTFLAGS: "-D warnings -W unreachable-pub -W rust-2021-compatibility -C debuginfo=0"
+  RUSTUP_MAX_RETRIES: 10
+  RUST_BACKTRACE: short
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - '.gitea/**'
+      - 'melib/src/**'
+      - 'melib/Cargo.toml'
+      - 'meli/src/**'
+      - 'meli/Cargo.toml'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+
+jobs:
+  test:
+    name: Run tests
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        build: [linux-amd64, linux-arm64]
+        include:
+          - build: linux-amd64
+            arch: amd64
+            os: ubuntu-latest
+            rust: stable
+            target: x86_64-unknown-linux-gnu
+          - build: linux-arm64
+            arch: arm64
+            os: ubuntu-latest-arm64
+            rust: stable
+            target: aarch64-unknown-linux-gnu
+    steps:
+      - uses: actions/checkout@v3
+      - id: os-deps
+        name: install OS dependencies
+        run: |
+          apt-get update
+          apt-get install -y libdbus-1-dev pkg-config mandoc libssl-dev make
+      - name: Cache rustup
+        id: cache-rustup
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.rustup/
+            ~/.cargo/env
+            ~/.cargo/config.toml
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+          key: build-workflow-${{ matrix.build }}-rustup
+      - id: rustup-setup
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
+        name: Install rustup and toolchains
+        shell: bash
+        run: |
+          if ! command -v rustup &>/dev/null; then
+            curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused --location --silent --show-error --fail "https://sh.rustup.rs" | sh -s -- --default-toolchain none -y
+            source "${HOME}/.cargo/env"
+            echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
+            echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
+            rustup toolchain install --profile minimal ${{ matrix.rust }} --target ${{ matrix.target }}
+          fi
+      - name: Source .cargo/env
+        shell: bash
+        run: |
+          source "${HOME}/.cargo/env"
+          echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
+          echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
+      - name: Setup Rust target
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p "${{ env.CARGO_HOME }}"
+          cat << EOF > "${{ env.CARGO_HOME }}"/config.toml
+          [build]
+          target = "${{ matrix.target }}"
+          EOF
+      - name: Add test dependencies
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
+        run: |
+          cargo install --quiet --version 0.9.54 --target "${{ matrix.target }}" cargo-nextest
+      - name: Restore build artifacts cache in target dir
+        id: cache-deps
+        uses: actions/cache/restore@v4
+        with:
+          path: target/
+          key: workflow-${{ matrix.build }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: cargo-check
+        run: |
+          make -f ./.gitea/Makefile.build cargo-check
+      - if: steps.cache-deps.outputs.cache-hit != 'true'
+        name: Save build artifacts in target dir
+        id: save-cache-deps
+        uses: actions/cache/save@v4
+        with:
+          path: target/
+          key: workflow-${{ matrix.build }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: cargo-test-compiles
+        if: success() || failure()
+        run: |
+          make -f ./.gitea/Makefile.build cargo-test-compiles
+      - name: cargo-test
+        run: |
+          make -f ./.gitea/Makefile.build cargo-test
+      - name: rustdoc build
+        if: success() || failure()
+        run: |
+          make -f ./.gitea/Makefile.build rustdoc-build
+      - name: rustdoc tests
+        if: success() || failure()
+        run: |
+          make -f ./.gitea/Makefile.build rustdoc-test

.gitea/workflows/build_artifacts.yaml

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: EUPL-1.2
-name: Build release binary
+name: Build release binaries
 
 env:
   CARGO_INCREMENTAL: 0
@@ -17,18 +17,25 @@ on:
 
 jobs:
   build:
-    name: Build on ${{ matrix.build }}
+    name: Build release binary
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        build: [linux-amd64, ]
+        build: [linux-amd64, linux-arm64]
         include:
           - build: linux-amd64
+            arch: amd64
             os: ubuntu-latest
-            rust: 1.79.0
+            rust: stable
             artifact_name: 'meli-linux-amd64'
             target: x86_64-unknown-linux-gnu
+          - build: linux-arm64
+            arch: arm64
+            os: ubuntu-latest-arm64
+            rust: stable
+            artifact_name: 'meli-linux-arm64'
+            target: aarch64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v3
       - id: os-deps
@@ -36,13 +43,6 @@ jobs:
         run: |
           apt-get update
           apt-get install -y libdbus-1-dev pkg-config mandoc libssl-dev
-          #- id: cache-rustup
-          #  name: Cache Rust toolchain
-          #  uses: https://github.com/actions/cache@v3
-          #  with:
-          #    path: ~/.rustup
-          #    key: toolchain-${{ matrix.os }}-${{ matrix.rust }}
-          #- if: ${{ steps.cache-rustup.outputs.cache-hit != 'true' }}
       - id: rustup-setup
         name: Install rustup and toolchains
         shell: bash
@@ -51,22 +51,9 @@ jobs:
             curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused --location --silent --show-error --fail "https://sh.rustup.rs" | sh -s -- --default-toolchain none -y
             source "${HOME}/.cargo/env"
             echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
+            echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
             rustup toolchain install --profile minimal ${{ matrix.rust }} --target ${{ matrix.target }}
           fi
-      - name: Configure cargo data directory
-        # After this point, all cargo registry and crate data is stored in
-        # $GITHUB_WORKSPACE/.cargo_home. This allows us to cache only the files
-        # that are needed during the build process. Additionally, this works
-        # around a bug in the 'cache' action that causes directories outside of
-        # the workspace dir to be saved/restored incorrectly.
-        run: echo "CARGO_HOME=$(pwd)/.cargo_home" >> $GITHUB_ENV
-          #- id: cache-cargo
-          #  name: Cache cargo configuration and installations
-          #  uses: https://github.com/actions/cache@v3
-          #  with:
-          #    path: ${{ env.CARGO_HOME }}
-          #    key: cargo-${{ matrix.os }}-${{ matrix.rust }}
-          #- if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }} && matrix.target
       - name: Setup Rust target
         run: |
           mkdir -p "${{ env.CARGO_HOME }}"
@@ -76,15 +63,17 @@ jobs:
           EOF
       - name: Build binary
         run: |
+          VERSION=$(grep -m1 version meli/Cargo.toml | head -n1 | cut -d'"' -f 2 | head -n1)
+          echo "VERSION=${VERSION}" >> $GITHUB_ENV
           make
           mkdir artifacts
           mv target/*/release/* target/ || true
           mv target/release/* target/ || true
-          mv target/meli  artifacts/
+          mv target/meli  artifacts/meli-${VERSION}-${{ matrix.target }}
       - name: Upload Artifacts
         uses: actions/upload-artifact@v3
         with:
-          name: ${{ matrix.artifact_name }}
-          path: artifacts/meli
+          name: ${{ matrix.artifact_name }}-${{ env.VERSION }}
+          path: artifacts/meli-${{ env.VERSION }}-${{ matrix.target }}
           if-no-files-found: error
           retention-days: 30

.gitea/workflows/build_debian_package.yaml

@@ -16,20 +16,26 @@ on:
       - v*
 
 jobs:
-  build:
-    name: Package for debian on ${{ matrix.arch }}
+  build-debian:
+    name: Create debian package
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        build: [linux-amd64, ]
+        build: [linux-amd64, linux-arm64]
         include:
           - build: linux-amd64
             arch: amd64
             os: ubuntu-latest
-            rust: 1.79.0
+            rust: stable
             artifact_name: 'linux-amd64'
             target: x86_64-unknown-linux-gnu
+          - build: linux-arm64
+            arch: arm64
+            os: ubuntu-latest-arm64
+            rust: stable
+            artifact_name: 'linux-arm64'
+            target: aarch64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v3
       - id: os-deps

.gitea/workflows/check_dco.yaml

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: EUPL-1.2
+name: Verify DCO
+
+on:
+  pull_request:
+
+jobs:
+  test:
+    name: Verify DCO signoff on commit messages
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        build: [linux-amd64, ]
+        include:
+          - build: linux-amd64
+            os: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - id: check-dco
+        shell: sh
+        name: Check that commit messages end with a Signed-off-by git trailer
+        run: |
+          env GITHUB_BASE_REF="origin/${{env.GITHUB_BASE_REF}}" GITHUB_HEAD_REF="origin/${{env.GITHUB_HEAD_REF}}" sh ./.gitea/check_dco.sh

.gitea/workflows/lints.yaml

@@ -22,8 +22,8 @@ on:
       - 'Cargo.lock'
 
 jobs:
-  test:
-    name: Lint on ${{ matrix.build }}
+  lints:
+    name: Run lints
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -32,7 +32,7 @@ jobs:
         include:
           - build: linux-amd64
             os: ubuntu-latest
-            rust: 1.79.0
+            rust: stable
             target: x86_64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v3
@@ -41,14 +41,25 @@ jobs:
         run: |
           apt-get update
           apt-get install -y libdbus-1-dev pkg-config mandoc libssl-dev
-          #- id: cache-rustup
-          #  name: Cache Rust toolchain
-          #  uses: https://github.com/actions/cache@v3
-          #  with:
-          #    path: ~/.rustup
-          #    key: toolchain-${{ matrix.os }}-${{ matrix.rust }}
-          #- if: ${{ steps.cache-rustup.outputs.cache-hit != 'true' }}
+      - name: Find meli MSRV from meli/Cargo.toml.
+        run: |
+          echo MELI_MSRV=$(grep -m1 rust-version meli/Cargo.toml | head -n1 | cut -d'"' -f 2 | head -n1) >> $GITHUB_ENV
+          printf "Rust MSRV is %s\n" $(grep -m1 rust-version meli/Cargo.toml | head -n1 | cut -d'"' -f 2 | head -n1)
+      - name: Cache rustup
+        id: cache-rustup
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.rustup/
+            ~/.cargo/env
+            ~/.cargo/config.toml
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+          key: lints-workflow-${{ matrix.build }}-rustup
       - id: rustup-setup
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
         name: Install Rustup and toolchains
         shell: bash
         run: |
@@ -56,56 +67,74 @@ jobs:
             curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused --location --silent --show-error --fail "https://sh.rustup.rs" | sh -s -- --default-toolchain none -y
             source "${HOME}/.cargo/env"
             echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
-            rustup toolchain install --profile minimal --component clippy,rustfmt --target ${{ matrix.target }} -- "${{ matrix.rust }}"
+            echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
+            rustup toolchain install --profile minimal --component "rustfmt" --target "${{ matrix.target }}" -- "${{ env.MELI_MSRV }}"
+            rustup component add rustfmt --toolchain ${{ env.MELI_MSRV }}-${{ matrix.target }}
+            rustup toolchain install --profile minimal --component clippy,rustfmt --target "${{ matrix.target }}" -- "${{ matrix.rust }}"
+            rustup component add rustfmt --toolchain ${{ matrix.rust }}-${{ matrix.target }}
             rustup default ${{ matrix.rust }}
           fi
-      - name: Configure cargo data directory
-        # After this point, all cargo registry and crate data is stored in
-        # $GITHUB_WORKSPACE/.cargo_home. This allows us to cache only the files
-        # that are needed during the build process. Additionally, this works
-        # around a bug in the 'cache' action that causes directories outside of
-        # the workspace dir to be saved/restored incorrectly.
-        run: echo "CARGO_HOME=$(pwd)/.cargo_home" >> $GITHUB_ENV
-          #- id: cache-cargo
-          #  name: Cache cargo configuration and installations
-          #  uses: https://github.com/actions/cache@v3
-          #  with:
-          #    path: ${{ env.CARGO_HOME }}
-          #    key: cargo-${{ matrix.os }}-${{ matrix.rust }}
-          #- if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }} && matrix.target
+      - name: Source .cargo/env
+        shell: bash
+        run: |
+          source "${HOME}/.cargo/env"
+          echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
+          echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
       - name: Setup Rust target
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
         run: |
           mkdir -p "${{ env.CARGO_HOME }}"
           cat << EOF > "${{ env.CARGO_HOME }}"/config.toml
           [build]
           target = "${{ matrix.target }}"
           EOF
-      - if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }} && matrix.target
-        name: Add lint dependencies
+      - name: Add lint dependencies
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
+        shell: bash
         run: |
-          cargo install --quiet --version 1.0.9 --target "${{ matrix.target }}" cargo-sort
-          RUSTFLAGS="" cargo install --locked --target "${{ matrix.target }}" --git https://github.com/dcchut/cargo-derivefmt --rev 2ff93de7fb418180458dd1ba27e5655607c23ab6 --bin cargo-derivefmt
-      - name: rustfmt
-        if: success() || failure()
-        run: |
-          cargo fmt --check --all
+          cargo install --version 0.15.1 --target "${{ matrix.target }}" cargo-msrv
+          # "This package is currently implemented using rust-analyzer internals, so cannot be published on crates.io."
+          RUSTFLAGS="" cargo install --locked --target "${{ matrix.target }}" --git https://github.com/dcchut/cargo-derivefmt --rev 95da8eee343de4adb25850893873b979258aed7f --bin cargo-derivefmt
+      - name: Restore build artifacts cache in target dir
+        id: cache-deps
+        uses: actions/cache/restore@v4
+        with:
+          path: target/
+          key: workflow-${{ matrix.build }}-cargo-${{ hashFiles('**/Cargo.lock') }}
       - name: clippy
         if: success() || failure()
         run: |
-          cargo clippy --no-deps --all-features --all --tests --examples --benches --bins
+          source "${HOME}/.cargo/env"
+          make -f .gitea/Makefile.lint clippy
+      - if: steps.cache-deps.outputs.cache-hit != 'true'
+        name: Save build artifacts in target dir
+        id: save-cache-deps
+        uses: actions/cache/save@v4
+        with:
+          path: target/
+          key: workflow-${{ matrix.build }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: cargo-msrv verify melib MSRV
+        if: success() || failure()
+        run: |
+          source "${HOME}/.cargo/env"
+          make -f ./.gitea/Makefile.lint cargo-msrv
+      - name: rustfmt
+        if: success() || failure()
+        run: |
+          source "${HOME}/.cargo/env"
+          make -f .gitea/Makefile.lint rustfmt
       - name: cargo-derivefmt melib
         if: success() || failure()
         run: |
-          cargo derivefmt --manifest-path ./melib/Cargo.toml
+          source "${HOME}/.cargo/env"
+          make -f .gitea/Makefile.lint cargo-derivefmt-melib
       - name: cargo-derivefmt meli
         if: success() || failure()
         run: |
-          cargo derivefmt --manifest-path ./meli/Cargo.toml
-      - name: cargo-derivefmt fuzz
-        if: success() || failure()
-        run: |
-          cargo derivefmt --manifest-path ./fuzz/Cargo.toml
+          source "${HOME}/.cargo/env"
+          make -f .gitea/Makefile.lint cargo-derivefmt-meli
       - name: cargo-derivefmt tools
         if: success() || failure()
         run: |
-          cargo derivefmt --manifest-path ./tools/Cargo.toml
+          source "${HOME}/.cargo/env"
+          make -f .gitea/Makefile.lint cargo-derivefmt-tools

.gitea/workflows/manifest_lints.yaml

@@ -24,7 +24,7 @@ on:
 
 jobs:
   manifest_lint:
-    name: Lint Cargo manifests on ${{ matrix.build }}
+    name: Run Cargo manifest etc lints
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -33,7 +33,7 @@ jobs:
         include:
           - build: linux-amd64
             os: ubuntu-latest
-            rust: 1.79.0
+            rust: stable
             target: x86_64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v3
@@ -42,8 +42,19 @@ jobs:
         run: |
           apt-get update
           apt-get install -y mandoc
-      - name: Find meli MSRV from meli/Cargo.toml.
-        run: echo MELI_MSRV=$(grep -m1 rust-version meli/Cargo.toml | head -n1 | cut -d'"' -f 2 | head -n1) >> $GITHUB_ENV
+      - name: Cache rustup
+        id: cache-rustup
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.rustup/
+            ~/.cargo/env
+            ~/.cargo/config.toml
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+          key: manifest_lints-workflow-${{ matrix.build }}-rustup
       - id: rustup-setup
         name: Install Rustup and toolchains
         shell: bash
@@ -53,39 +64,35 @@ jobs:
             source "${HOME}/.cargo/env"
             echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
             echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
-            rustup toolchain install --profile minimal --component "rustfmt" --target "${{ matrix.target }}" -- "${{ env.MELI_MSRV }}"
-            rustup component add rustfmt --toolchain ${{ env.MELI_MSRV }}-${{ matrix.target }}
             rustup toolchain install --profile minimal --component "rustfmt" --target "${{ matrix.target }}" -- "${{ matrix.rust }}"
             rustup component add rustfmt --toolchain ${{ matrix.rust }}-${{ matrix.target }}
             rustup default ${{ matrix.rust }}
           fi
+      - name: Source .cargo/env
+        shell: bash
+        run: |
+          source "${HOME}/.cargo/env"
+          echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
+          echo "CARGO_HOME=${CARGO_HOME:-$HOME/.cargo}" >> $GITHUB_ENV
       - name: Setup Rust target
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
         run: |
           mkdir -p "${{ env.CARGO_HOME }}"
           cat << EOF > "${{ env.CARGO_HOME }}"/config.toml
           [build]
           target = "${{ matrix.target }}"
           EOF
-      - if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }} && matrix.target
-        name: Add manifest lint dependencies
+      - name: Add manifest lint dependencies
+        if: steps.cache-rustup.outputs.cache-hit != 'true'
         run: |
           source "${HOME}/.cargo/env"
           cargo install --quiet --version 1.0.9 --target "${{ matrix.target }}" cargo-sort
-          cargo install --quiet --version 0.15.1 --target "${{ matrix.target }}" cargo-msrv
-      - name: cargo-msrv verify melib MSRV
-        if: success() || failure()
-        run: |
-          source "${HOME}/.cargo/env"
-          cargo-msrv --output-format json --log-level trace --log-target stdout --path meli verify -- cargo check --all-targets
-          cargo-msrv --output-format json --log-level trace --log-target stdout --path melib verify -- cargo check --all-targets
       - name: cargo-sort
         if: success() || failure()
         run: |
           source "${HOME}/.cargo/env"
-          cargo-sort --check --check-format --grouped --order package,bin,lib,dependencies,features,build-dependencies,dev-dependencies,workspace fuzz
-          cargo-sort --check --check-format --grouped --order package,bin,lib,dependencies,features,build-dependencies,dev-dependencies,workspace tools
-          cargo-sort --check --check-format --grouped --order package,bin,lib,dependencies,features,build-dependencies,dev-dependencies,workspace --workspace
+          make -f ./.gitea/Makefile.manifest-lint cargo-sort
       - name: Check debian/changelog is up-to-date.
         if: success() || failure()
         run: |
-          ./scripts/check_debian_changelog.sh
+          make -f ./.gitea/Makefile.manifest-lint check-debian-changelog

.gitea/workflows/test.yaml

@@ -1,103 +0,0 @@
-# SPDX-License-Identifier: EUPL-1.2
-name: Run Tests
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-  RUSTFLAGS: "-D warnings -W unreachable-pub -W rust-2021-compatibility -C debuginfo=0"
-  RUSTUP_MAX_RETRIES: 10
-  RUST_BACKTRACE: short
-
-on:
-  workflow_dispatch:
-  pull_request:
-    paths:
-      - '.gitea/**'
-      - 'melib/src/**'
-      - 'melib/Cargo.toml'
-      - 'meli/src/**'
-      - 'meli/Cargo.toml'
-      - 'Cargo.toml'
-      - 'Cargo.lock'
-
-jobs:
-  test:
-    name: Test on ${{ matrix.build }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        build: [linux-amd64, ]
-        include:
-          - build: linux-amd64
-            os: ubuntu-latest
-            rust: 1.79.0
-            target: x86_64-unknown-linux-gnu
-    steps:
-      - uses: actions/checkout@v3
-      - id: os-deps
-        name: install OS dependencies
-        run: |
-          apt-get update
-          apt-get install -y libdbus-1-dev pkg-config mandoc libssl-dev make
-          #- id: cache-rustup
-          #  name: Cache Rust toolchain
-          #  uses: https://github.com/actions/cache@v3
-          #  with:
-          #    path: ~/.rustup
-          #    key: toolchain-${{ matrix.os }}-${{ matrix.rust }}
-          #- if: ${{ steps.cache-rustup.outputs.cache-hit != 'true' }}
-      - id: rustup-setup
-        name: Install rustup and toolchains
-        shell: bash
-        run: |
-          if ! command -v rustup &>/dev/null; then
-            curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused --location --silent --show-error --fail "https://sh.rustup.rs" | sh -s -- --default-toolchain none -y
-            source "${HOME}/.cargo/env"
-            echo "${CARGO_HOME:-$HOME/.cargo}/bin" >> $GITHUB_PATH
-            rustup toolchain install --profile minimal ${{ matrix.rust }} --target ${{ matrix.target }}
-          fi
-      - name: Configure cargo data directory
-        # After this point, all cargo registry and crate data is stored in
-        # $GITHUB_WORKSPACE/.cargo_home. This allows us to cache only the files
-        # that are needed during the build process. Additionally, this works
-        # around a bug in the 'cache' action that causes directories outside of
-        # the workspace dir to be saved/restored incorrectly.
-        run: echo "CARGO_HOME=$(pwd)/.cargo_home" >> $GITHUB_ENV
-          #- id: cache-cargo
-          #  name: Cache cargo configuration and installations
-          #  uses: https://github.com/actions/cache@v3
-          #  with:
-          #    path: ${{ env.CARGO_HOME }}
-          #    key: cargo-${{ matrix.os }}-${{ matrix.rust }}
-          #- if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }} && matrix.target
-      - name: Setup Rust target
-        run: |
-          mkdir -p "${{ env.CARGO_HOME }}"
-          cat << EOF > "${{ env.CARGO_HOME }}"/config.toml
-          [build]
-          target = "${{ matrix.target }}"
-          EOF
-      - if: ${{ steps.cache-cargo.outputs.cache-hit != 'true' }} && matrix.target
-        name: Add test dependencies
-        run: |
-          cargo install --quiet --version 0.9.54 --target "${{ matrix.target }}" cargo-nextest
-      - name: cargo-check
-        run: |
-          cargo check --all-features --all --tests --examples --benches --bins
-      - name: Compile
-        if: success() || failure()
-        run: cargo test --all --no-fail-fast --all-features --no-run --locked
-      - name: cargo test
-        run: |
-          cargo nextest run --all --no-fail-fast --all-features --future-incompat-report -E 'not (test(smtp::test::test_smtp))'
-          #cargo test --all --no-fail-fast --all-features -- --nocapture --quiet
-      - name: rustdoc build
-        if: success() || failure() # always run even if other steps fail, except when cancelled <https://stackoverflow.com/questions/58858429/how-to-run-a-github-actions-step-even-if-the-previous-step-fails-while-still-f>
-        run: |
-          make build-rustdoc
-      - name: rustdoc tests
-        if: success() || failure()
-        run: |
-          make test-docs

.mailmap

@@ -0,0 +1,8 @@
+# Copyright (c) 2024 Manos Pitsidianakis <manos@pitsidianak.is>
+# Licensed under the EUPL-1.2-or-later.
+#
+# You may obtain a copy of the Licence at:
+# https://joinup.ec.europa.eu/software/page/eupl
+#
+# SPDX-License-Identifier: EUPL-1.2
+Manos Pitsidianakis <manos@pitsidianak.is> <el13635@mail.ntua.gr>

BUILD.md

@@ -20,7 +20,13 @@ You can build and run `meli` with one command: `cargo run --release`.
 
 ## Build features
 
-Some functionality is held behind "feature gates", or compile-time flags. The following list explains each feature's purpose:
+Some functionality is held behind "feature gates", or compile-time flags.
+
+Cargo features for `meli` are documented in its [`README.md`](./meli/README.md) file.
+
+Cargo features for `melib` are documented in its [`README.md`](./melib/README.md) file.
+
+The following list explains each feature's purpose:
 
 - `gpgme` enables GPG support via `libgpgme` (on by default)
 - `dbus-notifications` enables showing notifications using `dbus` (on by default)
@@ -28,15 +34,8 @@ Some functionality is held behind "feature gates", or compile-time flags. The fo
 - `jmap` provides support for connecting to a jmap server and use it as a mail backend (on by default)
 - `sqlite3` provides support for builting fast search indexes in local sqlite3 databases (on by default)
 - `cli-docs` includes the manpage documentation compiled by either `mandoc` or `man` binary to plain text in `meli`'s command line. Embedded documentation can be viewed with the subcommand `meli man [PAGE]` (on by default).
-- `regexp` provides experimental support for theming some e-mail fields based
-  on regular expressions.
-  It uses the `pcre2` library.
-  Since it's actual use in the code is very limited, it is not recommended to use this (off by default).
 - `static` and `*-static` bundle C libraries in dependencies so that you don't need them installed in your system (on by default).
 
-Though not a feature, the presence of the environment variable `UNICODE_REGENERATE_TABLES` in compile-time of the `melib` crate will force the regeneration of unicode tables.
-Otherwise the tables are included with the source code, and there's no real reason to regenerate them unless you intend to modify the code or update to a new Unicode version.
-
 ## Build Debian package (*deb*)
 
 Building with Debian's packaged cargo might require the installation of these two packages: `librust-openssl-sys-dev librust-libdbus-sys-dev`
@@ -56,6 +55,22 @@ To use the optional gpg feature, you must have `libgpgme` installed in your syst
 In Debian-like systems, install the `libgpgme11` package.
 `meli` detects the library's presence on runtime.
 
+## Building and running on Android with `termux`
+
+This is not a supported or stable setup so caveat emptor.
+
+At the time of writing this, Android is not a stable Rust target.
+The packaged Rust from `termux` will be used.
+
+The following steps should suffice to build and run `meli` on `termux`:
+
+```console
+$ pkg install rust perl make m4 man
+$ cargo install meli # ensure .cargo/bin is in your PATH
+```
+
+Exporting `EDITOR` and `PAGER` might be useful.
+
 ## Development
 
 Development builds can be built and/or run with

Makefile

@@ -25,7 +25,7 @@ CARGO_ARGS ?=
 RUSTFLAGS ?= -D warnings -W unreachable-pub -W rust-2021-compatibility
 CARGO_SORT_BIN = cargo-sort
 CARGO_HACK_BIN = cargo-hack
-PRINTF = /usr/bin/printf
+PRINTF := `command -v printf`
 
 # Options
 PREFIX ?= /usr/local
@@ -55,7 +55,8 @@ YELLOW ?= `[ -z $${NO_COLOR+x} ] && ([ -z $${TERM} ] && echo "" || tput setaf 3)
 
 .PHONY: meli
 meli: check-deps
-	${CARGO_BIN} build ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --release --bin meli
+	@echo ${CARGO_BIN} build ${CARGO_ARGS} ${CARGO_COLOR}--target-dir=\""${CARGO_TARGET_DIR}"\" ${FEATURES} --release --bin meli
+	@${CARGO_BIN} build ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --release --bin meli
 
 .PHONY: help
 help:
@@ -75,7 +76,8 @@ help:
 	@echo " - ${BOLD}deb-dist${ANSI_RESET} (builds debian package in the parent directory)"
 	@echo " - ${BOLD}distclean${ANSI_RESET} (cleans distribution build artifacts)"
 	@echo " - ${BOLD}build-rustdoc${ANSI_RESET} (builds rustdoc documentation for all packages in \$$CARGO_TARGET_DIR)"
-	@echo "\nENVIRONMENT variables of interest:"
+	@echo ""
+	@echo "ENVIRONMENT variables of interest:"
 	@$(PRINTF) "* MELI_FEATURES "
 	@[ -z $${MELI_FEATURES+x} ] && echo "unset" || echo "= ${UNDERLINE}"$${MELI_FEATURES}${ANSI_RESET}
 	@$(PRINTF) "* PREFIX "
@@ -89,37 +91,46 @@ help:
 	@$(PRINTF) "* NO_MAN "
 	@[ $${NO_MAN+x} ] && echo "set" || echo "unset"
 	@$(PRINTF) "* NO_COLOR "
-	@[ $${NO_COLOR+x} ] && echo "set" || echo "unset"
+	@([ $${NO_COLOR+x} ] && [ "$${NO_COLOR}" != "" ] && echo "set") || echo "unset"
 	@echo "* CARGO_BIN = ${UNDERLINE}${CARGO_BIN}${ANSI_RESET}"
 	@$(PRINTF) "* CARGO_ARGS "
-	@[ -z $${CARGO_ARGS+x} ] && echo "unset" || echo "= ${UNDERLINE}"$${CARGO_ARGS}${ANSI_RESET}
+	@([ -z "${CARGO_ARGS}" ] && echo "unset") || echo = ${UNDERLINE}${CARGO_ARGS}${ANSI_RESET}
+	@$(PRINTF) "* RUSTFLAGS = "
+	@([ -z "${RUSTFLAGS}" ] && echo "unset") || echo = ${UNDERLINE}${RUSTFLAGS}${ANSI_RESET}
 	@$(PRINTF) "* AUTHOR (for deb-dist) "
 	@[ -z $${AUTHOR+x} ] && echo "unset" || echo "= ${UNDERLINE}"$${AUTHOR}${ANSI_RESET}
 	@echo "* MIN_RUSTC = ${UNDERLINE}${MIN_RUSTC}${ANSI_RESET}"
 	@echo "* VERSION = ${UNDERLINE}${VERSION}${ANSI_RESET}"
 	@echo "* GIT_COMMIT = ${UNDERLINE}${GIT_COMMIT}${ANSI_RESET}"
-	@#@echo "* CARGO_COLOR = ${CARGO_COLOR}"
+	@echo "* CARGO_TARGET_DIR = ${CARGO_TARGET_DIR}"
+	@echo ""
+	@echo "Built-in/binary utilities"
+	@echo "* PRINTF = ${UNDERLINE}${PRINTF}${ANSI_RESET}"
 
 .PHONY: check
 check: check-tagrefs
-	RUSTFLAGS='${RUSTFLAGS}' ${CARGO_BIN} check ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --all --tests --examples --benches --bins
+	@echo RUSTFLAGS=\"'${RUSTFLAGS}'\" ${CARGO_BIN} check ${CARGO_ARGS} ${CARGO_COLOR}--target-dir=\""${CARGO_TARGET_DIR}"\" ${FEATURES} --all --tests --examples --benches --bins
+	@RUSTFLAGS='${RUSTFLAGS}' ${CARGO_BIN} check ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --all --tests --examples --benches --bins
 
 .PHONY: fmt
 fmt:
 	$(CARGO_BIN) +nightly fmt --all || $(CARGO_BIN) fmt --all
-	@OUT=$$($(CARGO_SORT_BIN) -w 2>&1) || $(PRINTF) "WARN: %s cargo-sort failed or binary not found in PATH.\n" "$$OUT"
+	@OUT=$$($(CARGO_SORT_BIN) melib -w 2>&1 && $(CARGO_SORT_BIN) meli -w 2>&1) || $(PRINTF) "WARN: %s cargo-sort failed or binary not found in PATH.\n" "$$OUT"
 
 .PHONY: lint
 lint:
-	RUSTFLAGS='${RUSTFLAGS}' $(CARGO_BIN) clippy --no-deps ${FEATURES} --all --tests --examples --benches --bins
+	@echo RUSTFLAGS=\"'${RUSTFLAGS}'\" $(CARGO_BIN) clippy --no-deps ${FEATURES} --all --tests --examples --benches --bins
+	@RUSTFLAGS='${RUSTFLAGS}' $(CARGO_BIN) clippy --no-deps ${FEATURES} --all --tests --examples --benches --bins
 
 .PHONY: test
 test: test-docs
-	RUSTFLAGS='${RUSTFLAGS}' ${CARGO_BIN} test ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --all --tests --examples --benches --bins
+	@echo RUSTFLAGS=\"'${RUSTFLAGS}'\" ${CARGO_BIN} test ${CARGO_ARGS} ${CARGO_COLOR}--target-dir=\""${CARGO_TARGET_DIR}"\" ${FEATURES} --all --tests --examples --benches --bins
+	@RUSTFLAGS='${RUSTFLAGS}' ${CARGO_BIN} test ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --all --tests --examples --benches --bins
 
 .PHONY: test-docs
 test-docs:
-	RUSTFLAGS='${RUSTFLAGS}' ${CARGO_BIN} test ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --all --doc
+	@echo RUSTFLAGS=\"'${RUSTFLAGS}'\" ${CARGO_BIN} test ${CARGO_ARGS} ${CARGO_COLOR}--target-dir=\""${CARGO_TARGET_DIR}"\" ${FEATURES} --all --doc
+	@RUSTFLAGS='${RUSTFLAGS}' ${CARGO_BIN} test ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" ${FEATURES} --all --doc
 
 .PHONY: test-feature-permutations
 test-feature-permutations:
@@ -204,7 +215,8 @@ deb-dist:
 
 .PHONY: build-rustdoc
 build-rustdoc:
-	RUSTDOCFLAGS="--crate-version ${VERSION}_${GIT_COMMIT}_${DATE}" ${CARGO_BIN} doc ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" --all-features --no-deps --workspace --document-private-items --open
+	@echo RUSTDOCFLAGS=\""--crate-version ${VERSION}_${GIT_COMMIT}_${DATE}"\" ${CARGO_BIN} doc ${CARGO_ARGS} ${CARGO_COLOR}--target-dir=\""${CARGO_TARGET_DIR}"\" --all-features --no-deps --workspace --document-private-items --open
+	@RUSTDOCFLAGS="--crate-version ${VERSION}_${GIT_COMMIT}_${DATE}" ${CARGO_BIN} doc ${CARGO_ARGS} ${CARGO_COLOR}--target-dir="${CARGO_TARGET_DIR}" --all-features --no-deps --workspace --document-private-items --open
 
 .PHONY: check-tagrefs
 check-tagrefs:

README.md

@@ -2,14 +2,16 @@
 
 **BSD/Linux/macos terminal email client with support for multiple accounts and Maildir / mbox / notmuch / IMAP / JMAP / NNTP (Usenet).**
 
-Try an [old online interactive web demo](https://meli-email.org/wasm2.html "online interactive web demo") powered by WebAssembly!
+Try an [old, outdated but online and interactive web demo](https://meli-email.org/wasm2.html "online interactive web demo") powered by WebAssembly!
 
-* `#meli` on OFTC IRC | [mailing lists](https://lists.meli-email.org/)
-* Repository:
-  - Main <https://git.meli-email.org/meli/meli> Report bugs and/or feature requests in [meli's issue tracker](https://git.meli-email.org/meli/meli/issues "meli gitea issue tracker")
-  - Official mirror <https://codeberg.org/meli/meli>
-  - Official mirror <https://github.com/meli/meli>
-  - Official mirror <https://ayllu-forge.org/meli/meli>
+* `#meli` on OFTC IRC
+* [Mailing lists](https://lists.meli-email.org/)
+* Main repository <https://git.meli-email.org/meli/meli> Report bugs and/or feature requests in [meli's issue tracker](https://git.meli-email.org/meli/meli/issues "meli gitea issue tracker")<details><summary>Official git mirrors</summary>
+  - <https://codeberg.org/meli/meli>
+  - <https://github.com/meli/meli>
+  - <https://ayllu-forge.org/meli/meli>
+  - <https://gitlab.com/meli-project/meli>
+  </details>
 
 **Table of contents**:
 
@@ -24,23 +26,55 @@ Try an [old online interactive web demo](https://meli-email.org/wasm2.html "onli
 
 ## Install
 
-- `cargo install meli` or `cargo install --git https://git.meli-email.org/meli/meli.git meli`
-- [pkgsrc](https://pkgsrc.se/mail/meli)
-- [openbsd ports](https://openports.pl/path/mail/meli)
-- [Pre-built debian package, static binaries](https://github.com/meli/meli/releases/ "github releases for meli")
-- [Nix](https://search.nixos.org/packages?show=meli&query=meli&from=0&size=30&sort=relevance&channel=unstable#disabled "nixos package search results for 'meli'")
-- [MacPorts](https://ports.macports.org/port/meli/)
+<a href="https://repology.org/project/meli/versions">
+  <img src="https://repology.org/badge/vertical-allrepos/meli.svg" alt="Packaging status table by repology.org" align="right">
+</a>
+
+- `cargo install meli` or `cargo install --git https://git.meli-email.org/meli/meli.git meli` [crates.io link](https://crates.io/crates/meli)
+- Official Debian packages <https://packages.debian.org/trixie/meli>
+- AUR (archlinux) <https://aur.archlinux.org/packages/meli>
+- NetBSD with pkgsrc <https://pkgsrc.se/mail/meli>
+- OpenBSD ports <https://openports.pl/path/mail/meli>
+- macOS with MacPorts <https://ports.macports.org/port/meli/>
+- Nix with Nixpkgs <https://search.nixos.org/packages?query=meli>
+- [Pre-built debian package, static binaries](https://github.com/meli/meli/releases/ "github releases for meli") for <code>amd64</code>, <code>arm64</code> architectures
 
 ## Build
 
-Run `cargo build --release --bin meli` or `make`.
+Run `make` or `cargo build --release --bin meli`.
 
 For detailed building instructions, see [`BUILD.md`](./BUILD.md)
 
-## Quick start
+### Cargo Compile-time Features
 
-<table>
-<tr><td>
+`meli` supports opting in and out of features at compile time with cargo features.
+
+The contents of the `default` feature are:
+
+```toml
+default = ["sqlite3", "notmuch", "smtp", "dbus-notifications", "gpgme", "cli-docs", "jmap", "static"]
+```
+
+A list of all the features and a description for each follows:
+
+| Feature flag                                                  | Dependencies                                                                                 | Notes                                                                                                                                                                                             |
+|---------------------------------------------------------------|----------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| <a name="notmuch-feature">`notmuch`</a>                       | `maildir` feature                                                                            | Provides the *notmuch* backend                                                                                                                                                                    |
+| <a name="jmap-feature">`jmap`</a>                             | `http` feature, `url` crate with `serde` feature                                             | Provides the *JMAP* backend                                                                                                                                                                       |
+| <a name="smtp-feature">`smtp`</a>                             | `tls` feature                                                                                | Integrated async *SMTP* client                                                                                                                                                                    |
+| <a name="sqlite3-feature">`sqlite3`</a>                       | `rusqlite` crate with `bundled-full` feature                                                 | Used in caches                                                                                                                                                                                    |
+| <a name="sqlite3-static-feature">`sqlite3-static`</a>         | `rusqlite` crate with `bundled-full` feature                                                 | Same as `sqlite3` feature but provided for consistency and in case `sqlite3` feature stops bundling libsqlite3 statically in the future.                                                          |
+| <a name="smtp-trace-feature">`smtp-trace`</a>                 | `smtp` feature                                                                               | Connection trace logs on the `trace` logging level                                                                                                                                                |
+| <a name="gpgme-feature">`gpgme`</a>                           |                                                                                              | *GPG* use by dynamically loading `libgpgme.so`                                                                                                                                                    |
+| <a name="tls-static-feature">`tls-static`</a>                 | `native-tls` crate with `vendored` feature                                                   | Links with `OpenSSL` statically where it's used                                                                                                                                                   |
+| <a name="http-static-feature">`http-static`</a>               | `isahc` crate with `static-curl` feature                                                     | Links with `curl` statically                                                                                                                                                                      |
+| <a name="dbus-notifications-feature">`dbus-notifications`</a> | `notify-rust` dependency                                                                     | Uses DBus notifications                                                                                                                                                                           |
+| <a name="dbus-static-feature">`dbus-static`</a>               | `notify-rust` dependency and enableds its `d_vendored` feature                               | Includes the dbus library statically.                                                                                                                                                             |
+| <a name="cli-docs-feature">`cli-docs`</a>                     | `flate2` dependency                                                                          | Includes the manpage documentation compiled by either `mandoc` or `man` binary to plain text in `meli`'s command line. Embedded documentation can be viewed with the subcommand `meli man [PAGE]` |
+| <a name="libz-static-feature">`libz-static`</a>               | `libz-sys` dependency and enables its `static` feature                                       | Allows for the transitive dependency libz (from `curl`) to be linked statically.                                                                                                                  |
+| <a name="static-feature">`static`</a>                         | enables `tls-static`, `http-static`, `sqlite3-static`, `dbus-static`, `libz-static` features |                                                                                                                                                                                                   |
+
+## Quick start
 
 ```sh
 # Create configuration file in ${XDG_CONFIG_HOME}/meli/config.toml:
@@ -51,16 +85,19 @@ $ meli edit-config
 $ meli install-man
 # Ready to go.
 $ meli
+# You can read any manual page with the CLI subcommand `man`:
+$ meli man meli.7
+# See help output for all options and subcommands.
+$ meli --help
 ```
 
-</td><td>
-
 See a comprehensive tour of `meli` in the manual page [`meli(7)`](./meli/docs/meli.7).
 
 See also the [Quickstart tutorial](https://meli-email.org/documentation.html#quick-start) online.
 
 After installing `meli`, see `meli(1)`, `meli.conf(5)`, `meli(7)` and `meli-themes(5)` for documentation.
 Sample configuration and theme files can be found in the `meli/docs/samples/` subdirectory.
+Examples for configuration file settings can be found in `meli.conf.examples(5)`
 Manual pages are also [hosted online](https://meli-email.org/documentation.html "meli documentation").
 `meli` by default looks for a configuration file in this location: `${XDG_CONFIG_HOME}/meli/config.toml`.
 
@@ -70,26 +107,22 @@ You can run meli with arbitrary configuration files by setting the `${MELI_CONFI
 MELI_CONFIG=./test_config cargo run
 ```
 
-</td></tr>
-</table>
-
 See [`meli(7)`](./meli/docs/meli.7) for an extensive tutorial and [`meli.conf(5)`](./meli/docs/meli.conf.5) for all configuration values.
 
-| | | |
-:---:|:---:|:---:
-![Main view screenshot](./meli/docs/screenshots/main.webp "mail meli view screenshot")  |  ![Compact main view screenshot](./meli/docs/screenshots/compact.webp "compact main view screenshot") | ![Compose with embed terminal editor screenshot](./meli/docs/screenshots/compose.webp "composing view screenshot")
-Main view             |  Compact main view | Compose with embed terminal editor
+| Main view | Compact main view | Compose with embed terminal editor |
+|-----------|-------------------|------------------------------------|
+| ![Main view screenshot](./meli/docs/screenshots/main.webp "mail meli view screenshot") | ![Compact main view screenshot](./meli/docs/screenshots/compact.webp "compact main view screenshot") | ![Compose with embed terminal editor screenshot](./meli/docs/screenshots/compose.webp "composing view screenshot") |
 
 ### Supported E-mail backends
 
-| Protocol     | Support         |
-|:------------:|:----------------|
-| IMAP         | full            |
-| Maildir      | full            |
-| notmuch      | full[^0]        |
-| mbox         | read-only       |
-| JMAP         | functional      |
-| NNTP / Usenet| functional      |
+| Protocol      | Support    |
+|---------------|------------|
+| IMAP          | full       |
+| Maildir       | full       |
+| notmuch       | full[^0]   |
+| mbox          | read-only  |
+| JMAP          | functional |
+| NNTP / Usenet | functional |
 
 [^0]: there's no support for searching through all email directly, you'd have to
       create a mailbox with a notmuch query that returns everything and search

cliff.toml

@@ -1,5 +1,9 @@
 # configuration for https://github.com/orhun/git-cliff
 
+[remote.gitea]
+owner = "meli"
+repo = "meli"
+
 [changelog]
 # changelog header
 header = """
@@ -20,12 +24,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 body = """
 
 {% if not version %}
-## [Unreleased]
+## Unreleased
 {% else %}
-## [{{ version }}](https://git.meli-email.org/meli/meli/releases/tag/{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
-{% endif %}
-{% macro commit(commit) -%}
-- [{{ commit.id | truncate(length=8, end="") }}]({{ "https://git.meli-email.org/meli/meli/commit/" ~ commit.id }}) {% if commit.scope %}*({{commit.scope | lower }})* {% endif %}{{ commit.message | split(pat="\n")| first | upper_first }}{% endmacro -%}
+## [{{ version }}]({{ "https://git.meli-email.org/meli/meli/releases/tag/" ~ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+{% endif %}{% if get_env(name = "FRIENDS", default = "") != "" %}
+Contributors in alphabetical order:
+
+{{ get_env(name = "FRIENDS") }}
+{%- endif -%}{% if gitea and gitea.contributors %}{% for contributor in gitea.contributors | filter(attribute="is_first_time", value=true) %}
+  * [@{{ contributor.username }}](https://git.meli-email.org/{{ contributor.username }}) made their first contribution in [#{{ contributor.pr_number }}]({{ "https://git.meli-email.org/meli/meli/pulls/" ~ contributor.pr_number }})
+{%- endfor -%}{%- endif -%}{% macro commit(commit) -%}
+- [**`{{ commit.id | truncate(length=8, end="") }}`**]({{ "https://git.meli-email.org/meli/meli/commit/" ~ commit.id }}) {% if commit.scope %}*({{commit.scope | lower }})* {% endif %}`{{ commit.message | split(pat="\n")| first }}`{% if commit.remote and commit.remote.pr_number and commit.remote.pr_title %} in PR [`#{{ commit.remote.pr_number }}` "{{ commit.remote.pr_title }}"]({{ "https://git.meli-email.org/meli/meli/pulls/" ~ commit.remote.pr_number }}){%- endif -%}{% endmacro -%}
 {% for group, commits in commits | group_by(attribute="group") %}
 
 ### {{ group | striptags | trim | upper_first }}
@@ -50,61 +59,95 @@ footer = """
 """
 
 [git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
+# don't parse the commits based on https://www.conventionalcommits.org
+conventional_commits = false
 # filter out the commits that are not conventional
 filter_unconventional = false
 # process each line of a commit as an individual commit
 split_commits = false
 # regex for preprocessing the commit messages
 commit_preprocessors = [
-  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://git.meli-email.org/meli/meli/issues/${2}))" },
+  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://git.meli-email.org/meli/meli/issues/${2}))" }, # Replace the issue number with the link
+  { pattern = " +", replace = " "}, # Replace multiple spaces with a single space
+  { pattern = "`[^`]+`", replace_command = "pandoc -f commonmark -t plain" },
 ]
 # regex for parsing and grouping commits
 commit_parsers = [
-  { message = "^feat", group = "<!-- 00 -->Added" },
-  { message = "^[aA]dd", group = "<!-- 00 -->Added" },
-  { message = "[fF]ix", group = "<!-- 01 -->Bug Fixes" },
-  { message = "[rR]efactor", group = "<!-- 02 -->Refactoring" },
-  { message = "[mM]ove", group = "<!-- 02 -->Refactoring" },
-  { message = "[rR]emove", group = "<!-- 02 -->Refactoring" },
-  { message = "^refactor", group = "<!-- 02 -->Refactoring" },
-  { message = "^[^.]*.rs:", group = "<!-- 02 -->Refactoring" },
-  { message = "^meli", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^melib", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^imap", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^jmap", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^notmuch", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^mbox", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^smtp", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^mbox", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^doc", group = "<!-- 03 -->Documentation" },
-  { message = "[mM]anual", group = "<!-- 03 -->Documentation" },
-  { message = "[mM]anpage", group = "<!-- 03 -->Documentation" },
-  { message = "[rR]eadme", group = "<!-- 03 -->Documentation" },
-  { message = "^perf", group = "<!-- 04 -->Performance" },
-  { message = "^style", group = "<!-- 05 -->Styling" },
-  { message = "^test", group = "<!-- 06 -->Testing" },
-  { message = "^debian", group = "<!-- 06 -->Packaging" },
-  { message = "^mail/view", group = "<!-- 02 -->Changes" },
-  { message = "^view", group = "<!-- 02 -->Changes" },
-  { message = "^utilities", group = "<!-- 02 -->Changes" },
-  { message = "^mail", group = "<!-- 02 -->Changes" },
-  { message = "^listing", group = "<!-- 02 -->Changes" },
-  { message = "^terminal", group = "<!-- 02 -->Changes" },
-  { message = "^types", group = "<!-- 02 -->Changes" },
-  { message = "^conf", group = "<!-- 02 -->Changes" },
-  { message = "^chore\\(release\\): prepare for", skip = true },
-  { message = "^chore\\(pr\\)", skip = true },
-  { message = "^chore\\(pull\\)", skip = true },
-  { message = "^chore\\(deps\\)", skip = true },
   { message = "^chore\\(changelog\\)", skip = true },
-  { message = "^[cC]hore", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { message = "^scripts", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { body = ".*security", group = "<!-- 08 -->Security" },
+  { message = "^chore\\(deps\\)", skip = true },
+  { message = "^chore\\(pull\\)", skip = true },
+  { message = "^chore\\(pr\\)", skip = true },
+  { message = "^chore\\(release\\): prepare for", skip = true },
+  { message = "^CHANGELOG", skip = true },
+  { message = "(?i)^revert", group = "<!-- 11 -->Reverted Commits" },
+  { message = "^.github", group = "<!-- 10 -->Continuous Integration" },
+  { message = "^.gitea", group = "<!-- 10 -->Continuous Integration" },
+  { message = "(?i)^ci", group = "<!-- 10 -->Continuous Integration" },
   { message = "^build", group = "<!-- 09 -->Build" },
-  { message = "^ci", group = "<!-- 10 -->Continuous Integration" },
-  { message = "^revert", group = "<!-- 11 -->Reverted Commits" },
+  { body = ".*security", group = "<!-- 08 -->Security" },
+  { message = "^scripts", group = "<!-- 07 -->Miscellaneous Tasks" },
+  { message = '(?i)^chore', group = "<!-- 07 -->Miscellaneous Tasks" },
+  { message = "^debian", group = "<!-- 06 -->Packaging" },
+  { message = "^test", group = "<!-- 06 -->Testing" },
+  { message = "^style", group = "<!-- 05 -->Styling" },
+  { message = "^perf", group = "<!-- 04 -->Performance" },
+  { message = "(?i)readme", group = "<!-- 03 -->Documentation" },
+  { message = "(?i)anpage", group = "<!-- 03 -->Documentation" },
+  { message = "(?i)anual", group = "<!-- 03 -->Documentation" },
+  { message = "meli.[17]", group = "<!-- 03 -->Documentation" },
+  { message = "meli.conf.5", group = "<!-- 03 -->Documentation" },
+  { message = "meli-themes.5", group = "<!-- 03 -->Documentation" },
+  { message = "README.md", group = "<!-- 03 -->Documentation" },
+  { message = "BUILD.md", group = "<!-- 03 -->Documentation" },
+  { message = "DEVELOPMENT.md", group = "<!-- 03 -->Documentation" },
+  { message = "^doc", group = "<!-- 03 -->Documentation" },
+  { message = "^[^.]*.rs:", group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)^refactor\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)lints?\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)move\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)replace\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)remove\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)refactor\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)rename\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)formatting\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)cleanups?\b', group = "<!-- 02 -->Refactoring" },
+  { message = '(?i)fix\b', group = "<!-- 01 -->Bug Fixes" },
+  { message = '(?i)fixups?\b', group = "<!-- 01 -->Bug Fixes" },
+  { message = "(?i)implement", group = "<!-- 00 -->Added" },
+  { message = '(?i)add\b', group = "<!-- 00 -->Added" },
+  { message = '(?i)^update\b', group = "<!-- 02 -->Changes" },
+  { message = '(?i)\bdependency\b', group = "<!-- 02 -->Changes" },
+  { message = "^feat", group = "<!-- 00 -->Added" },
+  { message = '(?i)retry\b', group = "<!-- 02 -->Changes" },
+  { message = "^conf", group = "<!-- 02 -->Changes" },
+  { message = "^contacts?", group = "<!-- 02 -->Changes" },
+  { message = "^compos[ie]?", group = "<!-- 02 -->Changes" },
+  { message = "^types", group = "<!-- 02 -->Changes" },
+  { message = '(?i)^use', group = "<!-- 02 -->Changes" },
+  { message = "^terminal", group = "<!-- 02 -->Changes" },
+  { message = "^listing", group = "<!-- 02 -->Changes" },
+  { message = "^mail", group = "<!-- 02 -->Changes" },
+  { message = "^utilities", group = "<!-- 02 -->Changes" },
+  { message = "^view", group = "<!-- 02 -->Changes" },
+  { message = "^mail/view", group = "<!-- 02 -->Changes" },
+  { message = "^backends?", group = "<!-- 02 -->Changes" },
+  { message = "^commands?", group = "<!-- 02 -->Changes" },
+  { message = "^actions?", group = "<!-- 02 -->Changes" },
+  { message = "^log", group = "<!-- 02 -->Changes" },
+  { message = "^pgp", group = "<!-- 02 -->Changes" },
+  { message = "^gpgme", group = "<!-- 02 -->Changes" },
+  { message = "^manage", group = "<!-- 02 -->Changes" },
+  { message = "^smtp", group = "<!-- 02 -->Changes" },
+  { message = "^mbox", group = "<!-- 02 -->Changes" },
+  { message = "^jmap", group = "<!-- 02 -->Changes" },
+  { message = "^imap", group = "<!-- 02 -->Changes" },
+  { message = "^nntp", group = "<!-- 02 -->Changes" },
+  { message = "^notmuch", group = "<!-- 02 -->Changes" },
+  { message = "^melib", group = "<!-- 02 -->Changes" },
+  { message = "^meli", group = "<!-- 02 -->Changes" },
+  { message = "^accounts", group = "<!-- 02 -->Changes" },
+  { message = "^embedded", group = "<!-- 02 -->Changes" },
+  { message = "^jobs", group = "<!-- 02 -->Changes" },
   { message = ".*", group = "<!-- 07 -->Miscellaneous Tasks" },
 ]
 # protect breaking changes from being skipped due to matching a skipping commit_parser

codemeta.json

@@ -15,10 +15,10 @@
     ],
     "codeRepository": "https://git.meli-email.org/meli/meli.git",
     "dateCreated": "2016-04-25",
-    "dateModified": "2024-07-30",
+    "dateModified": "2024-11-27",
     "datePublished": "2017-07-23",
     "description": "BSD/Linux/macos terminal email client with support for multiple accounts and Maildir / mbox / notmuch / IMAP / JMAP / NNTP (Usenet).",
-    "downloadUrl": "https://git.meli-email.org/meli/meli/archive/v0.8.7.tar.gz",
+    "downloadUrl": "https://git.meli-email.org/meli/meli/archive/v0.8.10.tar.gz",
     "identifier": "https://meli-email.org/",
     "isPartOf": "https://meli-email.org/",
     "keywords": [
@@ -49,14 +49,21 @@
     ],
     "programmingLanguage": "Rust",
     "relatedLink": [
+        "https://lists.meli-email.org/",
         "https://codeberg.org/meli/meli",
         "https://github.com/meli/meli",
-        "https://lists.meli-email.org/"
+        "https://gitlab.com/meli-project/meli",
+        "https://crates.io/crates/meli",
+        "https://packages.debian.org/trixie/meli",
+        "https://pkgsrc.se/mail/meli",
+        "https://openports.pl/path/mail/meli",
+        "https://ports.macports.org/port/meli/",
+        "https://search.nixos.org/packages?query=meli"
     ],
-    "version": "0.8.7",
+    "version": "0.8.10",
     "contIntegration": "https://git.meli-email.org/meli/meli/actions",
     "developmentStatus": "active",
     "issueTracker": "https://git.meli-email.org/meli/meli/issues",
-    "readme": "https://git.meli-email.org/meli/meli/raw/commit/f2e9cac38e8e8e02de7312e5b6871279cf675c97/README.md",
-    "buildInstructions": "https://git.meli-email.org/meli/meli/raw/commit/f2e9cac38e8e8e02de7312e5b6871279cf675c97/BUILD.md"
+    "readme": "https://git.meli-email.org/meli/meli/raw/tag/v0.8.10/README.md",
+    "buildInstructions": "https://git.meli-email.org/meli/meli/raw/tag/v0.8.10/BUILD.md"
 }

contrib/README.md

@@ -0,0 +1,50 @@
+<!-- SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later -->
+# Useful scripts and files for use with `meli`
+
+This directory includes various useful scripts and files that are contributed
+by the community and not actively maintained or supported.
+
+If you believe something in this directory needs updates to work with the
+current version of `meli` or there are bugs that need fixing, please file an
+issue on our issue tracker!
+
+## Connecting to a Gmail account with OAUTH2
+
+The script [`./oauth2.py`](./oauth2.py) is a helper script to authenticate to a Gmail account using IMAP OAUTH2 tokens.
+
+See [`meli.conf(5)`](../meli/docs/meli.conf.5) for documentation.
+
+If the script does not work and you're certain it's because it needs changes to
+work with Google's servers and not a user error on your part, please file a bug
+on our issue tracker!
+
+## Using `meli` for `mailto:` links
+
+To use `meli` to open `mailto:` links from your browser place the [`mailto-meli`](./mailto-meli) and [`mailto-meli-expect`](./mailto-meli-expect) scripts into `/usr/bin`
+(or `.local/bin`, and adjust the path in the script accordingly).
+
+Ensure all scripts are executable by your user account, if not set the permissions accordingly:
+
+```sh
+chmod u+x /path/to/mailto-meli
+```
+
+and
+
+```sh
+chmod u+x /path/to/mailto-meli-expect
+```
+
+Then set `mailto-meli` as program to open `mailto` links
+in your browser.
+
+E.g. in Firefox this can be done under "Settings" (`about:preferences`) which you can access from the menu button or `Edit -> Settings`.
+
+```text
+General -> Applications -> Content-Type: mailto.
+```
+
+You can test that it works by clicking the system menu entry `File -> Email link...`.
+
+_NOTE_: that you need to have the [`expect`](https://en.wikipedia.org/wiki/Expect) binary installed for this to work.
+`expect` is a scripting language used for interactive with interactive terminal applications like `meli`.

contrib/mailto-meli

@@ -0,0 +1,21 @@
+#!/usr/bin/env sh
+#
+# mailto-meli -- wrapper to use meli as mailto handler
+# To use meli as mailto: handler point your browser to use this as application for opening 
+# mailto: links.
+# Note: This assumes that x-terminal-emulator supports the "-e" flag for passing along arguments.
+
+# Copyright: 2024 Matthias Geiger <werdahias@debian.org>
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# Check if mailto-meli and expect are present
+if ! command -v mailto-meli > /dev/null 2>&1
+then echo "mailto-meli not found" && exit 1
+else 
+	if ! command -v expect > /dev/null 2>&1
+	then echo "expect not found" && exit 1
+	fi
+fi
+
+exec x-terminal-emulator -e mailto-meli-expect "$@"
+

contrib/mailto-meli-expect

@@ -0,0 +1,18 @@
+#!/usr/bin/env -S expect -f
+# Copyright 2024 Manos Pitsidianakis
+#
+# SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+# Trap window resize signal
+trap {
+  set rows [stty rows]
+  set cols [stty columns]
+  stty rows $rows columns $cols < $spawn_out(slave,name)
+} WINCH
+# send the input with human-like delay:
+set send_human {.001 .003 0.01 .005 .005}
+spawn meli
+send -h ":mailto "
+send -h [lindex $argv 0]
+send -h "\n"
+interact

debian/changelog

@@ -1,3 +1,443 @@
+meli (0.8.10-1) bookworm; urgency=low
+
+  Highlights:
+  ===========
+
+  - added pipe-attachment command
+  - added sample scripts for using meli as a mailto scheme handler in
+    contrib/
+  - fixed GPG encryption with libgpgme
+
+  Contributors in alphabetical order:
+  ===================================
+
+  - Manos Pitsidianakis
+  - Matthias Geiger
+
+  Added
+  =====
+
+  - 5e77821f mail/view: add pipe-attachment command in PR #540
+    "mail/view: add pipe-attachment command"
+  - fa896f6b contrib: add mailto: scheme handler scripts
+  - 00ce9660
+    melib/backends: add as_any/as_any_mut methods to BackendMailbox
+  - fd243fa5 maildir: add mailbox creation tests
+  - de65eec3 meli/accounts: add mailbox_by_path() tests in PR #535
+    "Rework maildir mailbox path logic, add tests"
+  - 6b363601 melib/gpgme: impl Display for gpgme::Key
+
+  Bug Fixes
+  =========
+
+  - 60c90d75 melib/attachments: ensure MIME boundary prefixed with CRLF
+  - 3433c5c3 compose/pgp: rewrite key selection logic in PR #541 "More
+    gpgme/PGP fixes again"
+  - 12de82e7 melib/conf: fix mutt_alias_file not being validated in PR
+    #550 "Remove sealed_test dependency"
+  - c8e055a7 Fix version migrations being triggered backwards in PR #557
+    "Fix version migrations being triggered backwards"
+  - efab99fd
+    terminal: check for NO_COLOR env var without unicode validation
+  - 36a63e88 melib/maildir: rewrite create_mailbox()
+  - fcab855f view: ensure envelope headers are always populated in PR
+    #538 "view: ensure envelope headers are always populated"
+  - 84564f44 mailcap: don't drop File before opening it in PR #552
+    "mailcap: don't drop File before opening it"
+
+  Changes
+  =======
+
+  - ed85da51 Remove sealed_test dependency
+
+  Refactoring
+  ===========
+
+  - 03df2ac1 meli/utilities: add print utilities for tests
+  - 18e9d5c1 conf.rs: impl From<melib::AccountSettings> for AccountConf
+  - 1f2fec19 Fix 1.83.0 lints in PR #536 "CI: Add action to check for
+    DCO signoffs in PRs"
+  - 192ecea2 compose/gpg.rs: Fix msrv regression
+
+  Documentation
+  =============
+
+  - 4a61a4b8 melib: include README.md as preamble of crate rustdocs
+  - 80e53471 BUILD.md: move melib specific stuff to melib/README.md
+  - 91a17ece melib/README.md: mention sqlite3-static feature
+  - b77a691b meli/README.md: Add cargo features section in PR #549
+    "Document cargo features in READMEs"
+  - 91dc271d contrib: add a README.md file
+  - 2e900be6 contrib/README.md: add section about oauth2.py
+  - 07812d2c contrib/README.md: elaborate a bit about mailto in PR #545
+    "Add external mailto: handler support via scripts in contrib"
+  - e784e8d2 scripts: add markdown_doc_lints.py
+
+  Continuous Integration
+  ======================
+
+  - 77629851 CI: Add action to check for DCO signoffs in PRs
+  - f944ebed CI: Add error msg when cargo-derivefmt check fails
+  - d49344f9 CI: Move MSRV checks from manifest to lints in PR #553
+    "ci-workflow-fixes"
+  - ece6bfc2 CI: non-zero exit if cargo-derivefmt-* targets fail
+  - 2257b91b CI: add actions/cache steps in PR #554 "CI: add
+    actions/cache steps"
+  - a1c9524f CI: fix check_dco.sh not working with other repos in PR
+    #555 "CI: fix check_dco.sh not working with other repos"
+
+ -- Manos Pitsidianakis <manos@pitsidianak.is>  Fri, 06 Dec 2024 07:03:58 +0200
+
+meli (0.8.9-1) bookworm; urgency=low
+
+  This is mostly a fixups release.
+
+  Added
+  =====
+
+  - cf16bf65 meli/sqlite3: add tests for reindexing
+  - a389772d accounts: suggest tips on mailbox_by_path error
+
+  Bug Fixes
+  =========
+
+  - 25f0a3f8 conf/terminal: fix serde of ProgressSpinnerSequence
+  - c375b48e terminal: fix Synchronized Output response parsed as input
+    in PR #523 "terminal: fix Synchronized Output response parsed as
+    input"
+  - b7e215f9
+    melib/utils: fix test_fd_locks() on platforms without OFD support in
+    PR #524 "melib/utils: fix test_fd_locks() on platforms without OFD
+    support"
+  - 25c32a6b meli/docs/meli.conf.examples.5: fix .Dt macro arguments
+  - 18ae5848 meli: fix reindex of previously indexed account with sqlite3
+    backend
+  - 13e917d9 Fix some compilation errors with cfg feature attrs in PR #531
+    "accounts: suggest tips on mailbox_by_path error"
+  - 8c176d38 contacts/editor: fix crash on saving contact in PR #532
+    "contacts/editor: fix crash on saving contact"
+  - fb5a88c2
+    melib/collection: ensure mailbox exists when inserting new envelopes
+    in PR #529 "Small account stuff fixes"
+
+  Changes
+  =======
+
+  - 7f8f1cf6 melib/gpgme bindings renewal in PR #533 "melib/gpgme
+    bindings renewal"
+  - 9b7825bc Update futures-util dep, remove stderrlog dep
+  - 4be69360 Remove obsolete "encoding" dependency in PR #530
+    "Remove/update obsolete dependencies"
+
+  Refactoring
+  ===========
+
+  - 5af6e059 meli/accounts: use Arc<str> for account name
+  - 567270e1 melib: use Vec instead of SmallVec for search results
+  - 2bd8d7ba
+    conf/tests.rs: Rename test functions to follow path convention
+
+  Documentation
+  =============
+
+  - 97242482 meli/docs: add meli.conf.examples to CLI and tests
+  - 0f096338 README.md: Update ways to install, add gitlab mirror link
+    in PR #528 "Integrate meli.conf.examples.5 into CLI and build, also
+    update README with installation instructions"
+
+  Continuous Integration
+  ======================
+
+  - 630df308 CI: Add arm64 runners in job matrices in PR #527 "CI: Add
+    arm64 runners in job matrices"
+  - 49ecbb56 CI: .gitea/Makefile.lint: check if nightly exists
+
+ -- Manos Pitsidianakis <manos@pitsidianak.is>  Wed, 27 Nov 2024 16:16:06 +0200
+
+meli (0.8.8-1) bookworm; urgency=low
+
+  WARNING: This release contains a breaking change in the configuration
+  file: a global composing option is not required anymore. Now, composing
+  options are per account.
+
+  Added
+  =====
+
+  -   f3d59ebf accounts: add force: bool arg to load()
+  -   33836a32 melib/error: add WrapResultIntoError helper trait
+  -   3216324c melib/mbox: impl FromStr for MboxFormat
+  -   94f345d7 Implement mailbox renaming command
+  -   8d45ecc1 melib/error: add related_path field
+  -   bf3a4c5d error: add ErrorChainDisplay struct for better output
+  -   6be5fd26
+      themes: add inheritance, and use themes when initializing grids
+  -   0ee7fc4d Print clickable path links with subcommands
+  -   aed7a60f samples: add ibm-modern theme in PR #469 "conf-refactor"
+  -   4bbf446b utils: add unix file locks module
+  -   6fbf569f search: add Message-ID, and other header search support
+  -   26d33ce5 address: add separator argument to display_slice()
+  -   32e3be8b
+      sqlite3: add optional directory field in DatabaseDescription
+  -   dbbb1529 Add missing ComponentUnrealize handlers
+  -   87d2cec9 Add sealed_test dependency
+  -   604ae111 Impl From<&[u8]> for u64-based hash newtypes
+  -   8205c7f5 melib: add JsContact module in PR #479 "view-filters"
+  -   2af5c8b6 terminal: add QuerySynchronizedOutputSupport WIP
+  -   5c4faea5 Add transpose shortcut and tests for text field
+  -   e9b87b2e melib/maildr: add rename_regex config option
+  -   8f0e1d66 Add human-readable identifiers in temp draft files
+  -   601e3711 Add vCard exports
+  -   719e2eb2 listing: add customizable view divider like sidebar's in PR
+      #485 "listing: add customizable view divider like sidebar's"
+  -   ba3ad8ed listing: always show mail_view_divider in PR #486 "listing:
+      always show mail_view_divider"
+  -   46b2c3b1 Add listing.thread_layout config flag in PR #487 "Add
+      listing.thread_layout config flag"
+  -   aaea3a5a nntp: add timeout conf flag
+  -   d4636bcc nntp: interpret IMPLEMENTATION cap as metadata
+  -   5f120309 nntp: add select_group_by_name() method
+  -   9a9cd03d nntp: add NntpType::article_message_id() method
+  -   7cfcbb7a Add patch_retrieve module in PR #489 "Add patch_retrieve
+      module"
+  -   c82341f3 File: try trimming filename if ENAMETOOLONG
+  -   23395491 compose/pgp: add encrypt_for_self flag
+  -   0b6988b7 gpgme: add always trust flag to encrypt op
+  -   be3b3ef8 melib/utils: add fnmatch(3) interface
+  -   32f7e50f Add version migration support
+  -   a6c7621c jscontact: add {created,updated} fields
+  -   39592ad0 jmap: implement changing mailbox subscription
+  -   ca7eb792 jmap: Implement deleting email
+  -   b8e841bb jmap: implement mailbox deletion
+  -   77e7c3df Add support for signatures in PR #500 "Add support for
+      signatures"
+  -   dba5b68b components: add prelude module
+  -   f656aff0 composer: add discard-draft command
+  -   789a88b2 shortcuts: add select_motion equivalent to select_entry
+  -   cb2dd5de listing/threaded: impl missing select functionality in PR
+      #514 "listing/threaded: impl missing filter functionality"
+  -   c1901c96
+      melib/email/compose: add Content-Type header for utf8 text plain attachments
+  -   0e77bd5b
+      melib/email/compose/tests: add multipart mixed attachment test in PR
+      #515 "Fix incorrect multipart/mixed rendering when sending text with
+      attachments under certain circumstances"
+  -   7b1be139 melib: make mbox backend build by default
+  -   7ff1db14 manage-mailboxes: add delete option in PR #520
+      "manage-mailboxes: add delete option"
+
+  Bug Fixes
+  =========
+
+  -   6b05279a Update time dep to fix 1.80.0 breakage
+  -   2084ce93 Fix invalid cfg feature combinations for macos in PR #471
+      "Fix invalid cfg feature combinations for macos"
+  -   4707ec9f text/line_break: fix ReflowState::{No,All} break
+  -   86e25bc0 sqlite: fix database reset sequence
+  -   4d4e189c imap: code style fixups
+  -   335cca88 listing: fix highlight_self flag off by one error in PR
+      #477 "listing: fix highlight_self flag off by one error"
+  -   80915832 mailto: rewrite parsing in PR #480 "mailto-rewrite"
+  -   65b32e77 subcommands: Fix wrong help info in imap-shell prompt
+  -   d0c81749 conf::data_types: minor style and error msg fixups
+  -   7dbee81d view: fix nested filter jobs never being completed
+  -   f78884ce melib/nntp: fix an ancient FIXME
+  -   e0cfe8e4 Fix compilation for 32-bit architectures in PR #492 "Fix
+      compilation for 32-bit architectures"
+  -   1b708a99 melib: attempt FromSql from Blob for u64 hash in PR #506
+      "melib: attempt FromSql from Blob for u64 hash"
+  -   6c315580 compose: fix add-attachment-file-picker
+  -   c6e9e424 listing/threaded: impl missing filter functionality
+  -   e7a164de Configure some gpgme stuff under gpgme feature
+
+  Changes
+  =======
+
+  -   8e300c46 melib/jmap: call req text(). asap
+  -   374ea8ba accounts: extract tests to tests.rs file
+  -   7020cd66 meli: derive PartialEq/Eq for some types
+  -   69065859 accounts: split mailbox to enum out of JobRequest
+  -   14f2d911 melib/backends: change RefreshEvent field decl order
+  -   56b1bf28 meli/accounts: batch process refresh events
+  -   6513c188 melib/imap: on sync only update exists/unseen if loaded
+  -   a8dad317 melib/imap: renamed cache module to sync
+  -   9e9c04a3 Update indexmap dep to 2.3.0
+  -   2b3828d8 Update futures dependency to 0.3.30
+  -   84812941
+      melib/jmap: do not serialize server-set fields in Set create
+  -   eda6620c jmap: detect supported Auth schemes on connect in PR #467
+      "jmap: detect supported Auth schemes on connect"
+  -   35f12b15 embedded: prevent double-close of pty fd in PR #468
+      "embedded: prevent double-close of pty fd"
+  -   0bed37b5 melib: use IndexMap in conf fields
+  -   f3ad824d meli: use itoa to format offset indices in listings
+  -   1cfb0b15 Update nix dependency to 0.29.0
+  -   9c1b4424 jobs: make cancel flag an AtomicBool
+  -   f06a9072 jmap: fetch mailbox with receivedAt descending sort
+  -   53b0d035 accounts: cancel any previous mailbox fetches
+  -   60833ee5 accounts: make mailbox available as soon as possible
+  -   28f45805 mail/view: try cancel env fetch on Drop
+  -   2bb9b20d mail/view: do not highlight reply subjects in thread
+  -   a4f344b3 Use create_new to avoid overwriting files
+  -   d6197e8b listing: clear count modifier on Home/End
+  -   b798ca4a imap: return cached response in {select,examine}_mailbox()
+  -   151fcebe imap: use BTreeMap for message sequence number store
+  -   e48fcc33 imap/protocol_parser: also populate other_headers
+  -   1e11c29c imap: resync cache first when fetching a mailbox
+  -   1779ad5d imap: interpret empty server response as BYE
+  -   2d320688 mail/listing: pre-lookup conf values
+  -   4e967280 nntp: don't needlessly select group before ARTICLE in PR
+      #473 "Various"
+  -   67b88d24 Update polling dependency from "2.8" to "3"
+  -   14d74f36 Update smol dependency from "1" to "2"
+  -   b950fcea melib: Use IndexMap in VCard
+  -   32acc347 view: show signature verification properly
+  -   ac1349b8 command: alias pwd to cwd
+  -   7c056e4b Retry loading mailbox on recoverable error in PR #481
+      "Retry loading mailbox on recoverable error"
+  -   cbafdcf7 terminal: color report WIP
+  -   4a26cfa1 logging: disable tracing from output
+  -   90974e7c imap: cache miss if row env hash != row hash
+  -   4c44c440 melib: #[ignore] shellexpand tests
+  -   dc9e91df contacts/editor: Use FormButtonAction in form
+  -   c0511901 Update debian/meli.{docs,examples} and Cargo exclude
+  -   592ce159 mbox: use Uuid::nil() as default envelope from
+  -   6eeb4571 nntp: make all fields public
+  -   b27bac7f nntp: use DEFLATE when available by default
+  -   128b959f
+      nntp: prepend Newsgroups header if missing on NntpType::submit()
+  -   a69122f8
+      pgp: use default sign/encrypt keys when no keys are selected
+  -   e6fa7093 view/envelope: trim headers values to 3 lines maximum
+  -   7f0157a9 compose: make dialogs bigger in height in PR #490 "pgp: use
+      default sign/encrypt keys when no keys are selected"
+  -   e032acfa view: pass filtered body to Composer as reply text in PR
+      #493 "view: pass filtered body to Composer as reply text"
+  -   49dcbc5e terminal: Extend Ask default actions, prompts
+  -   cd2e4bf3 melib/utils: vendor urn crate
+  -   5915f125 backends: use IsSubscribedFn in method signatures
+  -   4f927bbe nntp: properly return all nntp mailboxes
+  -   b930cb49 maildir: do not use rename_regex when only updating flags
+  -   27486f29 Accept newer versions of base64 dependency
+  -   c3cac77d Update imap-codec dependency to 2.0.0-alpha.4
+  -   05f404ba jobs: do not use AtomicU64 in PR #505 "jobs: do not use
+      AtomicU64"
+  -   46916895 melib/gpgme: s/NULL/NUL when referring to NUL byte
+  -   81ace71b terminal/embedded: lift error checking earlier
+  -   24114811 manage: parse scroll_{left,right} actions
+  -   d2559e42 imap: return all mailboxes, not just subscribed ones in PR
+      #509 "compose: fix add-attachment-file-picker"
+  -   320fddad melib/gpgme: disable layout tests on non-x86_64 hosts in PR
+      #511 "melib/gpgme: disable layout tests on non-x86_64 hosts"
+  -   bcbcb012
+      melib/email/compose: ensure boundary always prefixed with CRLF
+  -   d21c686d melib/attachments: Make AttachmentBuilder::set_raw generic
+  -   d5d34579 melib/email/compose/tests: normalise test fn names
+  -   e9ec6761 melib: make base64 dep mandatory
+  -   30405216 melib: make notmuch feature depend on maildir feature
+  -   35fa8e94 melib/imap: gracefully retry without DEFLATE on BYE in PR
+      #517 "Fix some unrelated bugs I found while debugging build failure
+      on armhf"
+
+  Refactoring
+  ===========
+
+  -   20d73292 melib: replace async-stream dep with async-fn-stream
+  -   201081b6 meli/command: move tests to tests.rs
+  -   84cfa358 conf: remove need for global send_mail setting
+  -   7be8912c Cargo.tomls: make formatting more consistent
+  -   e6877e89 melib/jmap: refactor some parser imports
+  -   f7ec6d6b melib/jmap: implement mailbox rename
+  -   15d24ab0 meli/jobs: refactor spawn_{blocking,specialized} to spawn()
+  -   6ee148c0 Fix 1.80.0 clippy lints
+  -   de72bc6a melib/error.rs: move network stuff to submodule
+  -   a214a35c conf: refactor into submodules
+  -   978cefbb Replace Escape ascii char with hex literal
+  -   4b959f5c Remove pcre feature/dependency
+  -   036586a2 Update serde dependency to 1.0.205
+  -   191725b5
+      Fix some borrow checker error/warnings from upcoming 2024 edition
+  -   11798be8 Replace Envelope::message_id_display() with Display impls
+  -   394236ba email/address: Refactor References struct
+  -   a7c73fc8 gpgme: refactor Rust interface, add tests
+  -   41e1fdd5 Fix cargo-derivefmt lints
+  -   a44486d9 imap: fix minor clippy lint
+  -   0c0f8210 Add a "move to Trash" shortcut
+  -   d20a9d0a Fix new clippy lints
+  -   e9a72072 Remove unused/obsolete plugins code and mentions
+  -   2ddd28ee main.rs: always send a JobFinished event to all components
+  -   571ae390 pager.rs: don't set self dirty after filter selector in PR
+      #488 "view: fix nested filter jobs never being completed"
+  -   6bc0caf4 melib: remove redundant get_path_hash macro
+  -   fc3308e4 melib: Add Mail::as_mbox() method
+  -   b1f24cbe view/filters: forward events on child filters
+  -   1b201bf6 Remove GlobMatch trait, replace usage with Fnmatch
+  -   8af003ab Rename addressbook stuff to "contacts"
+  -   2069b4da errors: impl From<xdg::BaseDirectoriesError>
+  -   7dee32ae contacts: refactor Card to its own module
+  -   6d0d9680 jmap: move EmailObject state to Store
+  -   0c590bbc contact-editor: remove empty space in PR #495 "Add version
+      migration support"
+  -   b2200ec3 Remove unused smtp tests in PR #501 "Apply patches from
+      upstream debian package"
+  -   ae294945 remove unused module file
+  -   3558db51 Move jobs and mailbox management Components together
+  -   3a931035 command: move Composer actions under TabActions
+  -   441fda56 terminal: move TextPresentation trait to melib
+  -   ee897942 lints: deny clippy::or_fun_call
+  -   0d088962 lints: Address clippy::too_long_first_doc_paragraph
+  -   ecc9b482 Small repo cleanups
+
+  Documentation
+  =============
+
+  -   a83b4176 meli.1: small fixes
+  -   72dea6f3 Manpage fixes
+  -   a55f65e1
+      meli.conf.5: Fix wrong default value type in default_header_values
+  -   57b45a9c docs/historical-manpages: add DEP5 copyright file
+  -   00236b86 docs: add meli.conf.examples(5) WIP
+  -   b88dc441 Comment out svgfeature; no need to ship it in PR #482
+      "milestone/0.8.8"
+  -   b048c95a BUILD.md: add instructions for Android build
+  -   593ed22b pgp: perform gpgme's sign+encrypt manually in PR #494 "pgp:
+      perform gpgme's sign+encrypt manually"
+  -   50922d97 melib/README.md: update and fix feature table
+  -   b912aabc docs: add examples of file picker usage in PR #516 "docs:
+      add examples of file picker usage"
+
+  Packaging
+  =========
+
+  -   b55edd47 debian: update meli.docs and add meli.manpages
+
+  Miscellaneous Tasks
+  ===================
+
+  -   1232e16a scripts/make_html_manual_page.py: don't prettify
+  -   6d520605 Vendor vobject crate
+  -   b33433e4
+      Don't create backends as Box<dyn MailBackend>, but as Box<Self>
+  -   2001b4dd Make subscribed_mailboxes conf val optional
+  -   6cfe4da0 Enable rusqlite feature "modern_sqlite" always
+  -   707a129e Coalesce repeating TUI notification messages
+  -   f036f95e scripts: add generate_release_changelog_entry.sh
+
+  Continuous Integration
+  ======================
+
+  -   4684b601 CI: remove env vars from action names in PR #458 "Minor QoL
+      fixes"
+  -   7419b465 CI: unpin rust version after updating time dependency in PR
+      #460 "Update time dep to fix 1.80.0 breakage"
+  -   77da86eb CI: Update cargo-derivefmt version
+  -   1b3f2732 CI: Move build.yaml actions to Makefile.build
+  -   598a70f9 CI: move lints.yaml actions to Makefile.lint
+  -   7e800a8f
+      CI: move manifest_lints.yaml actions to Makefile.manifest-lints
+  -   98652110 CI: prepend printf commands with @
+  -   ad79bf84 .gitea/Makefile.lint: attempt cargo-fmt with +nightly
+
+ -- Manos Pitsidianakis <manos@pitsidianak.is>  Tue, 19 Nov 2024 14:09:13 +0200
 meli (0.8.7-1) bookworm; urgency=low
 
   Contributors in alphabetical order:

debian/meli.docs

@@ -1,4 +1,4 @@
-meli/docs/meli.1
-meli/docs/meli.7
-meli/docs/meli.conf.5
-meli/docs/meli-themes.5
+meli/docs/*.1
+meli/docs/*.5
+meli/docs/*.7
+meli/docs/external-tools.md

debian/meli.examples

@@ -1,2 +1,3 @@
-meli/docs/samples/sample-config.toml
-meli/docs/samples/themes
+contrib/*
+meli/docs/mail.vim
+meli/docs/samples/*

debian/meli.manpages

@@ -0,0 +1,3 @@
+meli/docs/*.1
+meli/docs/*.5
+meli/docs/*.7

debian/patches/fix-prefix-for-debian.patch

@@ -1,6 +1,6 @@
 Description: Fix PREFIX env var in Makefile for use in Debian
-Author: Manos Pitsidianakis <epilys@nessuent.xyz>
-Last-Update: 2023-03-06
+Author: Manos Pitsidianakis <manos@pitsidianak.is>
+Last-Update: 2024-11-19
 Index: meli/Makefile
 ===================================================================
 --- meli.orig/Makefile

debian/patches/usr_bin_editor.patch

@@ -1,16 +1,11 @@
-From: Manos Pitsidianakis <manos@pitsidianak.is>
-Date: Thu, 27 Feb 2014 16:06:15 +0100
-Subject: usr_bin_editor
-
-If EDITOR or VISUAL is not set, fall back to /usr/bin/editor,
-which is set by update-alternatives.
----
- meli/src/subcommands.rs | 1 +---
- 1 file changed, 1 insertion(+), 3 deletions(-)
-
---- a/meli/src/subcommands.rs
-+++ b/meli/src/subcommands.rs
-@@ -52,9 +52,7 @@
+Description: If EDITOR or VISUAL is not set, fall back to /usr/bin/editor, which is set by update-alternatives.
+Author: Manos Pitsidianakis <manos@pitsidianak.is>
+Last-Update: 2024-11-19
+Index: meli/meli/src/subcommands.rs
+===================================================================
+--- meli.orig/meli/src/subcommands.rs
++++ meli/meli/src/subcommands.rs
+@@ -56,9 +56,7 @@
  pub fn edit_config() -> Result<()> {
      let editor = std::env::var("EDITOR")
          .or_else(|_| std::env::var("VISUAL"))
@@ -18,6 +13,6 @@ which is set by update-alternatives.
 -            format!("Could not find any value in environment variables EDITOR and VISUAL. {err}")
 -        })?;
 +        .unwrap_or_else(|_| "/usr/bin/editor".into());
-     let config_path = crate::conf::get_config_file()?;
+     let config_path = conf::get_config_file()?;
  
      let mut cmd = Command::new(editor);

debian/rules

@@ -2,6 +2,7 @@
 # You must remove unused comment lines for the released package.
 export RUSTUP_HOME=${HOME}/.rustup
 export DH_VERBOSE = 1
+export NO_MAN
 #export DEB_BUILD_MAINT_OPTIONS = hardening=+all
 #export DEB_CFLAGS_MAINT_APPEND  = -Wall -pedantic
 #export DEB_LDFLAGS_MAINT_APPEND = -Wl,--as-needed

meli/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "meli"
-version = "0.8.7"
+version = "0.8.10"
 authors = ["Manos Pitsidianakis <manos@pitsidianak.is>"]
 edition = "2021"
 rust-version = "1.70.0"
-license = "GPL-3.0-or-later"
+license = "EUPL-1.2 OR GPL-3.0-or-later"
 readme = "README.md"
 description = "terminal e-mail client"
 homepage = "https://meli-email.org"
@@ -12,6 +12,7 @@ repository = "https://git.meli-email.org/meli/meli.git"
 keywords = ["mail", "mua", "maildir", "terminal", "imap"]
 categories = ["command-line-utilities", "email"]
 default-run = "meli"
+exclude = ["/docs/historical-manpages"]
 
 [[bin]]
 name = "meli"
@@ -22,34 +23,31 @@ name = "meli"
 path = "src/lib.rs"
 
 [dependencies]
-async-task = "^4.2.0"
+aho-corasick = { version = "1.1.3" }
+async-task = { version = "^4.2.0" }
 bitflags = { version = "2.4", features = ["serde"] }
 crossbeam = { version = "^0.8" }
 flate2 = { version = "1", optional = true }
-futures = "0.3.5"
-indexmap = { version = "^1.6", features = ["serde-1"] }
+futures = { version = "0.3.30", default-features = false, features = ["async-await", "executor", "std"] }
+indexmap = { version = "^2.3", default-features = false, features = ["serde", "std"] }
+itoa = { version = "1.0.11", default-features = false }
 libc = { version = "0.2.125", default-features = false, features = ["extra_traits"] }
 libz-sys = { version = "1.1", features = ["static"], optional = true }
 linkify = { version = "^0.10", default-features = false }
-melib = { path = "../melib", version = "0.8.7", features = [] }
-nix = { version = "0.27", default-features = false, features = ["signal", "poll", "term", "ioctl", "process"] }
-serde = "1.0.71"
-serde_derive = "1.0.71"
-serde_json = "1.0"
+melib = { path = "../melib", version = "0.8.10", features = [] }
+nix = { version = "0.29", default-features = false, features = ["signal", "poll", "term", "ioctl", "process"] }
+regex = { version = "1" }
+serde = { version = "1.0.71" }
+serde_derive = { version = "1.0.71" }
+serde_json = { version = "1.0" }
 signal-hook = { version = "^0.3", default-features = false, features = ["iterator"] }
 signal-hook-registry = { version = "1.2.0", default-features = false }
 smallvec = { version = "^1.5.0", features = ["serde"] }
-structopt = { version = "0.3.14", default-features = false }
-svg_crate = { version = "^0.13", optional = true, package = "svg" }
+structopt = { version = "0.3.26", default-features = false }
+# svg_crate = { version = "^0.13", optional = true, package = "svg" }
 termion = { version = "1.5.1", default-features = false }
 toml = { version = "0.8", default-features = false, features = ["display","preserve_order","parse"] }
-xdg = "2.1.0"
-
-[dependencies.pcre2]
-# An [env] entry in .cargo/config.toml should force a static build instead of
-# looking for a system library.
-version = "0.2.3"
-optional = true
+xdg = { version = "2.1.0" }
 
 [features]
 default = ["sqlite3", "notmuch", "smtp", "dbus-notifications", "gpgme", "cli-docs", "jmap", "static"]
@@ -58,10 +56,9 @@ jmap = ["melib/jmap"]
 sqlite3 = ["melib/sqlite3"]
 smtp = ["melib/smtp"]
 smtp-trace = ["smtp", "melib/smtp-trace"]
-regexp = ["dep:pcre2"]
 dbus-notifications = ["dep:notify-rust"]
 cli-docs = ["dep:flate2"]
-svgscreenshot = ["dep:svg_crate"]
+# svgscreenshot = ["dep:svg_crate"]
 gpgme = ["melib/gpgme"]
 # Static / vendoring features.
 tls-static = ["melib/tls-static"]
@@ -77,17 +74,18 @@ debug-tracing = ["melib/debug-tracing"]
 
 [build-dependencies]
 flate2 = { version = "1", optional = true }
-proc-macro2 = "1.0.37"
-quote = "^1.0"
-regex = "1"
+proc-macro2 = { version = "1.0.37" }
+quote = { version = "^1.0" }
+regex = { version = "1" }
 syn = { version = "1", features = [] }
 
 [dev-dependencies]
 assert_cmd = { version = "=2.0.13" }
 flate2 = { version = "1" }
 predicates = { version = "3" }
-regex = "1"
-tempfile = "3.3"
+regex = { version = "1" }
+rusty-fork = { version = "0.3.0" }
+tempfile = { version = "3.3" }
 
 [target.'cfg(target_os="linux")'.dependencies]
 notify-rust = { version = "^4", default-features = false, features = ["dbus"], optional = true }

meli/build.rs

@@ -75,10 +75,20 @@ fn main() {
 
         cl("docs/meli.1", "meli.txt.gz", false);
         cl("docs/meli.conf.5", "meli.conf.txt.gz", false);
+        cl(
+            "docs/meli.conf.examples.5",
+            "meli.conf.examples.txt.gz",
+            false,
+        );
         cl("docs/meli-themes.5", "meli-themes.txt.gz", false);
         cl("docs/meli.7", "meli.7.txt.gz", false);
         cl("docs/meli.1", "meli.mdoc.gz", true);
         cl("docs/meli.conf.5", "meli.conf.mdoc.gz", true);
+        cl(
+            "docs/meli.conf.examples.5",
+            "meli.conf.examples.mdoc.gz",
+            true,
+        );
         cl("docs/meli-themes.5", "meli-themes.mdoc.gz", true);
         cl("docs/meli.7", "meli.7.mdoc.gz", true);
     }

meli/config_macros.rs

@@ -58,9 +58,12 @@ pub(crate) fn override_derive(filenames: &[(&str, &str)]) {
 
 //! This module is automatically generated by `config_macros.rs`.
 
-use super::*;
 use melib::HeaderName;
 
+use indexmap::IndexSet;
+
+use crate::conf::{*, data_types::*};
+
 "##
     .to_string();
 

meli/docs/external-tools.md

@@ -2,7 +2,7 @@
 
 ## Sending mail with a command line tool
 
-`composing.send_mail` can use either settings for an SMTP server or a shell 
+`send_mail` can use either settings for an SMTP server or a shell 
 command to which it pipes new mail to.
 
 ### `msmtp` and `send_mail`
@@ -12,7 +12,6 @@ with many SMTP servers. It supports queuing and other small useful features.
 See [the documentation](https://marlam.de/msmtp/msmtp.html).
 
 ```toml
-[composing]
 send_mail = 'msmtp --logfile=/home/user/.mail/msmtp.log --read-recipients 
 --read-envelope-from'
 ```
@@ -120,3 +119,32 @@ The HTML of the e-mail is piped into `html_filter`'s standard input.
 If your account's syncing is handled by an external tool, you can use the 
 refresh shortcuts within `meli` to call this tool with 
 `accounts.refresh_command`.
+
+## Viewing binary attachments such as images inside your terminal
+
+If you have a specific terminal tool that lets you pipe binary data to it and
+it outputs command suitable for the terminal, you can use the `pipe-attachment`
+command to view/preview attachments without leaving `meli` or opening a GUI app.
+
+This requires the output to be interactive otherwise `meli` will run the tool
+and immediately return, probably too quickly for you to notice the output in
+your terminal. A general solution is to pipe the output to an interactive pager
+like `less` which requires the user to exit it interactively.
+
+The [`chafa`] tool can be used for images in this example:
+
+Write a wrapper script that outputs the tool's output into a pager, for example
+`less`. If the output contains ANSI escape codes (i.e. colors, or bold/italic
+text) make sure to use `less -r` to preserve those codes.
+
+```sh
+#!/bin/sh
+
+/bin/chafa "$@" | less -r
+```
+
+Save it somewhere as a file with executable permissions and you can use
+`pipe-attachment 1 /path/to/your/chafa/wrapper` to view the first attachment as
+an image with [`chafa`].
+
+[`chafa`]: https://hpjansson.org/chafa/

meli/docs/historical-manpages/copyright

@@ -0,0 +1,42 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Comment: This directory contains various manual pages that may be of use to meli users.
+
+Files: mailaddr.7.gz
+Comment: Sourced from debian manpages package.
+Copyright: Copyright (c) 1983, 1987 The Regents of the University of California.
+License: 6.5 (Berkeley) 2/14/89
+ Redistribution and use in source and binary forms are permitted
+ provided that the above copyright notice and this paragraph are
+ duplicated in all such forms and that any documentation,
+ advertising materials, and other materials related to such
+ distribution and use acknowledge that the software was developed
+ by the University of California, Berkeley.  The name of the
+ University may not be used to endorse or promote products derived
+ from this software without specific prior written permission.
+ THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+Files: maildir.5.en.gz
+Comment: Sourced from debian maildrop package.
+Copyright: Copyright 1998 - 2007 Double Precision, Inc.
+License: GPLv3 with OpenSSL linking extension
+ This software is released under the GPL, version 3 (see COPYING.GPL).
+ Additionally, compiling, linking, and/or using the OpenSSL toolkit in
+ conjunction with this software is allowed.
+
+Files: mbox.5.en.gz
+Comment: Sourced from debian mutt package.
+Copyright: Copyright (C) 2000 Thomas Roessler <roessler@does-not-exist.org>
+License: public-domain
+ This document is in the public domain and may be distributed and
+ changed arbitrarily.
+
+Files: mbox.5qmail.en.gz
+Comment: Sourced from (now obsolete) debian qmail package.
+Copyright: D. J. Bernstein
+License:  From http://cr.yp.to/qmail/dist.html
+ I hereby place the qmail package (in particular, qmail-1.03.tar.gz,
+ with MD5 checksum 622f65f982e380dbe86e6574f3abcb7c) into the public
+ domain.  You are free to modify the package, distribute modified
+ versions, etc.

meli/docs/meli.1

@@ -214,14 +214,30 @@ See
 for the location of the mailcap files and
 .Xr mailcap 5
 for their syntax.
-You can save individual attachments with the
-.Command save-attachment Ar INDEX Ar path-to-file
-command.
+You can save individual attachments with the following command:
+.Command save\-attachment Ar INDEX Ar path\-to\-file
 .Ar INDEX
 is the attachment's index in the listing.
-If the path provided is a directory, the attachment is saved with its filename set to the filename in the attachment, if any.
-If the 0th index is provided, the entire message is saved.
-If the path provided is a directory, the message is saved as an eml file with its filename set to the messages message-id.
+.Bl -tag -compact -width 8n
+.It If the path provided is a directory, the attachment is saved with its filename set to the filename in the attachment, if any.
+.It If the 0th index is provided, the entire message is saved.
+.It If the path provided is a directory, the message is saved as an eml file with its filename set to the messages message\-id.
+.El
+.Pp
+You can pipe individual attachments to binaries with the following command:
+.Command pipe\-attachment Ar INDEX Ar binary Ar ARGS
+Example usage with the
+.Xr less 1
+pager:
+.D1 pipe\-attachment 0 less
+If the binary does not wait for your input before exiting, you will probably
+not see its output since you will return back to the user interface
+immediately.
+You can write a wrapper script that pipes your binary's output to
+.Dl less
+or
+.Dl less \-r
+if you want to preserve the ANSI escape codes in the pager's output.
 .Sh SEARCH
 Each e\-mail storage backend has a default search method assigned.
 .Em IMAP
@@ -250,7 +266,7 @@ To enable sqlite3 indexing for an account set
 to
 .Em sqlite3
 in the configuration file and to create the sqlite3 index issue command:
-.Command index Ar ACCOUNT_NAME Ns
+.Command reindex Ar ACCOUNT_NAME Ns
 To search in the message body type your keywords without any special formatting.
 To search in specific fields, prepend your search keyword with "field:" like so:
 .Pp
@@ -287,10 +303,12 @@ Sqlite3 on the contrary at reasonable mailbox sizes should have a non noticeable
 .HorizontalRule
 .Bl -dash -compact
 .It
-.Li query = \&"(\&" query \&")\&" | from | to | cc | bcc | alladdresses | subject | flags | has_attachments | query \&"or\&" query | query \&"and\&" query | not query
+.Li query = \&"(\&" query \&")\&" | from | to | cc | bcc | message_id | in_reply_to | references | header | all_addresses | subject | flags | has_attachment | query \&"or\&" query | query \&"and\&" query | not query
 .It
 .Li not = \&"not\&" | \&"!\&"
 .It
+.Li has_attachment = \&"has:attachment\&" | \&"has:attachments\&"
+.It
 .Li quoted = ALPHA / SP *(ALPHA / DIGIT / SP)
 .It
 .Li term = ALPHA *(ALPHA / DIGIT) | DQUOTE quoted DQUOTE
@@ -301,6 +319,8 @@ Sqlite3 on the contrary at reasonable mailbox sizes should have a non noticeable
 .It
 .Li flagterm = flagval | flagval \&",\&" flagterm
 .It
+.Li flags = \&"flag:\&" flag | \&"flags:\&" flag | \&"tag:\&" flag | \&"tags:\&" flag | \&"is:\&" flag
+.It
 .Li from = \&"from:\&" term
 .It
 .Li to = \&"to:\&" term
@@ -309,11 +329,21 @@ Sqlite3 on the contrary at reasonable mailbox sizes should have a non noticeable
 .It
 .Li bcc = \&"bcc:\&" term
 .It
-.Li alladdresses = \&"alladdresses:\&" term
+.Li message_id = \&"message-id:\&" term | \&"msg-id:\&" term
+.It
+.Li in_reply_to = \&"in-reply-to:\&" term
+.It
+.Li references = \&"references:\&" term
+.It
+.Li header = \&"header:\&" field_name \&",\&" field_value
+.It
+.Li field_name = term
+.It
+.Li field_value = term
+.It
+.Li all_addresses = \&"all-addresses:\&" term
 .It
 .Li subject = \&"subject:\&" term
-.It
-.Li flags = \&"flags:\&" flag | \&"tags:\&" flag | \&"is:\&" flag
 .El
 .Sh FLAGS
 .Nm
@@ -436,7 +466,7 @@ supports three kinds of contact backends:
 .Bl -enum -compact
 .It
 an internal format that gets saved under
-.Pa $XDG_DATA_HOME/meli/account_name/addressbook Ns
+.Pa $XDG_DATA_HOME/meli/account_name/contacts Ns
 \&.
 .It
 vCard files (v3, v4) through the
@@ -491,9 +521,9 @@ threaded:shows threads as a tree structure
 plain:shows one row per mail, regardless of threading
 .TE
 .Bl -tag -width 36n
-.It Cm sort Ar subject | date \  Ar asc | desc
+.It Cm sort Oo Ar subject | date Oc Ar asc | desc
 sort mail listing
-.It Cm subsort Ar subject | date \  Ar asc | desc
+.It Cm subsort Oo Ar subject | date Oc Ar asc | desc
 sorts only the first level of replies.
 .It Cm go Ar n
 where
@@ -514,7 +544,7 @@ select threads matching
 query.
 .It Cm clear-selection
 Clear current selection.
-.It Cm set seen, set unseen
+.It Cm set Ar seen | unseen
 Set seen status of message.
 .It Cm import Ar FILEPATH Ar MAILBOX_PATH
 Import mail from file into given mailbox.
@@ -523,7 +553,7 @@ Copy or move to other mailbox.
 .It Cm copyto, moveto Ar ACCOUNT Ar MAILBOX_PATH
 Copy or move to another account's mailbox.
 .It Cm delete
-Delete selected threads.
+Delete selected entries.
 .It Cm export-mbox Ar FILEPATH
 Export selected threads to mboxcl2 file.
 .It Cm create\-mailbox Ar ACCOUNT Ar MAILBOX_PATH
@@ -542,9 +572,9 @@ This action is irreversible.
 .Ss Mail view commands
 .HorizontalRule
 .Bl -tag -width 36n
-.It Cm pipe Ar EXECUTABLE Ar ARGS
+.It Cm pipe Ar EXECUTABLE Oo Ar ARGS Oc
 pipe pager contents to binary
-.It Cm filter Ar EXECUTABLE Ar ARGS
+.It Cm filter Ar EXECUTABLE Oo Ar ARGS Oc
 filter and display pager contents through command
 .It Cm filter
 select a filter from
@@ -568,7 +598,7 @@ open list archive with
 .Bl -tag -width 36n
 .It Cm mailto Ar MAILTO_ADDRESS
 Opens a composer tab with initial values parsed from the
-.Li mailto:
+.Li mailto :
 address.
 .It Cm add-attachment Ar PATH
 in composer, add
@@ -587,7 +617,11 @@ in
 Launch command
 .Ar CMD Ar ARGS Ns
 \&.
-The command should print file paths in stderr, separated by NULL bytes.
+The command should print file paths in stdout, separated by NUL bytes.
+Example usage with
+.Xr fzf 1 Ns
+:
+.D1 add-attachment-file-picker < fzf --print0
 .It Cm remove-attachment Ar INDEX
 remove attachment with given index
 .It Cm toggle sign
@@ -635,7 +669,7 @@ catchall for general errors
 process panic
 .El
 .Sh ENVIRONMENT
-.Bl -tag -width "$XDG_CONFIG_HOME/meli/plugins/*" -offset indent
+.Bl -tag -width "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" -offset indent
 .It Ev EDITOR
 Specifies the editor to use
 .It Ev MELI_CONFIG
@@ -651,7 +685,7 @@ overrides this.
 .Sh FILES
 .Nm
 uses the following parts of the XDG standard:
-.Bl -tag -width "$XDG_CONFIG_HOME/meli/plugins/*" -offset indent
+.Bl -tag -width "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" -offset indent
 .It Ev XDG_CONFIG_HOME
 defaults to
 .Pa ~/.config/
@@ -661,17 +695,13 @@ defaults to
 .El
 .Pp
 and appropriates the following locations:
-.Bl -tag -width "$XDG_CONFIG_HOME/meli/plugins/*" -offset indent
+.Bl -tag -width "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" -offset indent
 .It Pa $XDG_CONFIG_HOME/meli/
 User configuration directory
 .It Pa $XDG_CONFIG_HOME/meli/config.toml
 User configuration file, see
 .Xr meli.conf 5
 for its syntax and values.
-.It Pa $XDG_CONFIG_HOME/meli/hooks/*
-Reserved for event hooks.
-.It Pa $XDG_CONFIG_HOME/meli/plugins/*
-Reserved for plugin files.
 .It Pa $XDG_CACHE_HOME/meli/*
 Internal cached data used by meli.
 .It Pa $XDG_DATA_HOME/meli/*

meli/docs/meli.7

@@ -412,9 +412,9 @@ which shows more than one line per thread which can include multiple e\-mails wi
 .Sy Performing actions on entries and/or selections\&.
 .Pp
 Press
-.Shortcut v listing select_entry
+.Shortcut V listing select_entry
 to toggle the selection of a single entry.
-.Qq select_entry
+.Shortcut v listing select_motion
 can be prefixed by a number modifier and affixed by a scrolling motion (up or down) to select multiple entries.
 .Tg number-modifier
 Simple set operations can be performed on a selection with these shortcut modifiers:
@@ -713,7 +713,11 @@ in
 Launch command
 .Ar CMD Ar ARGS Ns
 \&.
-The command should print file paths in stderr, separated by NULL bytes.
+The command should print file paths in stdout, separated by NUL bytes.
+Example usage with
+.Xr fzf Ns
+:
+.D1 add-attachment-file-picker < fzf --print0
 .It Cm remove\-attachment Ar INDEX
 remove attachment with given index
 .It Cm toggle sign

meli/docs/meli.conf.5

@@ -293,6 +293,11 @@ Path of
 .Xr mutt 1
 compatible alias file in the option
 They are parsed and imported read-only.
+.It Ic notmuch_address_book_query Ar String
+.Pq Em optional
+Query passed to
+.Qq Li notmuch address
+to import contacts into meli. Contacts are parsed and imported read-only.
 .It Ic mailboxes Ar mailbox
 .Pq Em optional
 Configuration for each mailbox.
@@ -415,6 +420,12 @@ Do not validate
 .Em TLS
 certificates.
 .Pq Em false \" default value
+.It Ic offline_cache Ar boolean
+.Pq Em optional
+Keep mail headers in an
+.Sy sqlite3
+database.
+.Pq Em true \" default value
 .It Ic use_idle Ar boolean
 .Pq Em optional
 Use
@@ -693,6 +704,13 @@ Store seen status locally in an
 .Sy sqlite3
 database.
 .Pq Em true \" default value
+.It Ic timeout Ar integer
+.Pq Em optional
+Timeout to use for server connections in seconds.
+A timeout of
+.Li 0
+seconds means there is no timeout.
+.Pq Em 16 \" default value
 .El
 .Pp
 You have to explicitly state the groups you want to see in the
@@ -882,7 +900,7 @@ header in new drafts.
 .It Ic default_header_values Ar hash table String[String]
 .Pq Em optional
 Default header values used when creating a new draft.
-.Pq Em [] \" default value
+.Pq Em {} \" default value
 .It Ic wrap_header_preamble Ar Option<(String, String)>
 .Pq Em optional
 Wrap header pre-ample when editing a draft in an editor.
@@ -974,7 +992,7 @@ Example:
 .Bd -literal
 [composing]
 editor_cmd = '~/.local/bin/vim +/^$'
-embed = true
+embedded_pty = true
 custom_compose_hooks = [ { name ="spellcheck", command="aspell --mode email --dont-suggest --ignore-case list" }]
 .Ed
 .\"
@@ -1017,6 +1035,36 @@ or draft body mention attachments but they are missing.
 .Ic empty-draft-warn
 — Warn if draft has no subject and no body.
 .El
+.It Ic signature_file Ar Path
+.Pq Em optional
+Plain text file with signature that will pre-populate an email draft.
+Signatures must be explicitly enabled to be used, otherwise this setting will be ignored.
+.Pq Em None \" default value
+.It Ic use_signature Ar bool
+Pre-populate email drafts with signature, if any.
+.Sy meli
+will lookup the signature value in this order:
+.Bl -enum -compact
+.It
+The
+.Ic signature_file
+setting.
+.It
+.Pa ${XDG_CONFIG_DIR}/meli/<account>/signature
+.It
+.Pa ${XDG_CONFIG_DIR}/meli/signature
+.It
+.Pa ${XDG_CONFIG_DIR}/signature
+.It
+.Pa ${HOME}/.signature
+.It
+No signature otherwise.
+.El
+.Pq Em false \" default value
+.It Ic signature_delimiter Ar String
+.Pq Em optional
+Signature delimiter, that is, text that will be prefixed to your signature to separate it from the email body.
+.Pq Ql \en\en\-\- \en
 .El
 .\"
 .\"
@@ -1237,6 +1285,9 @@ Manually request a mailbox refresh.
 .It Ic set_seen
 Set thread as seen.
 .Pq Em n \" default value
+.It Ic send_to_trash
+Send entry to trash folder.
+.Pq Em D \" default value
 .It Ic union_modifier
 Union modifier.
 .Pq Em C-u \" default value
@@ -1247,7 +1298,10 @@ Difference modifier.
 Intersection modifier.
 .Pq Em i \" default value
 .It Ic select_entry
-Select thread entry.
+Select (or toggle) thread entry.
+.Pq Em V \" default value
+.It Ic select_motion
+Perform select motion with a movement.
 .Pq Em v \" default value
 .It Ic increase_sidebar
 Increase sidebar width.
@@ -1317,6 +1371,9 @@ Create new contact.
 .It Ic edit_contact
 Edit contact under cursor.
 .Pq Em e \" default value
+.It Ic export_contact
+Export contact under cursor to .vcf.
+.Pq Em E \" default value
 .It Ic delete_contact
 Delete contact under cursor.
 .Pq Em d \" default value
@@ -1697,6 +1754,15 @@ Show relative indices in listings to quickly help with jumping to them.
 .It Ic hide_sidebar_on_launch Ar boolean
 Start app with sidebar hidden.
 .Pq Em false \" default value
+.It Ic mail_view_divider Ar char
+Character to show in the divider space between mail view and listing.
+.Pq Em ' ' \" default value
+.It Ic thread_layout Ar "auto" | "vertical" | "horizontal"
+Force specific layout in thread view.
+The layout can also be toggled at runtime with the
+.Li listing.toggle_layout
+shortcut.
+.Pq Em "auto"
 .El
 .Ss Examples of sidebar mailbox tree customization
 .HorizontalRule
@@ -1972,7 +2038,7 @@ title is set.
 .Pq Em "meli" \" default value
 .It Ic file_picker_command Ar String
 .Pq Em optional
-Set command that prints file paths in stderr, separated by NULL bytes.
+Set command that prints file paths in stdout, separated by NUL bytes.
 Used with
 .Ic add-attachment-file-picker
 when composing new mail.

meli/docs/meli.conf.examples.5

@@ -0,0 +1,227 @@
+.\" meli - meli.conf.examples.5
+.\"
+.\" Copyright 2024 Manos Pitsidianakis
+.\"
+.\" This file is part of meli.
+.\"
+.\" meli is free software: you can redistribute it and/or modify
+.\" it under the terms of the GNU General Public License as published by
+.\" the Free Software Foundation, either version 3 of the License, or
+.\" (at your option) any later version.
+.\"
+.\" meli is distributed in the hope that it will be useful,
+.\" but WITHOUT ANY WARRANTY; without even the implied warranty of
+.\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+.\" GNU General Public License for more details.
+.\"
+.\" You should have received a copy of the GNU General Public License
+.\" along with meli. If not, see <http://www.gnu.org/licenses/>.
+.\"
+.\" SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+.de HorizontalRule
+.\"\l'\n(.l\(ru1.25'
+.sp
+..
+.de LiteralStringValue
+.Sm
+.Po Qo
+.Em Li \\$1
+.Qc Pc
+.Sm
+..
+.de LiteralStringValueRenders
+.LiteralStringValue \\$1
+.shift 1
+.Bo
+.Sm
+Rendered as:
+.Li r##
+.Qo
+\\$1
+.Qc
+.Li ##
+.Bc
+.Sm
+..
+.\".Dd November 11, 2022
+.Dd November 22, 2024
+.Dt MELI.CONF.EXAMPLES 5
+.Os
+.Sh NAME
+.Nm meli.conf examples
+.Nd Example configurations for various mail backends supported by the
+.Xr meli 1
+terminal e-mail client
+.\"
+.\"
+.\"
+.\"
+.\"
+.\".Sh SYNOPSIS
+.\".Pa $XDG_CONFIG_HOME/meli/config.toml
+.\".\"
+.\".\"
+.\".\"
+.\".\"
+.\".\"
+.\".Sh DESCRIPTION
+.Sh MAILDIR ACCOUNT
+An example configuration:
+.\"
+.\"
+.\"
+.Bd -literal
+[accounts.account-name]
+root_mailbox = "/path/to/root/folder"
+format = "Maildir"
+listing.index_style = "Compact"
+identity="email@example.com"
+display_name = "Name"
+send_mail = 'msmtp --read-recipients --read-envelope-from'
+#send_mail = { hostname = "smtp.example.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
+
+# Set mailbox-specific settings
+  [accounts.account-name.mailboxes]
+  "INBOX" = { alias="Inbox" } #inline table
+  "drafts" = { alias="Drafts" } #inline table
+  [accounts.account-name.mailboxes."foobar-devel"] # or a regular table
+    ignore = true # don't show notifications for this mailbox
+.Ed
+.\"
+.\"
+.\"
+.Sh MBOX ACCOUNT
+An example configuration:
+.\"
+.\"
+.\"
+.Bd -literal
+[accounts.account-name]
+root_mailbox = "/var/mail/username"
+format = "mbox"
+listing.index_style = "Compact"
+identity="username@hostname.local"
+composing.send_mail = '/bin/false'
+.Ed
+.Sh IMAP ACCOUNT
+.Bd -literal
+[accounts."account-name"]
+root_mailbox = "INBOX"
+format = "imap"
+server_hostname="mail.example.com"
+server_password="pha2hiLohs2eeeish2phaii1We3ood4chakaiv0hien2ahie3m"
+server_username="username@example.com"
+#server_port="993" # imaps
+server_port="143" # STARTTLS
+use_starttls=true #optional
+send_mail = { hostname = "smtp.example.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
+display_name = "Name Name"
+identity = "username@example.com"
+## show only specific mailboxes:
+#subscribed_mailboxes = ["INBOX", "INBOX/Sent", "INBOX/Drafts", "INBOX/Junk"]
+.Ed
+.Ss Gmail account example
+.Bd -literal
+[accounts."account-name"]
+root_mailbox = '[Gmail]'
+format = "imap"
+send_mail = { hostname = "smtp.gmail.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
+server_hostname='imap.gmail.com'
+server_password="password"
+server_username="username@gmail.com"
+server_port="993"
+listing.index_style = "Conversations"
+identity = "username@gmail.com"
+display_name = "Name Name"
+# Gmail auto saves sent mail to Sent folder, so don't duplicate the effort:
+composing.store_sent_mail = false
+.Ed
+
+.Sh JMAP ACCOUNT
+The
+.Ic server_url
+option must hold the address of the server's session endpoint.
+.Bd -literal
+[accounts."account-name"]
+root_mailbox = "INBOX"
+format = "jmap"
+send_mail = 'server_submission'
+server_url="http://localhost:8080"
+server_username="user@hostname.local"
+server_password="changeme"
+identity = "user@hostname.local"
+.Ed
+.Ss fastmail.com account example
+.Lk https://fastmail.com/ Fastmail
+uses the
+.Em Bearer token
+authentication mechanism, so the option
+.Ic use_token
+must be enabled:
+.Bd -literal
+[accounts."fastmail-jmap"]
+root_mailbox = "INBOX"
+format = "jmap"
+server_url="https://api.fastmail.com/jmap/session"
+server_username="user@fastmail.com"
+server_password="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+use_token=true
+identity = "My Name <user@fastmail.com>"
+send_mail = "server_submission"
+.Ed
+.Sh NOTMUCH ACCOUNT
+TODO
+.Sh NNTP / USENET ACCOUNT
+TODO
+.Sh SEE ALSO
+.Xr meli.conf 5 ,
+.Xr meli 1 ,
+.Xr meli-themes 5
+.Sh AUTHORS
+Copyright 2017\(en2024
+.An Manos Pitsidianakis Aq Mt manos@pitsidianak.is
+.Pp
+Released under the GPL, version 3 or greater.
+This software carries no warranty of any kind.
+.Po
+See
+.Pa COPYING
+for full copyright and warranty notices.
+.Pc
+.Ss Links
+.Bl -item -compact
+.It
+.Lk https://meli\-email.org "Website"
+.It
+.Lk https://git.meli\-email.org/meli/meli "Main\ git\ repository\ and\ issue\ tracker"
+.It
+.Lk https://codeberg.org/meli/meli "Official\ read-only\ git\ mirror\ on\ codeberg.org"
+.It
+.Lk https://github.com/meli/meli "Official\ read-only\ git\ mirror\ on\ github.com"
+.It
+.Lk https://crates.io/crates/meli "meli\ crate\ on\ crates.io"
+.El
+.\" [pager]
+.\" filter = "COLUMNS=72 /usr/local/bin/pygmentize -l email"
+.\" html_filter = "w3m -I utf-8 -T text/html"
+
+.\" [notifications]
+.\" script = "notify-send"
+
+.\" [composing]
+.\" # required for sending e-mail
+.\" send_mail = 'msmtp --read-recipients --read-envelope-from'
+.\" #send_mail = { hostname = "smtp.example.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
+.\" editor_command = 'vim +/^$'
+
+.\" [shortcuts]
+.\" [shortcuts.composing]
+.\" edit = 'e'
+
+.\" [shortcuts.listing]
+.\" new_mail = 'm'
+.\" set_seen = 'n'
+
+.\" [terminal]
+.\" theme = "light"

meli/docs/samples/sample-config.toml

@@ -11,9 +11,12 @@
 #[accounts.account-name]
 #root_mailbox = "/path/to/root/mailbox"
 #format = "Maildir"
+#send_mail = 'msmtp --read-recipients --read-envelope-from'
+##send_mail = { hostname = "smtp.example.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
 #listing.index_style = "Conversations" # or [plain, threaded, compact]
 #identity="email@example.com"
 #display_name = "Name"
+## Need to explicitly list mailboxes of interest:
 #subscribed_mailboxes = ["INBOX", "INBOX/Sent", "INBOX/Drafts", "INBOX/Junk"]
 #
 ## Set mailbox-specific settings
@@ -26,6 +29,7 @@
 #[accounts.mbox]
 #root_mailbox = "/var/mail/username"
 #format = "mbox"
+#send_mail = 'false'
 #listing.index_style = "Compact"
 #identity="username@hostname.local"
 #
@@ -33,6 +37,7 @@
 #[accounts."imap"]
 #root_mailbox = "INBOX"
 #format = "imap"
+#send_mail = { hostname = "smtp.example.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
 #server_hostname="mail.example.com"
 #server_password="pha2hiLohs2eeeish2phaii1We3ood4chakaiv0hien2ahie3m"
 #server_username="username@example.com"
@@ -42,15 +47,14 @@
 #listing.index_style = "Conversations"
 #identity = "username@example.com"
 #display_name = "Name Name"
-### match every mailbox:
-#subscribed_mailboxes = ["*" ]
-### match specific mailboxes:
+### show only specific mailboxes, overriding the server's subscribed status.
 ##subscribed_mailboxes = ["INBOX", "INBOX/Sent", "INBOX/Drafts", "INBOX/Junk"]
 #
 ## Setting up an account for an already existing notmuch database
 ##[accounts.notmuch]
 ##root_mailbox = "/path/to/folder" # where .notmuch/ directory is located
 ##format = "notmuch"
+##send_mail = 'msmtp --read-recipients --read-envelope-from'
 ##listing.index_style = "conversations"
 ##identity="username@example.com"
 ##display_name = "Name Name"
@@ -64,6 +68,7 @@
 #[accounts."gmail"]
 #root_mailbox = '[Gmail]'
 #format = "imap"
+#send_mail = { hostname = "smtp.gmail.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
 #server_hostname='imap.gmail.com'
 #server_password="password"
 #server_username="username@gmail.com"
@@ -71,22 +76,18 @@
 #listing.index_style = "Conversations"
 #identity = "username@gmail.com"
 #display_name = "Name Name"
-### match every mailbox:
-#subscribed_mailboxes = ["*" ]
-#composing.send_mail = 'msmtp --read-recipients --read-envelope-from'
-### Gmail auto saves sent mail to Sent folder, so don't duplicate the effort:
+## Gmail auto saves sent mail to Sent folder, so don't duplicate the effort:
 #composing.store_sent_mail = false
 #
 ##[accounts."jmap account"]
 ##root_mailbox = "INBOX"
 ##format = "jmap"
+##send_mail = 'server_submission'
 ##server_url="http://localhost:8080"
 ##server_username="user@hostname.local"
 ##server_password="changeme"
 ##listing.index_style = "Conversations"
 ##identity = "user@hostname.local"
-##subscribed_mailboxes = ["*", ]
-##composing.send_mail = 'server_submission'
 #
 #[pager]
 #filter = "COLUMNS=72 /usr/local/bin/pygmentize -l email"
@@ -128,12 +129,8 @@
 #page_down = "PageDown"
 #
 #[composing]
-##required for sending e-mail
-#send_mail = 'msmtp --read-recipients --read-envelope-from'
-##send_mail = { hostname = "smtp.example.com", port = 587, auth = { type = "auto", username = "user", password = { type = "command_eval", value = "gpg2 --no-tty -q -d ~/.passwords/user.gpg" } }, security = { type = "STARTTLS" } }
 #editor_command = 'vim +/^$' # optional, by default $EDITOR is used.
 #
-#
 #[pgp]
 #auto_sign = false # always sign sent messages
 #auto_verify_signatures = true # always verify signatures when reading signed e-mails

meli/docs/samples/themes/ibm-modern.toml

@@ -0,0 +1,73 @@
+[terminal.themes.ibm-modern]
+"theme_default" = { fg = "$Black100", bg = "$White0", attrs = "Default" }
+"status.bar" = { fg = "$Black100", bg = "$Magenta40", attrs = "theme_default" }
+"status.notification" = { fg = "$Black100", bg = "$Magenta40", attrs = "theme_default" }
+"tab.focused" = { fg = "$White0", bg = "$Purple40", attrs = "theme_default" }
+"tab.unfocused" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"tab.bar" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"widgets.list.header" = { fg = "theme_default", bg = "theme_default", attrs = "Bold" }
+"widgets.form.label" = { fg = "theme_default", bg = "theme_default", attrs = "Bold" }
+"widgets.form.field" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"widgets.form.highlighted" = { fg = "theme_default", bg = "$Cyan30", attrs = "theme_default" }
+"widgets.options.highlighted" = { fg = "$Cyan10", bg = "$Teal30", attrs = "theme_default" }
+"mail.sidebar" = { fg = "theme_default", bg = "$CoolGray10", attrs = "theme_default" }
+"mail.sidebar_account_name" = { fg = "mail.sidebar", attrs = "Bold" }
+"mail.sidebar_unread_count" = { fg = "$Magenta40", bg = "$CoolGray10" }
+"mail.sidebar_index" = { fg = "theme_default", bg = "theme_default" }
+"mail.sidebar_highlighted" = { fg = "theme_default", bg = "$CoolGray10" }
+"mail.sidebar_highlighted_unread_count" = { from = "mail.sidebar_highlighted" }
+"mail.sidebar_highlighted_index" = { fg = "mail.sidebar_index", bg = "mail.sidebar_highlighted", attrs = "theme_default" }
+"mail.sidebar_highlighted_account" = { fg = "mail.sidebar_highlighted", bg = "mail.sidebar_highlighted", attrs = "theme_default" }
+"mail.sidebar_highlighted_account_name" = { fg = "mail.sidebar_highlighted_account", bg = "mail.sidebar_highlighted_account", attrs = "Bold" }
+"mail.sidebar_highlighted_account_unread_count" = { fg = "mail.sidebar_unread_count", bg = "mail.sidebar_highlighted_account", attrs = "theme_default" }
+"mail.sidebar_highlighted_account_index" = { fg = "mail.sidebar_index", bg = "mail.sidebar_highlighted_account", attrs = "theme_default" }
+"mail.listing.compact.even" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.compact.odd" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.compact.even_unseen" = { fg = "$Black100", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.compact.odd_unseen" = { fg = "$Black100", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.compact.even_selected" = { fg = "$CoolGray10", attrs = "theme_default" }
+"mail.listing.compact.odd_selected" = { fg = "$CoolGray10", attrs = "theme_default" }
+"mail.listing.compact.even_highlighted" = { fg = "theme_default", bg = "$CoolGray10", attrs = "theme_default" }
+"mail.listing.compact.odd_highlighted" = { fg = "theme_default", bg = "$CoolGray10", attrs = "theme_default" }
+"mail.listing.conversations" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.conversations.subject" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.conversations.from" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.conversations.date" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.conversations.unseen" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.conversations.highlighted" = { fg = "theme_default", bg = "$CoolGray10", attrs = "Bold" }
+"mail.listing.conversations.selected" = { fg = "$CoolGray10", bg = "$CoolGray30", attrs = "theme_default" }
+"mail.listing.plain.even" = { fg = "mail.listing.compact.even", bg = "mail.listing.compact.even", attrs = "theme_default" }
+"mail.listing.plain.odd" = { fg = "mail.listing.compact.odd", bg = "mail.listing.compact.odd", attrs = "theme_default" }
+"mail.listing.plain.even_unseen" = { fg = "$Black100", bg = "$CoolGray30", attrs = "theme_default" }
+"mail.listing.plain.odd_unseen" = { fg = "$Black100", bg = "$CoolGray30", attrs = "theme_default" }
+"mail.listing.plain.even_selected" = { fg = "theme_default", bg = "LightCoral", attrs = "theme_default" }
+"mail.listing.plain.odd_selected" = { fg = "theme_default", bg = "LightCoral", attrs = "theme_default" }
+"mail.listing.plain.even_highlighted" = { fg = "theme_default", bg = "$CoolGray10", attrs = "theme_default" }
+"mail.listing.plain.odd_highlighted" = { fg = "theme_default", bg = "$CoolGray10", attrs = "theme_default" }
+"mail.view.headers" = { fg = "$Black100", bg = "$Purple40", attrs = "theme_default" }
+"mail.view.headers_names" = { fg = "$Black100", bg = "$Magenta40", attrs = "mail.view.headers" }
+"mail.view.headers_area" = { fg = "theme_default", bg = "$Purple40", attrs = "theme_default" }
+"mail.view.body" = { fg = "theme_default", bg = "theme_default", attrs = "theme_default" }
+"mail.view.thread.indentation.a" = { fg = "theme_default", bg = "CornflowerBlue", attrs = "theme_default" }
+"mail.view.thread.indentation.b" = { fg = "theme_default", bg = "Red1", attrs = "theme_default" }
+"mail.view.thread.indentation.c" = { fg = "theme_default", bg = "Pink3", attrs = "theme_default" }
+"mail.view.thread.indentation.d" = { fg = "theme_default", bg = "Gold1", attrs = "theme_default" }
+"mail.view.thread.indentation.e" = { fg = "theme_default", bg = "Orange3", attrs = "theme_default" }
+"mail.view.thread.indentation.f" = { fg = "theme_default", bg = "CadetBlue", attrs = "theme_default" }
+"mail.listing.attachment_flag" = { fg = "$CoolGray30", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.thread_snooze_flag" = { fg = "$Magenta40", bg = "theme_default", attrs = "theme_default" }
+"mail.listing.tag_default" = { fg = "$White0", bg = "$Black100", attrs = "Bold" }
+"pager.highlight_search" = { fg = "theme_default", bg = "$Teal30", attrs = "Bold" }
+"pager.highlight_search_current" = { fg = "$CoolGray10", bg = "$Teal30", attrs = "Bold" }
+
+[terminal.themes.ibm-modern.color_aliases]
+"Blue60" = "#0f62fe"
+"Black100" = "#000000"
+"White0" = "#ffffff"
+"Cyan30" = "#82cfff"
+"Purple40" = "#be95ff"
+"Magenta40" = "#ff7eb6"
+"Teal30" = "#3ddbd9"
+"Cyan10" = "#e5f6ff"
+"CoolGray10" = "#f2f4f8"
+"CoolGray30" = "#c1c7cd"

meli/src/accounts/backend_ops.rs

@@ -35,10 +35,10 @@ impl Account {
             mailbox_hash,
             flags.clone(),
         )?;
-        let handle = self
-            .main_loop_handler
-            .job_executor
-            .spawn_specialized("set_flags".into(), fut);
+        let handle =
+            self.main_loop_handler
+                .job_executor
+                .spawn("set-flags".into(), fut, self.is_async());
         let job_id = handle.job_id;
         self.insert_job(
             job_id,
@@ -59,8 +59,8 @@ impl Account {
 
     #[cfg(feature = "sqlite3")]
     pub(super) fn update_cached_env(&mut self, env: Envelope, old_hash: Option<EnvelopeHash>) {
-        if self.settings.conf.search_backend == crate::conf::SearchBackend::Sqlite3 {
-            let msg_id = env.message_id_display().to_string();
+        if self.settings.conf.search_backend == SearchBackend::Sqlite3 {
+            let msg_id = env.message_id().to_string();
             let name = self.name.clone();
             let backend = self.backend.clone();
             let fut = async move {
@@ -73,10 +73,11 @@ impl Account {
                 crate::sqlite3::AccountCache::insert(env, backend, name).await?;
                 Ok(())
             };
-            let handle = self
-                .main_loop_handler
-                .job_executor
-                .spawn_specialized("sqlite3::remove".into(), fut);
+            let handle = self.main_loop_handler.job_executor.spawn(
+                "sqlite3::remove".into(),
+                fut,
+                crate::sqlite3::AccountCache::is_async(),
+            );
             self.insert_job(
                 handle.job_id,
                 JobRequest::Generic {

meli/src/accounts/jobs.rs

@@ -26,12 +26,88 @@ use futures::stream::Stream;
 use melib::{backends::*, email::*, error::Result, LogLevel};
 use smallvec::SmallVec;
 
-use crate::{is_variant, jobs::JoinHandle};
+use crate::{is_variant, jobs::JoinHandle, StatusEvent};
 
-pub enum JobRequest {
+pub enum MailboxJobRequest {
     Mailboxes {
         handle: JoinHandle<Result<HashMap<MailboxHash, Mailbox>>>,
     },
+    CreateMailbox {
+        path: String,
+        handle: JoinHandle<Result<(MailboxHash, HashMap<MailboxHash, Mailbox>)>>,
+    },
+    DeleteMailbox {
+        mailbox_hash: MailboxHash,
+        handle: JoinHandle<Result<HashMap<MailboxHash, Mailbox>>>,
+    },
+    RenameMailbox {
+        mailbox_hash: MailboxHash,
+        new_path: String,
+        handle: JoinHandle<Result<Mailbox>>,
+    },
+    SetMailboxPermissions {
+        mailbox_hash: MailboxHash,
+        handle: JoinHandle<Result<()>>,
+    },
+    SetMailboxSubscription {
+        mailbox_hash: MailboxHash,
+        new_value: bool,
+        handle: JoinHandle<Result<()>>,
+    },
+}
+
+impl std::fmt::Debug for MailboxJobRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::CreateMailbox { .. } => write!(f, "JobRequest::CreateMailbox"),
+            Self::DeleteMailbox { mailbox_hash, .. } => {
+                write!(f, "JobRequest::DeleteMailbox({})", mailbox_hash)
+            }
+            Self::RenameMailbox {
+                mailbox_hash,
+                new_path,
+                ..
+            } => {
+                write!(f, "JobRequest::RenameMailbox {mailbox_hash} to {new_path} ")
+            }
+            Self::SetMailboxPermissions { .. } => {
+                write!(f, "JobRequest::SetMailboxPermissions")
+            }
+            Self::SetMailboxSubscription { .. } => {
+                write!(f, "JobRequest::SetMailboxSubscription")
+            }
+            Self::Mailboxes { .. } => write!(f, "JobRequest::Mailboxes"),
+        }
+    }
+}
+
+impl std::fmt::Display for MailboxJobRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::Mailboxes { .. } => write!(f, "Get mailbox list"),
+            Self::CreateMailbox { path, .. } => write!(f, "Create mailbox {}", path),
+            Self::DeleteMailbox { .. } => write!(f, "Delete mailbox"),
+            Self::RenameMailbox { new_path, .. } => write!(f, "Rename mailbox to {new_path}"),
+            Self::SetMailboxPermissions { .. } => write!(f, "Set mailbox permissions"),
+            Self::SetMailboxSubscription { .. } => write!(f, "Set mailbox subscription"),
+        }
+    }
+}
+
+impl MailboxJobRequest {
+    pub fn cancel(&self) -> Option<StatusEvent> {
+        match self {
+            Self::Mailboxes { handle } => handle.cancel(),
+            Self::CreateMailbox { handle, .. } => handle.cancel(),
+            Self::DeleteMailbox { handle, .. } => handle.cancel(),
+            Self::RenameMailbox { handle, .. } => handle.cancel(),
+            Self::SetMailboxPermissions { handle, .. } => handle.cancel(),
+            Self::SetMailboxSubscription { handle, .. } => handle.cancel(),
+        }
+    }
+}
+
+pub enum JobRequest {
     Fetch {
         mailbox_hash: MailboxHash,
         #[allow(clippy::type_complexity)]
@@ -72,69 +148,17 @@ pub enum JobRequest {
         env_hashes: EnvelopeHashBatch,
         handle: JoinHandle<Result<()>>,
     },
-    CreateMailbox {
-        path: String,
-        handle: JoinHandle<Result<(MailboxHash, HashMap<MailboxHash, Mailbox>)>>,
-    },
-    DeleteMailbox {
-        mailbox_hash: MailboxHash,
-        handle: JoinHandle<Result<HashMap<MailboxHash, Mailbox>>>,
-    },
-    //RenameMailbox,
-    SetMailboxPermissions {
-        mailbox_hash: MailboxHash,
-        handle: JoinHandle<Result<()>>,
-    },
-    SetMailboxSubscription {
-        mailbox_hash: MailboxHash,
-        new_value: bool,
-        handle: JoinHandle<Result<()>>,
-    },
     Watch {
         handle: JoinHandle<Result<()>>,
     },
-}
-
-impl Drop for JobRequest {
-    fn drop(&mut self) {
-        match self {
-            Self::Generic { handle, .. } |
-            Self::IsOnline { handle, .. } |
-            Self::Refresh { handle, .. } |
-            Self::SetFlags { handle, .. } |
-            Self::SaveMessage { handle, .. } |
-            //JobRequest::RenameMailbox,
-            Self::SetMailboxPermissions { handle, .. } |
-            Self::SetMailboxSubscription { handle, .. } |
-            Self::Watch { handle, .. } |
-            Self::SendMessageBackground { handle, .. } => {
-                handle.cancel();
-            }
-            Self::DeleteMessages { handle, .. } => {
-                handle.cancel();
-            }
-            Self::CreateMailbox { handle, .. } => {
-                handle.cancel();
-            }
-            Self::DeleteMailbox { handle, .. } => {
-                handle.cancel();
-            }
-            Self::Fetch { handle, .. } => {
-                handle.cancel();
-            }
-            Self::Mailboxes { handle, .. } => {
-                handle.cancel();
-            }
-            Self::SendMessage => {}
-        }
-    }
+    Mailbox(MailboxJobRequest),
 }
 
 impl std::fmt::Debug for JobRequest {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Self::Generic { name, .. } => write!(f, "JobRequest::Generic({})", name),
-            Self::Mailboxes { .. } => write!(f, "JobRequest::Mailboxes"),
+            Self::Mailbox(inner) => std::fmt::Debug::fmt(inner, f),
             Self::Fetch { mailbox_hash, .. } => {
                 write!(f, "JobRequest::Fetch({})", mailbox_hash)
             }
@@ -153,17 +177,6 @@ impl std::fmt::Debug for JobRequest {
                 .finish(),
             Self::SaveMessage { .. } => write!(f, "JobRequest::SaveMessage"),
             Self::DeleteMessages { .. } => write!(f, "JobRequest::DeleteMessages"),
-            Self::CreateMailbox { .. } => write!(f, "JobRequest::CreateMailbox"),
-            Self::DeleteMailbox { mailbox_hash, .. } => {
-                write!(f, "JobRequest::DeleteMailbox({})", mailbox_hash)
-            }
-            //JobRequest::RenameMailbox,
-            Self::SetMailboxPermissions { .. } => {
-                write!(f, "JobRequest::SetMailboxPermissions")
-            }
-            Self::SetMailboxSubscription { .. } => {
-                write!(f, "JobRequest::SetMailboxSubscription")
-            }
             Self::Watch { .. } => write!(f, "JobRequest::Watch"),
             Self::SendMessage => write!(f, "JobRequest::SendMessage"),
             Self::SendMessageBackground { .. } => {
@@ -177,7 +190,7 @@ impl std::fmt::Display for JobRequest {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Self::Generic { name, .. } => write!(f, "{}", name),
-            Self::Mailboxes { .. } => write!(f, "Get mailbox list"),
+            Self::Mailbox(inner) => std::fmt::Display::fmt(inner, f),
             Self::Fetch { .. } => write!(f, "Mailbox fetch"),
             Self::IsOnline { .. } => write!(f, "Online status check"),
             Self::Refresh { .. } => write!(f, "Refresh mailbox"),
@@ -197,11 +210,6 @@ impl std::fmt::Display for JobRequest {
                 env_hashes.len(),
                 if env_hashes.len() == 1 { "" } else { "s" }
             ),
-            Self::CreateMailbox { path, .. } => write!(f, "Create mailbox {}", path),
-            Self::DeleteMailbox { .. } => write!(f, "Delete mailbox"),
-            //JobRequest::RenameMailbox,
-            Self::SetMailboxPermissions { .. } => write!(f, "Set mailbox permissions"),
-            Self::SetMailboxSubscription { .. } => write!(f, "Set mailbox subscription"),
             Self::Watch { .. } => write!(f, "Background watch"),
             Self::SendMessageBackground { .. } | Self::SendMessage => {
                 write!(f, "Sending message")
@@ -213,10 +221,27 @@ impl std::fmt::Display for JobRequest {
 impl JobRequest {
     is_variant! { is_watch, Watch { .. } }
     is_variant! { is_online, IsOnline { .. } }
+    is_variant! { is_any_fetch, Fetch { .. } }
 
     pub fn is_fetch(&self, mailbox_hash: MailboxHash) -> bool {
         matches!(self, Self::Fetch {
                  mailbox_hash: h, ..
              } if *h == mailbox_hash)
     }
+
+    pub fn cancel(&self) -> Option<StatusEvent> {
+        match self {
+            Self::Generic { handle, .. } => handle.cancel(),
+            Self::Mailbox(inner) => inner.cancel(),
+            Self::Fetch { handle, .. } => handle.cancel(),
+            Self::IsOnline { handle, .. } => handle.cancel(),
+            Self::Refresh { handle, .. } => handle.cancel(),
+            Self::SetFlags { handle, .. } => handle.cancel(),
+            Self::SaveMessage { handle, .. } => handle.cancel(),
+            Self::DeleteMessages { handle, .. } => handle.cancel(),
+            Self::Watch { handle, .. } => handle.cancel(),
+            Self::SendMessage => None,
+            Self::SendMessageBackground { handle, .. } => handle.cancel(),
+        }
+    }
 }

meli/src/accounts/mailbox.rs

@@ -259,89 +259,3 @@ pub fn build_mailboxes_order(
         rec(node, mailbox_entries, 0, false);
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use melib::{
-        backends::{Mailbox, MailboxHash},
-        error::Result,
-        MailboxPermissions, SpecialUsageMailbox,
-    };
-
-    use crate::accounts::{FileMailboxConf, MailboxEntry, MailboxStatus};
-
-    #[test]
-    fn test_mailbox_utf7() {
-        #[derive(Debug)]
-        struct TestMailbox(String);
-
-        impl melib::BackendMailbox for TestMailbox {
-            fn hash(&self) -> MailboxHash {
-                unimplemented!()
-            }
-
-            fn name(&self) -> &str {
-                &self.0
-            }
-
-            fn path(&self) -> &str {
-                &self.0
-            }
-
-            fn children(&self) -> &[MailboxHash] {
-                unimplemented!()
-            }
-
-            fn clone(&self) -> Mailbox {
-                unimplemented!()
-            }
-
-            fn special_usage(&self) -> SpecialUsageMailbox {
-                unimplemented!()
-            }
-
-            fn parent(&self) -> Option<MailboxHash> {
-                unimplemented!()
-            }
-
-            fn permissions(&self) -> MailboxPermissions {
-                unimplemented!()
-            }
-
-            fn is_subscribed(&self) -> bool {
-                unimplemented!()
-            }
-
-            fn set_is_subscribed(&mut self, _: bool) -> Result<()> {
-                unimplemented!()
-            }
-
-            fn set_special_usage(&mut self, _: SpecialUsageMailbox) -> Result<()> {
-                unimplemented!()
-            }
-
-            fn count(&self) -> Result<(usize, usize)> {
-                unimplemented!()
-            }
-        }
-        for (n, d) in [
-            ("~peter/mail/&U,BTFw-/&ZeVnLIqe-", "~peter/mail/台北/日本語"),
-            ("&BB4EQgQ,BEAEMAQyBDsENQQ9BD0ESwQ1-", "Отправленные"),
-        ] {
-            let ref_mbox = TestMailbox(n.to_string());
-            let mut conf: melib::MailboxConf = Default::default();
-            conf.extra.insert("encoding".to_string(), "utf7".into());
-
-            let entry = MailboxEntry::new(
-                MailboxStatus::None,
-                n.to_string(),
-                Box::new(ref_mbox),
-                FileMailboxConf {
-                    mailbox_conf: conf,
-                    ..Default::default()
-                },
-            );
-            assert_eq!(&entry.path, d);
-        }
-    }
-}

meli/src/accounts/mailbox_ops.rs

@@ -0,0 +1,439 @@
+//
+// meli
+//
+// Copyright 2024 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+use melib::conf::ToggleFlag;
+
+use super::*;
+use crate::command::actions::MailboxOperation;
+
+impl Account {
+    pub fn mailbox_operation(&mut self, op: MailboxOperation) -> Result<JobId> {
+        if self.settings.account.read_only {
+            return Err(Error::new("Account is read-only."));
+        }
+        match op {
+            MailboxOperation::Create(path) => {
+                let job = self
+                    .backend
+                    .write()
+                    .unwrap()
+                    .create_mailbox(path.to_string())?;
+                let handle = self.main_loop_handler.job_executor.spawn(
+                    "create_mailbox".into(),
+                    job,
+                    self.is_async(),
+                );
+                let job_id = handle.job_id;
+                self.insert_job(
+                    handle.job_id,
+                    JobRequest::Mailbox(MailboxJobRequest::CreateMailbox { path, handle }),
+                );
+                Ok(job_id)
+            }
+            MailboxOperation::Delete(path) => {
+                if self.mailbox_entries.len() == 1 {
+                    return Err(Error::new("Cannot delete only mailbox."));
+                }
+
+                let mailbox_hash = self.mailbox_by_path(&path)?;
+                let job = self.backend.write().unwrap().delete_mailbox(mailbox_hash)?;
+                let handle = self.main_loop_handler.job_executor.spawn(
+                    "delete-mailbox".into(),
+                    job,
+                    self.is_async(),
+                );
+                let job_id = handle.job_id;
+                self.insert_job(
+                    handle.job_id,
+                    JobRequest::Mailbox(MailboxJobRequest::DeleteMailbox {
+                        mailbox_hash,
+                        handle,
+                    }),
+                );
+                Ok(job_id)
+            }
+            MailboxOperation::Subscribe(path) => {
+                let mailbox_hash = self.mailbox_by_path(&path)?;
+                let job = self
+                    .backend
+                    .write()
+                    .unwrap()
+                    .set_mailbox_subscription(mailbox_hash, true)?;
+                let handle = self.main_loop_handler.job_executor.spawn(
+                    "subscribe-mailbox".into(),
+                    job,
+                    self.is_async(),
+                );
+                let job_id = handle.job_id;
+                self.insert_job(
+                    handle.job_id,
+                    JobRequest::Mailbox(MailboxJobRequest::SetMailboxSubscription {
+                        mailbox_hash,
+                        new_value: true,
+                        handle,
+                    }),
+                );
+                Ok(job_id)
+            }
+            MailboxOperation::Unsubscribe(path) => {
+                let mailbox_hash = self.mailbox_by_path(&path)?;
+                let job = self
+                    .backend
+                    .write()
+                    .unwrap()
+                    .set_mailbox_subscription(mailbox_hash, false)?;
+                let handle = self.main_loop_handler.job_executor.spawn(
+                    "unsubscribe-mailbox".into(),
+                    job,
+                    self.is_async(),
+                );
+                let job_id = handle.job_id;
+                self.insert_job(
+                    job_id,
+                    JobRequest::Mailbox(MailboxJobRequest::SetMailboxSubscription {
+                        mailbox_hash,
+                        new_value: false,
+                        handle,
+                    }),
+                );
+                Ok(job_id)
+            }
+            MailboxOperation::Rename(path, new_path) => {
+                let mailbox_hash = self.mailbox_by_path(&path)?;
+                let job = self
+                    .backend
+                    .write()
+                    .unwrap()
+                    .rename_mailbox(mailbox_hash, new_path.clone())?;
+                let handle = self.main_loop_handler.job_executor.spawn(
+                    format!("rename-mailbox {path} to {new_path}").into(),
+                    job,
+                    self.is_async(),
+                );
+                let job_id = handle.job_id;
+                self.insert_job(
+                    job_id,
+                    JobRequest::Mailbox(MailboxJobRequest::RenameMailbox {
+                        handle,
+                        mailbox_hash,
+                        new_path,
+                    }),
+                );
+                Ok(job_id)
+            }
+            MailboxOperation::SetPermissions(_) => Err(Error::new("Not implemented.")),
+        }
+    }
+
+    pub fn process_mailbox_event(&mut self, job_id: JobId, mut job: MailboxJobRequest) {
+        macro_rules! try_handle {
+            ($handle:ident, $binding:pat => $then:block) => {{
+                try_handle! { $handle, Err(err) => {
+                    self.main_loop_handler
+                        .job_executor
+                        .set_job_success(job_id, false);
+                    self.main_loop_handler
+                        .send(ThreadEvent::UIEvent(UIEvent::Notification {
+                            title: None,
+                            body: format!("{}: {} failed", &self.name, job).into(),
+                            kind: Some(NotificationType::Error(err.kind)),
+                            source: Some(err),
+                        }));
+                    return;
+                },
+                $binding => $then
+                }
+            }};
+            ($handle:ident, Err($err:pat) => $then_err: block, $binding:pat => $then:block) => {{
+                match $handle.chan.try_recv() {
+                    _err @ Ok(None) | _err @ Err(_) => {
+                        /* canceled */
+                        #[cfg(debug_assertions)]
+                        log::trace!(
+                            "handle.chan.try_recv() for job {} returned {:?}",
+                            job_id,
+                            _err
+                        );
+                        self.main_loop_handler
+                            .job_executor
+                            .set_job_success(job_id, false);
+                    }
+                    Ok(Some(Err($err))) => $then_err,
+                    Ok(Some(Ok($binding))) => $then,
+                }
+            }};
+        }
+
+        match job {
+            MailboxJobRequest::Mailboxes { ref mut handle } => {
+                if let Ok(Some(mailboxes)) = handle.chan.try_recv() {
+                    if let Err(err) = mailboxes.and_then(|mailboxes| self.init(mailboxes)) {
+                        if !err.is_recoverable() {
+                            self.main_loop_handler.send(ThreadEvent::UIEvent(
+                                UIEvent::Notification {
+                                    title: Some(self.name.to_string().into()),
+                                    source: Some(err.clone()),
+                                    body: err.to_string().into(),
+                                    kind: Some(NotificationType::Error(err.kind)),
+                                },
+                            ));
+                            self.main_loop_handler.send(ThreadEvent::UIEvent(
+                                UIEvent::AccountStatusChange(
+                                    self.hash,
+                                    Some(err.to_string().into()),
+                                ),
+                            ));
+                            self.is_online.set_err(err);
+                            self.main_loop_handler
+                                .job_executor
+                                .set_job_success(job_id, false);
+                            return;
+                        }
+                        let mailboxes_job = self.backend.read().unwrap().mailboxes();
+                        if let Ok(mailboxes_job) = mailboxes_job {
+                            let handle = self.main_loop_handler.job_executor.spawn(
+                                "list-mailboxes".into(),
+                                mailboxes_job,
+                                self.is_async(),
+                            );
+                            self.insert_job(
+                                handle.job_id,
+                                JobRequest::Mailbox(MailboxJobRequest::Mailboxes { handle }),
+                            );
+                        };
+                    } else {
+                        self.main_loop_handler.send(ThreadEvent::UIEvent(
+                            UIEvent::AccountStatusChange(
+                                self.hash,
+                                Some("Loaded mailboxes.".into()),
+                            ),
+                        ));
+                    }
+                }
+            }
+            MailboxJobRequest::CreateMailbox { ref mut handle, .. } => {
+                try_handle! { handle, (mailbox_hash, mut mailboxes) => {
+                    self.main_loop_handler.send(ThreadEvent::UIEvent(
+                            UIEvent::MailboxCreate((self.hash, mailbox_hash)),
+                    ));
+                    let mut new = FileMailboxConf::default();
+                    new.mailbox_conf.subscribe = ToggleFlag::InternalVal(true);
+                    new.mailbox_conf.usage = if mailboxes[&mailbox_hash].special_usage()
+                        != SpecialUsageMailbox::Normal
+                    {
+                        Some(mailboxes[&mailbox_hash].special_usage())
+                    } else {
+                        let tmp = SpecialUsageMailbox::detect_usage(
+                            mailboxes[&mailbox_hash].name(),
+                        );
+                        if let Some(tmp) = tmp.filter(|&v| v != SpecialUsageMailbox::Normal)
+                        {
+                            mailboxes.entry(mailbox_hash).and_modify(|entry| {
+                                let _ = entry.set_special_usage(tmp);
+                            });
+                        }
+                        tmp
+                    };
+                    // if new mailbox has parent, we need to update its children field
+                    if let Some(parent_hash) = mailboxes[&mailbox_hash].parent() {
+                        self.mailbox_entries
+                            .entry(parent_hash)
+                            .and_modify(|parent| {
+                                parent.ref_mailbox =
+                                    mailboxes.remove(&parent_hash).unwrap();
+                            });
+                    }
+                    let status = MailboxStatus::default();
+
+                    self.mailbox_entries.insert(
+                        mailbox_hash,
+                        MailboxEntry::new(
+                            status,
+                            mailboxes[&mailbox_hash].path().to_string(),
+                            mailboxes.remove(&mailbox_hash).unwrap(),
+                            new,
+                        ),
+                    );
+                    self.collection
+                        .threads
+                        .write()
+                        .unwrap()
+                        .insert(mailbox_hash, Threads::default());
+                    self.collection
+                        .mailboxes
+                        .write()
+                        .unwrap()
+                        .insert(mailbox_hash, Default::default());
+                    build_mailboxes_order(
+                        &mut self.tree,
+                        &self.mailbox_entries,
+                        &mut self.mailboxes_order,
+                    );
+                }}
+            }
+            MailboxJobRequest::DeleteMailbox {
+                mailbox_hash,
+                ref mut handle,
+                ..
+            } => {
+                try_handle! { handle, mut mailboxes => {
+                    self.main_loop_handler
+                        .send(ThreadEvent::UIEvent(UIEvent::MailboxDelete((
+                                        self.hash,
+                                        mailbox_hash,
+                        ))));
+                    if let Some(pos) =
+                        self.mailboxes_order.iter().position(|&h| h == mailbox_hash)
+                    {
+                        self.mailboxes_order.remove(pos);
+                    }
+                    if let Some(pos) = self.tree.iter().position(|n| n.hash == mailbox_hash) {
+                        self.tree.remove(pos);
+                    }
+                    if self.settings.sent_mailbox == Some(mailbox_hash) {
+                        self.settings.sent_mailbox = None;
+                    }
+                    self.collection
+                        .threads
+                        .write()
+                        .unwrap()
+                        .remove(&mailbox_hash);
+                    let deleted_mailbox =
+                        self.mailbox_entries.shift_remove(&mailbox_hash).unwrap();
+                    // if deleted mailbox had parent, we need to update its children field
+                    if let Some(parent_hash) = deleted_mailbox.ref_mailbox.parent() {
+                        self.mailbox_entries
+                            .entry(parent_hash)
+                            .and_modify(|parent| {
+                                parent.ref_mailbox = mailboxes.remove(&parent_hash).unwrap();
+                            });
+                    }
+                    self.collection
+                        .mailboxes
+                        .write()
+                        .unwrap()
+                        .remove(&mailbox_hash);
+                    build_mailboxes_order(
+                        &mut self.tree,
+                        &self.mailbox_entries,
+                        &mut self.mailboxes_order,
+                    );
+                    // [ref:FIXME] remove from settings as well
+
+                    self.main_loop_handler
+                        .send(ThreadEvent::UIEvent(UIEvent::Notification {
+                            title: Some(
+                                       format!("{}: mailbox deleted successfully", &self.name).into(),
+                                   ),
+                                   source: None,
+                                   body: "".into(),
+                                   kind: Some(NotificationType::Info),
+                        }));
+                }}
+            }
+            MailboxJobRequest::RenameMailbox {
+                ref mut handle,
+                mailbox_hash,
+                ref mut new_path,
+            } => {
+                use indexmap::map::MutableKeys;
+                try_handle! { handle, mailbox => {
+                    let new_hash = mailbox.hash();
+                    if let Some((_, key, entry)) = self.mailbox_entries.get_full_mut2(&mailbox_hash) {
+                        *key = new_hash;
+                        *entry = MailboxEntry::new(entry.status.clone(), std::mem::take(new_path), mailbox, entry.conf.clone());
+                    }
+                    if let Some(key) = self.mailboxes_order.iter_mut().find(|k| **k == mailbox_hash) {
+                        *key = new_hash;
+                    }
+                    if let Some((_, key, _)) = self.event_queue.get_full_mut2(&mailbox_hash) {
+                        *key = new_hash;
+                    }
+                    {
+                        let mut threads = self.collection.threads.write().unwrap();
+                        if let Some(entry) = threads.remove(&mailbox_hash) {
+                            threads.insert(new_hash, entry);
+                        }
+                    }
+                    {
+                        let mut mailboxes = self.collection.mailboxes.write().unwrap();
+                        if let Some(entry) = mailboxes.remove(&mailbox_hash) {
+                            mailboxes.insert(new_hash, entry);
+                        }
+                    }
+                    build_mailboxes_order(
+                        &mut self.tree,
+                        &self.mailbox_entries,
+                        &mut self.mailboxes_order,
+                    );
+                }}
+            }
+            MailboxJobRequest::SetMailboxPermissions { ref mut handle, .. } => {
+                try_handle! { handle, _ => {
+                    self.main_loop_handler
+                        .send(ThreadEvent::UIEvent(UIEvent::Notification {
+                            title: Some(
+                                       format!("{}: mailbox permissions set successfully", &self.name)
+                                       .into(),
+                                   ),
+                                   source: None,
+                                   body: "".into(),
+                                   kind: Some(NotificationType::Info),
+                        }));
+                }}
+            }
+            MailboxJobRequest::SetMailboxSubscription {
+                ref mut handle,
+                ref mailbox_hash,
+                ref new_value,
+            } => {
+                try_handle! { handle, () => {
+                    if self.mailbox_entries.contains_key(mailbox_hash) {
+                        self.mailbox_entries.entry(*mailbox_hash).and_modify(|m| {
+                            m.conf.mailbox_conf.subscribe = if *new_value {
+                                ToggleFlag::True
+                            } else {
+                                ToggleFlag::False
+                            };
+                            let _ = m.ref_mailbox.set_is_subscribed(*new_value);
+                        });
+                        self.main_loop_handler
+                            .send(ThreadEvent::UIEvent(UIEvent::Notification {
+                                title: Some(
+                                    format!(
+                                        "{}: `{}` has been {}subscribed.",
+                                        &self.name,
+                                        self.mailbox_entries[mailbox_hash].name(),
+                                        if *new_value { "" } else { "un" }
+                                    )
+                                    .into(),
+                                ),
+                                source: None,
+                                body: "".into(),
+                                kind: Some(NotificationType::Info),
+                            }));
+                    }
+                }}
+            }
+        }
+    }
+}

meli/src/accounts/tests.rs

@@ -0,0 +1,565 @@
+//
+// meli
+//
+// Copyright 2024 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+use std::path::PathBuf;
+
+use melib::{
+    backends::{prelude::*, Mailbox, MailboxHash},
+    error::Result,
+    maildir::MaildirType,
+    smol, MailboxPermissions, SpecialUsageMailbox,
+};
+use tempfile::TempDir;
+
+use crate::{
+    accounts::{AccountConf, FileMailboxConf, MailboxEntry, MailboxStatus},
+    command::actions::MailboxOperation,
+    utilities::tests::{eprint_step_fn, eprintln_ok_fn},
+};
+
+#[test]
+fn test_mailbox_utf7() {
+    #[derive(Debug)]
+    struct TestMailbox(String);
+
+    impl melib::BackendMailbox for TestMailbox {
+        fn hash(&self) -> MailboxHash {
+            unimplemented!()
+        }
+
+        fn name(&self) -> &str {
+            &self.0
+        }
+
+        fn path(&self) -> &str {
+            &self.0
+        }
+
+        fn children(&self) -> &[MailboxHash] {
+            unimplemented!()
+        }
+
+        fn clone(&self) -> Mailbox {
+            unimplemented!()
+        }
+
+        fn special_usage(&self) -> SpecialUsageMailbox {
+            unimplemented!()
+        }
+
+        fn parent(&self) -> Option<MailboxHash> {
+            unimplemented!()
+        }
+
+        fn permissions(&self) -> MailboxPermissions {
+            unimplemented!()
+        }
+
+        fn is_subscribed(&self) -> bool {
+            unimplemented!()
+        }
+
+        fn set_is_subscribed(&mut self, _: bool) -> Result<()> {
+            unimplemented!()
+        }
+
+        fn set_special_usage(&mut self, _: SpecialUsageMailbox) -> Result<()> {
+            unimplemented!()
+        }
+
+        fn count(&self) -> Result<(usize, usize)> {
+            unimplemented!()
+        }
+
+        fn as_any(&self) -> &dyn std::any::Any {
+            self
+        }
+
+        fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+            self
+        }
+    }
+    for (n, d) in [
+        ("~peter/mail/&U,BTFw-/&ZeVnLIqe-", "~peter/mail/台北/日本語"),
+        ("&BB4EQgQ,BEAEMAQyBDsENQQ9BD0ESwQ1-", "Отправленные"),
+    ] {
+        let ref_mbox = TestMailbox(n.to_string());
+        let mut conf: melib::MailboxConf = Default::default();
+        conf.extra.insert("encoding".to_string(), "utf7".into());
+
+        let entry = MailboxEntry::new(
+            MailboxStatus::None,
+            n.to_string(),
+            Box::new(ref_mbox),
+            FileMailboxConf {
+                mailbox_conf: conf,
+                ..Default::default()
+            },
+        );
+        assert_eq!(&entry.path, d);
+    }
+}
+
+fn new_maildir_backend(
+    temp_dir: &TempDir,
+    acc_name: &str,
+    event_consumer: BackendEventConsumer,
+    with_root_mailbox: bool,
+) -> Result<(PathBuf, AccountConf, Box<MaildirType>)> {
+    let root_mailbox = temp_dir.path().join("inbox");
+    {
+        std::fs::create_dir(&root_mailbox).expect("Could not create root mailbox directory.");
+        if with_root_mailbox {
+            for d in &["cur", "new", "tmp"] {
+                std::fs::create_dir(root_mailbox.join(d))
+                    .expect("Could not create root mailbox directory contents.");
+            }
+        }
+    }
+    let subscribed_mailboxes = if with_root_mailbox {
+        vec!["inbox".into()]
+    } else {
+        vec![]
+    };
+    let mailboxes = if with_root_mailbox {
+        vec![(
+            "inbox".into(),
+            melib::conf::MailboxConf {
+                extra: indexmap::indexmap! {
+                    "path".into() => root_mailbox.display().to_string(),
+                },
+                ..Default::default()
+            },
+        )]
+        .into_iter()
+        .collect()
+    } else {
+        indexmap::indexmap! {}
+    };
+    let extra = if with_root_mailbox {
+        indexmap::indexmap! {
+            "root_mailbox".into() => root_mailbox.display().to_string(),
+        }
+    } else {
+        indexmap::indexmap! {}
+    };
+
+    let account_conf = melib::AccountSettings {
+        name: acc_name.to_string(),
+        root_mailbox: root_mailbox.display().to_string(),
+        format: "maildir".to_string(),
+        identity: "user@localhost".to_string(),
+        extra_identities: vec![],
+        read_only: false,
+        display_name: None,
+        order: Default::default(),
+        subscribed_mailboxes,
+        mailboxes,
+        manual_refresh: true,
+        extra,
+    };
+
+    let maildir = MaildirType::new(&account_conf, Default::default(), event_consumer)?;
+    Ok((root_mailbox, account_conf.into(), maildir))
+}
+
+#[test]
+fn test_accounts_mailbox_by_path_error_msg() {
+    const ACCOUNT_NAME: &str = "test";
+
+    let eprintln_ok = eprintln_ok_fn();
+    let mut eprint_step_closure = eprint_step_fn();
+    macro_rules! eprint_step {
+        ($($arg:tt)+) => {{
+            eprint_step_closure(format_args!($($arg)+));
+        }};
+    }
+    let temp_dir = TempDir::new().unwrap();
+    {
+        eprint_step!(
+            "Create maildir backend with a root mailbox, \"inbox\" which will be a valid maildir \
+             folder because it will contain cur, new, tmp subdirectories..."
+        );
+        let mut ctx = crate::Context::new_mock(&temp_dir);
+        let backend_event_queue = Arc::new(std::sync::Mutex::new(
+            std::collections::VecDeque::with_capacity(16),
+        ));
+
+        let backend_event_consumer = {
+            let backend_event_queue = Arc::clone(&backend_event_queue);
+
+            BackendEventConsumer::new(Arc::new(move |ah, be| {
+                backend_event_queue.lock().unwrap().push_back((ah, be));
+            }))
+        };
+
+        let (root_mailbox, settings, maildir) =
+            new_maildir_backend(&temp_dir, ACCOUNT_NAME, backend_event_consumer, true).unwrap();
+        eprintln_ok();
+        let name = maildir.account_name.to_string();
+        let account_hash = maildir.account_hash;
+        let backend = maildir as Box<dyn MailBackend>;
+        let ref_mailboxes = smol::block_on(backend.mailboxes().unwrap()).unwrap();
+        let contacts = melib::contacts::Contacts::new(name.to_string());
+
+        let mut account = super::Account {
+            hash: account_hash,
+            name: name.into(),
+            is_online: super::IsOnline::True,
+            mailbox_entries: Default::default(),
+            mailboxes_order: Default::default(),
+            tree: Default::default(),
+            contacts,
+            collection: backend.collection(),
+            settings,
+            main_loop_handler: ctx.main_loop_handler.clone(),
+            active_jobs: HashMap::default(),
+            active_job_instants: std::collections::BTreeMap::default(),
+            event_queue: IndexMap::default(),
+            backend_capabilities: backend.capabilities(),
+            backend: Arc::new(std::sync::RwLock::new(backend)),
+        };
+        account.init(ref_mailboxes).unwrap();
+        while let Ok(thread_event) = ctx.receiver.try_recv() {
+            if let crate::ThreadEvent::JobFinished(job_id) = thread_event {
+                if !account.process_event(&job_id) {
+                    assert!(
+                        ctx.accounts[0].process_event(&job_id),
+                        "unclaimed job id: {:?}",
+                        job_id
+                    );
+                }
+            }
+        }
+        eprint_step!("Assert that mailbox_by_path(\"inbox\") returns the root mailbox...");
+        account.mailbox_by_path("inbox").unwrap();
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"box\") returns an error mentioning the root mailbox..."
+        );
+        assert_eq!(
+            account.mailbox_by_path("box").unwrap_err().to_string(),
+            Error {
+                summary: "Mailbox with that path not found.".into(),
+                details: Some(
+                    "Some matching paths that were found: [\"inbox\"]. You can inspect the list \
+                     of mailbox paths of an account with the manage-mailboxes command."
+                        .into()
+                ),
+                source: None,
+                inner: None,
+                related_path: None,
+                kind: ErrorKind::NotFound
+            }
+            .to_string()
+        );
+        eprintln_ok();
+
+        macro_rules! wait_for_job {
+            ($job_id:expr) => {{
+                let wait_for = $job_id;
+                while let Ok(thread_event) = ctx.receiver.recv() {
+                    if let crate::ThreadEvent::JobFinished(job_id) = thread_event {
+                        if !account.process_event(&job_id) {
+                            assert!(
+                                ctx.accounts[0].process_event(&job_id),
+                                "unclaimed job id: {:?}",
+                                job_id
+                            );
+                        } else if job_id == wait_for {
+                            break;
+                        }
+                    }
+                }
+            }};
+        }
+        eprint_step!(
+            "Create new mailboxes: \"Sent\", \"Trash\", \"Drafts\", \"Archive\", \"Outbox\", \
+             \"Archive/Archive (old)\"..."
+        );
+        wait_for_job!(account
+            .mailbox_operation(MailboxOperation::Create("Sent".to_string()))
+            .unwrap());
+        wait_for_job!(account
+            .mailbox_operation(MailboxOperation::Create("Trash".to_string()))
+            .unwrap());
+        wait_for_job!(account
+            .mailbox_operation(MailboxOperation::Create("Drafts".to_string()))
+            .unwrap());
+        wait_for_job!(account
+            .mailbox_operation(MailboxOperation::Create("Archive".to_string()))
+            .unwrap());
+        wait_for_job!(account
+            .mailbox_operation(MailboxOperation::Create("Outbox".to_string()))
+            .unwrap());
+        wait_for_job!(account
+            .mailbox_operation(MailboxOperation::Create(
+                "inbox/Archive/Archive (old)".to_string(),
+            ))
+            .unwrap());
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"rchive\") returns an error and mentions matching \
+             archives with mailboxes with the least depth in the tree hierarchy of mailboxes \
+             mentioned first..."
+        );
+        assert_eq!(
+            account.mailbox_by_path("rchive").unwrap_err().to_string(),
+            Error {
+                summary: "Mailbox with that path not found.".into(),
+                details: Some(
+                    "Some matching paths that were found: [\"inbox/Archive\", \
+                     \"inbox/Archive/Archive (old)\"]. You can inspect the list of mailbox paths \
+                     of an account with the manage-mailboxes command."
+                        .into()
+                ),
+                source: None,
+                inner: None,
+                related_path: None,
+                kind: ErrorKind::NotFound
+            }
+            .to_string()
+        );
+        eprintln_ok();
+        eprint_step!("Create \"inbox/Archive/Archive{{1,2,3,4,5,6,7,8,9,10}}\" mailboxes...");
+        for i in 1..=10 {
+            wait_for_job!(account
+                .mailbox_operation(MailboxOperation::Create(format!(
+                    "inbox/Archive/Archive{i}"
+                )))
+                .unwrap());
+        }
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"inbox/Archive/Archive{{n}}\") works, i.e. we have to \
+             specify the root prefix \"inbox\"..."
+        );
+        for i in 1..=10 {
+            account
+                .mailbox_by_path(&format!("inbox/Archive/Archive{i}"))
+                .unwrap();
+            account
+                .mailbox_by_path(&format!("Archive/Archive{i}"))
+                .unwrap_err();
+        }
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"rchive\") returns and error and truncates the matching \
+             mailbox paths to 5 maximum..."
+        );
+        assert_eq!(
+            account.mailbox_by_path("rchive").unwrap_err().to_string(),
+            Error {
+                summary: "Mailbox with that path not found.".into(),
+                details: Some(
+                    "Some matching paths that were found: [\"inbox/Archive\", \
+                     \"inbox/Archive/Archive1\", \"inbox/Archive/Archive2\", \
+                     \"inbox/Archive/Archive3\", \"inbox/Archive/Archive4\"] and 7 others. You \
+                     can inspect the list of mailbox paths of an account with the \
+                     manage-mailboxes command."
+                        .into()
+                ),
+                source: None,
+                inner: None,
+                related_path: None,
+                kind: ErrorKind::NotFound
+            }
+            .to_string()
+        );
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"inbox/Archive\") returns a valid result (since the \
+             root mailbox is a valid maildir folder)..."
+        );
+        account.mailbox_by_path("inbox/Archive").unwrap();
+        eprintln_ok();
+
+        eprint_step!("Cleanup maildir account with valid root mailbox...");
+        std::fs::remove_dir_all(root_mailbox).unwrap();
+        eprintln_ok();
+    }
+
+    {
+        eprint_step!(
+            "Create maildir backend with a root mailbox, \"inbox\" which will NOT be a valid \
+             maildir folder because it will NOT contain cur, new, tmp subdirectories..."
+        );
+        let mut ctx = crate::Context::new_mock(&temp_dir);
+        let backend_event_queue = Arc::new(std::sync::Mutex::new(
+            std::collections::VecDeque::with_capacity(16),
+        ));
+
+        let backend_event_consumer = {
+            let backend_event_queue = Arc::clone(&backend_event_queue);
+
+            BackendEventConsumer::new(Arc::new(move |ah, be| {
+                backend_event_queue.lock().unwrap().push_back((ah, be));
+            }))
+        };
+
+        let (_root_mailbox, settings, maildir) =
+            new_maildir_backend(&temp_dir, ACCOUNT_NAME, backend_event_consumer, false).unwrap();
+        eprintln_ok();
+        let name = maildir.account_name.to_string();
+        let account_hash = maildir.account_hash;
+        let backend = maildir as Box<dyn MailBackend>;
+        let ref_mailboxes = smol::block_on(backend.mailboxes().unwrap()).unwrap();
+        eprint_step!("Assert that created account has no mailboxes at all...");
+        assert!(
+            ref_mailboxes.is_empty(),
+            "ref_mailboxes were not empty: {:?}",
+            ref_mailboxes
+        );
+        eprintln_ok();
+        let contacts = melib::contacts::Contacts::new(name.to_string());
+
+        let mut account = super::Account {
+            hash: account_hash,
+            name: name.into(),
+            is_online: super::IsOnline::True,
+            mailbox_entries: Default::default(),
+            mailboxes_order: Default::default(),
+            tree: Default::default(),
+            contacts,
+            collection: backend.collection(),
+            settings,
+            main_loop_handler: ctx.main_loop_handler.clone(),
+            active_jobs: HashMap::default(),
+            active_job_instants: std::collections::BTreeMap::default(),
+            event_queue: IndexMap::default(),
+            backend_capabilities: backend.capabilities(),
+            backend: Arc::new(std::sync::RwLock::new(backend)),
+        };
+        account.init(ref_mailboxes).unwrap();
+        while let Ok(thread_event) = ctx.receiver.try_recv() {
+            if let crate::ThreadEvent::JobFinished(job_id) = thread_event {
+                if !account.process_event(&job_id) {
+                    assert!(
+                        ctx.accounts[0].process_event(&job_id),
+                        "unclaimed job id: {:?}",
+                        job_id
+                    );
+                }
+            }
+        }
+        eprint_step!(
+            "Assert that mailbox_by_path(\"inbox\") does not return a valid result (there are no \
+             mailboxes)..."
+        );
+        assert_eq!(
+            account.mailbox_by_path("inbox").unwrap_err().to_string(),
+            Error {
+                summary: "Mailbox with that path not found.".into(),
+                details: Some(
+                    "You can inspect the list of mailbox paths of an account with the \
+                     manage-mailboxes command."
+                        .into()
+                ),
+                source: None,
+                inner: None,
+                related_path: None,
+                kind: ErrorKind::NotFound
+            }
+            .to_string()
+        );
+        eprintln_ok();
+        eprint_step!(
+            "Create multiple maildir folders \"inbox/Archive{{1,2,3,4,5,6,7,8,9,10}}\"..."
+        );
+        macro_rules! wait_for_job {
+            ($job_id:expr) => {{
+                let wait_for = $job_id;
+                while let Ok(thread_event) = ctx.receiver.recv() {
+                    if let crate::ThreadEvent::JobFinished(job_id) = thread_event {
+                        if !account.process_event(&job_id) {
+                            assert!(
+                                ctx.accounts[0].process_event(&job_id),
+                                "unclaimed job id: {:?}",
+                                job_id
+                            );
+                        } else if job_id == wait_for {
+                            break;
+                        }
+                    }
+                }
+            }};
+        }
+        for i in 1..=10 {
+            wait_for_job!(account
+                .mailbox_operation(MailboxOperation::Create(format!("inbox/Archive{i}")))
+                .unwrap());
+        }
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"Archive{{n}}\") works, and that we don't have to \
+             specify the root prefix \"inbox\"..."
+        );
+        for i in 1..=10 {
+            account.mailbox_by_path(&format!("Archive{i}")).unwrap();
+        }
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"rchive\") returns an error message with matches..."
+        );
+        assert_eq!(
+            account.mailbox_by_path("rchive").unwrap_err().to_string(),
+            Error {
+                summary: "Mailbox with that path not found.".into(),
+                details: Some(
+                    "Some matching paths that were found: [\"Archive1\", \"Archive2\", \
+                     \"Archive3\", \"Archive4\", \"Archive5\"] and 5 others. You can inspect the \
+                     list of mailbox paths of an account with the manage-mailboxes command."
+                        .into()
+                ),
+                source: None,
+                inner: None,
+                related_path: None,
+                kind: ErrorKind::NotFound
+            }
+            .to_string()
+        );
+        eprintln_ok();
+        eprint_step!(
+            "Assert that mailbox_by_path(\"inbox/Archive{{n}}\") does not return a valid result..."
+        );
+        assert_eq!(
+            account
+                .mailbox_by_path("inbox/Archive1")
+                .unwrap_err()
+                .to_string(),
+            Error {
+                summary: "Mailbox with that path not found.".into(),
+                details: Some(
+                    "You can inspect the list of mailbox paths of an account with the \
+                     manage-mailboxes command."
+                        .into()
+                ),
+                source: None,
+                inner: None,
+                related_path: None,
+                kind: ErrorKind::NotFound
+            }
+            .to_string()
+        );
+        eprintln_ok();
+    }
+}

meli/src/args.rs

@@ -146,6 +146,23 @@ pub enum ToolOpt {
     },
 }
 
+fn print_path(path: &std::path::Path) {
+    if let Some(hostname) = nix::unistd::gethostname()
+        .ok()
+        .and_then(|s| s.into_string().ok())
+    {
+        println!(
+            "{}",
+            Hyperlink::new(
+                &path.display(),
+                &format_args!("file://{hostname}{}", path.display())
+            )
+        );
+    } else {
+        println!("{}", path.display());
+    }
+}
+
 impl Opt {
     /// Execute `self.subcommand` if any, and return its result. Otherwise
     /// return `None`.
@@ -174,7 +191,7 @@ impl Opt {
             }
             SubCommand::PrintConfigPath => {
                 let config_path = ret_err!(crate::conf::get_config_file());
-                println!("{}", config_path.display());
+                print_path(&config_path);
                 Ok(())
             }
             #[cfg(not(feature = "cli-docs"))]
@@ -217,19 +234,15 @@ impl Opt {
                 Ok(())
             }
             SubCommand::PrintAppDirectories => {
-                println!(
-                    "{}",
-                    xdg::BaseDirectories::with_prefix("meli")
+                print_path(&xdg::BaseDirectories::with_prefix("meli")
                         .expect(
                             "Could not find your XDG directories. If this is unexpected, please \
                          report it as a bug."
                         )
-                        .get_data_file("")
-                        .display()
-                );
+                        .get_data_file(""));
                 let mut temp_dir = std::env::temp_dir();
                 temp_dir.push("meli");
-                println!("{}", temp_dir.display());
+                print_path(&temp_dir);
                 Ok(())
             }
             #[cfg(not(feature = "cli-docs"))]
@@ -248,7 +261,7 @@ impl Opt {
             }
             SubCommand::PrintLogPath => {
                 let settings = ret_err!(crate::conf::Settings::new());
-                println!("{}", settings._logger.log_dest().display());
+                print_path(&settings._logger.log_dest());
                 Ok(())
             }
         })

meli/src/command.rs

@@ -40,6 +40,9 @@ use melib::{
     SortField, SortOrder,
 };
 
+#[cfg(test)]
+mod tests;
+
 pub mod actions;
 #[macro_use]
 pub mod error;
@@ -55,7 +58,7 @@ pub use crate::actions::{
     AccountAction::{self, *},
     Action::{self, *},
     ComposeAction::{self, *},
-    FlagAction,
+    ComposerTabAction, FlagAction,
     ListingAction::{self, *},
     MailingListAction::{self, *},
     TabAction::{self, *},
@@ -423,6 +426,11 @@ Alternatives(&[to_stream!(One(Literal("add-attachment")), One(Filepath)), to_str
                   tokens: &[One(Literal("save-draft"))],
                   parser: parser::save_draft
                 },
+                { tags: ["discard-draft"],
+                  desc: "discard draft",
+                  tokens: &[One(Literal("discard-draft"))],
+                  parser: parser::discard_draft
+                },
                 { tags: ["toggle sign "],
                   desc: "switch between sign/unsign for this draft",
                   tokens: &[One(Literal("toggle")), One(Literal("sign"))],
@@ -555,172 +563,3 @@ pub fn command_completion_suggestions(input: &str) -> Vec<String> {
         .map(|s| format!("{}{}", input, s.as_str()))
         .collect::<Vec<String>>()
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_command_parser() {
-        let mut input = "sort".to_string();
-        macro_rules! match_input {
-            ($input:expr) => {{
-                let mut sugg: HashSet<String> = Default::default();
-                //print!("{}", $input);
-                for (_tags, _desc, tokens, _) in COMMAND_COMPLETION.iter() {
-                    //    //println!("{:?}, {:?}, {:?}", _tags, _desc, tokens);
-                    let _ = tokens.matches(&mut $input.as_str(), &mut sugg);
-                    //    if !m.is_empty() {
-                    //        //print!("{:?} ", desc);
-                    //        //println!(" result = {:#?}\n\n", m);
-                    //    }
-                }
-                //println!("suggestions = {:#?}", sugg);
-                sugg.into_iter()
-                    .map(|s| format!("{}{}", $input.as_str(), s.as_str()))
-                    .collect::<HashSet<String>>()
-            }};
-        }
-        assert_eq!(
-            &match_input!(input),
-            &IntoIterator::into_iter(["sort date".to_string(), "sort subject".to_string()])
-                .collect(),
-        );
-        input = "so".to_string();
-        assert_eq!(
-            &match_input!(input),
-            &IntoIterator::into_iter(["sort".to_string()]).collect(),
-        );
-        input = "so ".to_string();
-        assert_eq!(&match_input!(input), &HashSet::default(),);
-        input = "to".to_string();
-        assert_eq!(
-            &match_input!(input),
-            &IntoIterator::into_iter(["toggle".to_string()]).collect(),
-        );
-        input = "toggle ".to_string();
-        assert_eq!(
-            &match_input!(input),
-            &IntoIterator::into_iter([
-                "toggle mouse".to_string(),
-                "toggle sign".to_string(),
-                "toggle encrypt".to_string(),
-                "toggle thread_snooze".to_string()
-            ])
-            .collect(),
-        );
-    }
-
-    #[test]
-    #[ignore]
-    fn test_parser_interactive() {
-        use std::io;
-        let mut input = String::new();
-        loop {
-            input.clear();
-            print!("> ");
-            match io::stdin().read_line(&mut input) {
-                Ok(_n) => {
-                    println!("Input is {:?}", input.as_str().trim());
-                    let mut sugg: HashSet<String> = Default::default();
-                    let mut vec = vec![];
-                    //print!("{}", input);
-                    for (_tags, _desc, tokens, _) in COMMAND_COMPLETION.iter() {
-                        //println!("{:?}, {:?}, {:?}", _tags, _desc, tokens);
-                        let m = tokens.matches(&mut input.as_str().trim(), &mut sugg);
-                        if !m.is_empty() {
-                            vec.push(tokens);
-                            //print!("{:?} ", desc);
-                            //println!(" result = {:#?}\n\n", m);
-                        }
-                    }
-                    println!(
-                        "suggestions = {:#?}",
-                        sugg.into_iter()
-                            .zip(vec.into_iter())
-                            .map(|(s, v)| format!(
-                                "{}{} {:?}",
-                                input.as_str().trim(),
-                                if input.trim().is_empty() {
-                                    s.trim()
-                                } else {
-                                    s.as_str()
-                                },
-                                v
-                            ))
-                            .collect::<Vec<String>>()
-                    );
-                    if input.trim() == "quit" {
-                        break;
-                    }
-                }
-                Err(error) => println!("error: {}", error),
-            }
-        }
-        println!("alright");
-    }
-
-    #[test]
-    fn test_command_parser_all() {
-        use CommandError::*;
-
-        for cmd in [
-            "set unseen",
-            "set seen",
-            "delete",
-            "copyto somewhere",
-            "moveto somewhere",
-            "import fpath mpath",
-            "close  ",
-            "go 5",
-        ] {
-            parse_command(cmd.as_bytes()).unwrap_or_else(|err| panic!("{} failed {}", cmd, err));
-        }
-
-        assert_eq!(
-            parse_command(b"setfafsfoo").unwrap_err().to_string(),
-            Parsing {
-                inner: "setfafsfoo".into(),
-                kind: "".into(),
-            }
-            .to_string(),
-        );
-        assert_eq!(
-            parse_command(b"set foo").unwrap_err().to_string(),
-            BadValue {
-                inner: "foo".into(),
-                suggestions: Some(&[
-                    "seen",
-                    "unseen",
-                    "plain",
-                    "threaded",
-                    "compact",
-                    "conversations"
-                ])
-            }
-            .to_string(),
-        );
-        assert_eq!(
-            parse_command(b"moveto ").unwrap_err().to_string(),
-            WrongNumberOfArguments {
-                too_many: false,
-                takes: (1, Some(1)),
-                given: 0,
-                __func__: "moveto",
-                inner: "".into(),
-            }
-            .to_string(),
-        );
-        assert_eq!(
-            parse_command(b"reindex 1 2 3").unwrap_err().to_string(),
-            WrongNumberOfArguments {
-                too_many: true,
-                takes: (1, Some(1)),
-                given: 2,
-                __func__: "reindex",
-                inner: "".into(),
-            }
-            .to_string(),
-        );
-    }
-}

meli/src/command/actions.rs

@@ -21,25 +21,25 @@
 
 //! User actions that need to be handled by the UI
 
-use std::path::PathBuf;
+use std::{path::PathBuf, sync::Arc};
 
 use melib::{email::mailto::Mailto, Flag, SortField, SortOrder};
 
 use crate::components::{Component, ComponentId};
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum FlagAction {
     Set(Flag),
     Unset(Flag),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum TagAction {
     Add(String),
     Remove(String),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum ListingAction {
     SetPlain,
     SetThreaded,
@@ -49,6 +49,7 @@ pub enum ListingAction {
     Select(String),
     SetSeen,
     SetUnseen,
+    SendToTrash,
     CopyTo(MailboxPath),
     CopyToOtherAccount(AccountName, MailboxPath),
     MoveTo(MailboxPath),
@@ -63,8 +64,23 @@ pub enum ListingAction {
     ToggleThreadSnooze,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
+pub enum ComposerTabAction {
+    DiscardDraft,
+    SaveDraft,
+    #[cfg(feature = "gpgme")]
+    ToggleSign,
+    #[cfg(feature = "gpgme")]
+    ToggleEncrypt,
+    AddAttachment(String),
+    AddAttachmentFilePicker(Option<String>),
+    AddAttachmentPipe(String),
+    RemoveAttachment(usize),
+}
+
+#[derive(Debug, PartialEq)]
 pub enum TabAction {
+    ComposerAction(ComposerTabAction),
     Close,
     Kill(ComponentId),
     New(Option<Box<dyn Component>>),
@@ -74,41 +90,35 @@ pub enum TabAction {
     Man(crate::manpages::ManPages),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum MailingListAction {
     ListPost,
     ListArchive,
     ListUnsubscribe,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum ViewAction {
     Pipe(String, Vec<String>),
     Filter(Option<String>),
     SaveAttachment(usize, String),
+    PipeAttachment(usize, String, Vec<String>),
     ExportMail(String),
     AddAddressesToContacts,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum ComposeAction {
-    AddAttachment(String),
-    AddAttachmentFilePicker(Option<String>),
-    AddAttachmentPipe(String),
-    RemoveAttachment(usize),
-    SaveDraft,
-    ToggleSign,
-    ToggleEncrypt,
     Mailto(Mailto),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum AccountAction {
     ReIndex,
     PrintAccountSetting(String),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub enum MailboxOperation {
     Create(NewMailboxPath),
     Delete(MailboxPath),
@@ -119,7 +129,7 @@ pub enum MailboxOperation {
     SetPermissions(MailboxPath),
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum Action {
     Listing(ListingAction),
     ViewMailbox(usize),
@@ -159,7 +169,7 @@ type MailboxPath = String;
 type NewMailboxPath = String;
 
 macro_rules! impl_into_action {
-    ($({$t:ty => $var:tt}),*) => {
+    ($({$t:ty => $var:tt}),*$(,)?) => {
         $(
             impl From<$t> for Action {
                 fn from(v: $t) -> Self {
@@ -170,11 +180,11 @@ macro_rules! impl_into_action {
     };
 }
 macro_rules! impl_tuple_into_action {
-    ($({$a:ty,$b:ty => $var:tt}),*) => {
+    ($({$a:ty,$b:ty => $var:tt}),*$(,)?) => {
         $(
             impl From<($a,$b)> for Action {
                 fn from((a, b): ($a,$b)) -> Self {
-                    Self::$var(a, b)
+                    Self::$var(a.to_string(), b)
                 }
             }
         )*
@@ -190,5 +200,7 @@ impl_into_action!(
 );
 impl_tuple_into_action!(
     { AccountName, MailboxOperation => Mailbox },
-    { AccountName, AccountAction => AccountAction }
+    { AccountName, AccountAction => AccountAction },
+    { Arc<str>, MailboxOperation => Mailbox },
+    { Arc<str>, AccountAction => AccountAction },
 );

meli/src/command/error.rs

@@ -140,28 +140,3 @@ impl std::fmt::Display for CommandError {
 }
 
 impl std::error::Error for CommandError {}
-
-#[cfg(test)]
-mod tests {
-    use super::CommandError;
-
-    #[test]
-    fn test_command_error_display() {
-        assert_eq!(
-            &CommandError::BadValue {
-                inner: "foo".into(),
-                suggestions: Some(&[
-                    "seen",
-                    "unseen",
-                    "plain",
-                    "threaded",
-                    "compact",
-                    "conversations"
-                ])
-            }
-            .to_string(),
-            "Bad value/argument: foo. Possible values are: seen, unseen, plain, threaded, \
-             compact, conversations"
-        );
-    }
-}

meli/src/command/parser.rs

@@ -121,7 +121,13 @@ pub fn listing_action(input: &[u8]) -> IResult<&[u8], Result<Action, CommandErro
 }
 
 pub fn compose_action(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
-    alt((add_attachment, mailto, remove_attachment, save_draft))(input)
+    alt((
+        add_attachment,
+        mailto,
+        remove_attachment,
+        save_draft,
+        discard_draft,
+    ))(input)
 }
 
 pub fn account_action(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
@@ -133,6 +139,7 @@ pub fn view(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
         filter,
         pipe,
         save_attachment,
+        pipe_attachment,
         export_mail,
         add_addresses_to_contacts,
     ))(input)
@@ -562,15 +569,15 @@ pub fn printenv(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
     Ok((input, Ok(PrintEnv(key.to_string()))))
 }
 pub fn currentdir(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
-    let mut check = arg_init! { min_arg:0, max_arg: 0, currentdir};
-    let (input, _) = tag("cwd")(input.ltrim())?;
+    let mut check = arg_init! { min_arg:0, max_arg: 0, pwd};
+    let (input, _) = alt((tag("cwd"), tag("pwd")))(input.ltrim())?;
     arg_chk!(start check, input);
     arg_chk!(finish check, input);
     let (input, _) = eof(input)?;
     Ok((input, Ok(CurrentDirectory)))
 }
 pub fn change_currentdir(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
-    let mut check = arg_init! { min_arg:1, max_arg: 1, change_currentdir};
+    let mut check = arg_init! { min_arg: 1, max_arg: 1, cd};
     let (input, _) = tag("cd")(input.ltrim())?;
     arg_chk!(start check, input);
     let (input, _) = is_a(" ")(input)?;
@@ -660,7 +667,12 @@ pub fn add_attachment<'a>(input: &'a [u8]) -> IResult<&'a [u8], Result<Action, C
             let (input, cmd) = quoted_argument(input)?;
             arg_chk!(finish check, input);
             let (input, _) = eof(input)?;
-            Ok((input, Ok(Compose(AddAttachmentPipe(cmd.to_string())))))
+            Ok((
+                input,
+                Ok(Tab(ComposerAction(ComposerTabAction::AddAttachmentPipe(
+                    cmd.to_string(),
+                )))),
+            ))
         },
         |input: &'a [u8]| -> IResult<&'a [u8], Result<Action, CommandError>> {
             let mut check = arg_init! { min_arg:1, max_arg: 1, add_attachment};
@@ -671,32 +683,46 @@ pub fn add_attachment<'a>(input: &'a [u8]) -> IResult<&'a [u8], Result<Action, C
             let (input, path) = quoted_argument(input)?;
             arg_chk!(finish check, input);
             let (input, _) = eof(input)?;
-            Ok((input, Ok(Compose(AddAttachment(path.to_string())))))
-        },
-        |input: &'a [u8]| -> IResult<&'a [u8], Result<Action, CommandError>> {
-            let mut check = arg_init! { min_arg:0, max_arg: 0, add_attachment};
-            let (input, _) = tag("add-attachment-file-picker")(input.trim())?;
-            arg_chk!(start check, input);
-            arg_chk!(finish check, input);
-            let (input, _) = eof(input)?;
-            Ok((input, Ok(Compose(AddAttachmentFilePicker(None)))))
-        },
-        |input: &'a [u8]| -> IResult<&'a [u8], Result<Action, CommandError>> {
-            let mut check = arg_init! { min_arg:1, max_arg: 1, add_attachment_file_picker};
-            let (input, _) = tag("add-attachment-file-picker")(input.trim())?;
-            arg_chk!(start check, input);
-            let (input, _) = is_a(" ")(input)?;
-            let (input, _) = tag("<")(input.trim())?;
-            let (input, _) = is_a(" ")(input)?;
-            arg_chk!(inc check, input);
-            let (input, shell) = map_res(not_line_ending, std::str::from_utf8)(input)?;
-            arg_chk!(finish check, input);
-            let (input, _) = eof(input)?;
             Ok((
                 input,
-                Ok(Compose(AddAttachmentFilePicker(Some(shell.to_string())))),
+                Ok(Tab(ComposerAction(ComposerTabAction::AddAttachment(
+                    path.to_string(),
+                )))),
             ))
         },
+        alt((
+            |input: &'a [u8]| -> IResult<&'a [u8], Result<Action, CommandError>> {
+                let mut check = arg_init! { min_arg:1, max_arg: 1, add_attachment_file_picker};
+                let (input, _) = tag("add-attachment-file-picker")(input.trim())?;
+                arg_chk!(start check, input);
+                let (input, _) = is_a(" ")(input)?;
+                let (input, _) = tag("<")(input.trim())?;
+                let (input, _) = is_a(" ")(input)?;
+                arg_chk!(inc check, input);
+                let (input, shell) = map_res(not_line_ending, std::str::from_utf8)(input)?;
+                arg_chk!(finish check, input);
+                let (input, _) = eof(input)?;
+                Ok((
+                    input,
+                    Ok(Tab(ComposerAction(
+                        ComposerTabAction::AddAttachmentFilePicker(Some(shell.to_string())),
+                    ))),
+                ))
+            },
+            |input: &'a [u8]| -> IResult<&'a [u8], Result<Action, CommandError>> {
+                let mut check = arg_init! { min_arg:0, max_arg: 0, add_attachment};
+                let (input, _) = tag("add-attachment-file-picker")(input.trim())?;
+                arg_chk!(start check, input);
+                arg_chk!(finish check, input);
+                let (input, _) = eof(input)?;
+                Ok((
+                    input,
+                    Ok(Tab(ComposerAction(
+                        ComposerTabAction::AddAttachmentFilePicker(None),
+                    ))),
+                ))
+            },
+        )),
     ))(input)
 }
 pub fn remove_attachment(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
@@ -708,7 +734,12 @@ pub fn remove_attachment(input: &[u8]) -> IResult<&[u8], Result<Action, CommandE
     let (input, idx) = map_res(quoted_argument, usize::from_str)(input)?;
     arg_chk!(finish check, input);
     let (input, _) = eof(input)?;
-    Ok((input, Ok(Compose(RemoveAttachment(idx)))))
+    Ok((
+        input,
+        Ok(Tab(ComposerAction(ComposerTabAction::RemoveAttachment(
+            idx,
+        )))),
+    ))
 }
 pub fn save_draft(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
     let mut check = arg_init! { min_arg:0, max_arg: 0, save_draft };
@@ -716,7 +747,18 @@ pub fn save_draft(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>>
     arg_chk!(start check, input);
     arg_chk!(finish check, input);
     let (input, _) = eof(input)?;
-    Ok((input, Ok(Compose(SaveDraft))))
+    Ok((input, Ok(Tab(ComposerAction(ComposerTabAction::SaveDraft)))))
+}
+pub fn discard_draft(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
+    let mut check = arg_init! { min_arg:0, max_arg: 0, discard_draft };
+    let (input, _) = tag("discard-draft")(input.trim())?;
+    arg_chk!(start check, input);
+    arg_chk!(finish check, input);
+    let (input, _) = eof(input)?;
+    Ok((
+        input,
+        Ok(Tab(ComposerAction(ComposerTabAction::DiscardDraft))),
+    ))
 }
 pub fn create_mailbox(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
     let mut check = arg_init! { min_arg:1, max_arg: 1, create_malbox};
@@ -854,6 +896,35 @@ pub fn save_attachment(input: &[u8]) -> IResult<&[u8], Result<Action, CommandErr
     let (input, _) = eof(input)?;
     Ok((input, Ok(View(SaveAttachment(idx, path.to_string())))))
 }
+pub fn pipe_attachment<'a>(input: &'a [u8]) -> IResult<&'a [u8], Result<Action, CommandError>> {
+    let mut check = arg_init! { min_arg:2, max_arg:{u8::MAX}, pipe_attachment};
+    let (input, _) = tag("pipe-attachment")(input.trim())?;
+    arg_chk!(start check, input);
+    let (input, _) = is_a(" ")(input)?;
+    arg_chk!(inc check, input);
+    let (input, idx) = map_res(quoted_argument, usize::from_str)(input)?;
+    let (input, _) = is_a(" ")(input)?;
+    arg_chk!(inc check, input);
+    let (input, bin) = quoted_argument(input)?;
+    arg_chk!(inc check, input);
+    let (input, args) = alt((
+        |input: &'a [u8]| -> IResult<&'a [u8], Vec<String>> {
+            let (input, _) = is_a(" ")(input)?;
+            let (input, args) = separated_list1(is_a(" "), quoted_argument)(input)?;
+            let (input, _) = eof(input)?;
+            Ok((
+                input,
+                args.into_iter().map(String::from).collect::<Vec<String>>(),
+            ))
+        },
+        |input: &'a [u8]| -> IResult<&'a [u8], Vec<String>> {
+            let (input, _) = eof(input)?;
+            Ok((input, Vec::with_capacity(0)))
+        },
+    ))(input)?;
+    arg_chk!(finish check, input);
+    Ok((input, Ok(View(PipeAttachment(idx, bin.to_string(), args)))))
+}
 pub fn export_mail(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
     let mut check = arg_init! { min_arg:1, max_arg: 1, export_mail};
     let (input, _) = tag("export-mail")(input.trim())?;
@@ -961,8 +1032,13 @@ pub fn toggle(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
     for (tok, action) in [
         ("thread_snooze", Listing(ToggleThreadSnooze)),
         ("mouse", ToggleMouse),
-        ("sign", Compose(ToggleSign)),
-        ("encrypt", Compose(ToggleEncrypt)),
+        #[cfg(feature = "gpgme")]
+        ("sign", Tab(ComposerAction(ComposerTabAction::ToggleSign))),
+        #[cfg(feature = "gpgme")]
+        (
+            "encrypt",
+            Tab(ComposerAction(ComposerTabAction::ToggleEncrypt)),
+        ),
     ] {
         if let Ok((inner_input, _)) = tag!()(tok)(input.trim()) {
             input = inner_input;
@@ -1004,36 +1080,38 @@ pub fn manage_jobs(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>>
     Ok((input, Ok(Tab(ManageJobs))))
 }
 
-#[cfg(feature = "cli-docs")]
 pub fn view_manpage(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
     let mut check = arg_init! { min_arg:1, max_arg: 1, view_manpage };
     let (input, _) = tag("man")(input.trim())?;
     arg_chk!(start check, input);
     let (input, _) = is_a(" ")(input)?;
     arg_chk!(inc check, input);
+    #[allow(unused_variables)]
     let (input, manpage) = map_res(not_line_ending, std::str::from_utf8)(input.trim())?;
     let (input, _) = eof(input)?;
     arg_chk!(finish check, input);
-    match crate::manpages::parse_manpage(manpage) {
-        Ok(m) => Ok((input, Ok(Tab(Man(m))))),
-        Err(err) => Ok((
-            input,
-            Err(CommandError::BadValue {
-                inner: err.to_string().into(),
-                suggestions: Some(crate::manpages::POSSIBLE_VALUES),
-            }),
-        )),
+    #[cfg(feature = "cli-docs")]
+    {
+        match crate::manpages::parse_manpage(manpage) {
+            Ok(m) => Ok((input, Ok(Tab(Man(m))))),
+            Err(err) => Ok((
+                input,
+                Err(CommandError::BadValue {
+                    inner: err.to_string().into(),
+                    suggestions: Some(crate::manpages::POSSIBLE_VALUES),
+                }),
+            )),
+        }
+    }
+    #[cfg(not(feature = "cli-docs"))]
+    {
+        Ok((
+            input,
+            Err(CommandError::Other {
+                inner: "this meli binary has not been compiled with the cli-docs feature".into(),
+            }),
+        ))
     }
-}
-
-#[cfg(not(feature = "cli-docs"))]
-pub fn view_manpage(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {
-    Ok((
-        input,
-        Err(CommandError::Other {
-            inner: "this meli binary has not been compiled with the cli-docs feature".into(),
-        }),
-    ))
 }
 
 pub fn quit(input: &[u8]) -> IResult<&[u8], Result<Action, CommandError>> {

meli/src/command/tests.rs

@@ -0,0 +1,206 @@
+//
+// meli
+//
+// Copyright 2017- Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+use super::*;
+
+#[test]
+fn test_command_parser() {
+    let mut input = "sort".to_string();
+    macro_rules! match_input {
+        ($input:expr) => {{
+            let mut sugg: HashSet<String> = Default::default();
+            //print!("{}", $input);
+            for (_tags, _desc, tokens, _) in COMMAND_COMPLETION.iter() {
+                //    //println!("{:?}, {:?}, {:?}", _tags, _desc, tokens);
+                let _ = tokens.matches(&mut $input.as_str(), &mut sugg);
+                //    if !m.is_empty() {
+                //        //print!("{:?} ", desc);
+                //        //println!(" result = {:#?}\n\n", m);
+                //    }
+            }
+            //println!("suggestions = {:#?}", sugg);
+            sugg.into_iter()
+                .map(|s| format!("{}{}", $input.as_str(), s.as_str()))
+                .collect::<HashSet<String>>()
+        }};
+    }
+    assert_eq!(
+        &match_input!(input),
+        &IntoIterator::into_iter(["sort date".to_string(), "sort subject".to_string()]).collect(),
+    );
+    input = "so".to_string();
+    assert_eq!(
+        &match_input!(input),
+        &IntoIterator::into_iter(["sort".to_string()]).collect(),
+    );
+    input = "so ".to_string();
+    assert_eq!(&match_input!(input), &HashSet::default(),);
+    input = "to".to_string();
+    assert_eq!(
+        &match_input!(input),
+        &IntoIterator::into_iter(["toggle".to_string()]).collect(),
+    );
+    input = "toggle ".to_string();
+    assert_eq!(
+        &match_input!(input),
+        &IntoIterator::into_iter([
+            "toggle mouse".to_string(),
+            "toggle sign".to_string(),
+            "toggle encrypt".to_string(),
+            "toggle thread_snooze".to_string()
+        ])
+        .collect(),
+    );
+}
+
+#[test]
+#[ignore]
+fn test_command_parser_interactive() {
+    use std::io;
+    let mut input = String::new();
+    loop {
+        input.clear();
+        print!("> ");
+        match io::stdin().read_line(&mut input) {
+            Ok(_n) => {
+                println!("Input is {:?}", input.as_str().trim());
+                let mut sugg: HashSet<String> = Default::default();
+                let mut vec = vec![];
+                //print!("{}", input);
+                for (_tags, _desc, tokens, _) in COMMAND_COMPLETION.iter() {
+                    //println!("{:?}, {:?}, {:?}", _tags, _desc, tokens);
+                    let m = tokens.matches(&mut input.as_str().trim(), &mut sugg);
+                    if !m.is_empty() {
+                        vec.push(tokens);
+                        //print!("{:?} ", desc);
+                        //println!(" result = {:#?}\n\n", m);
+                    }
+                }
+                println!(
+                    "suggestions = {:#?}",
+                    sugg.into_iter()
+                        .zip(vec.into_iter())
+                        .map(|(s, v)| format!(
+                            "{}{} {:?}",
+                            input.as_str().trim(),
+                            if input.trim().is_empty() {
+                                s.trim()
+                            } else {
+                                s.as_str()
+                            },
+                            v
+                        ))
+                        .collect::<Vec<String>>()
+                );
+                if input.trim() == "quit" {
+                    break;
+                }
+            }
+            Err(error) => println!("error: {}", error),
+        }
+    }
+    println!("alright");
+}
+
+#[test]
+fn test_command_parser_all() {
+    use CommandError::*;
+
+    for cmd in [
+        "set unseen",
+        "set seen",
+        "delete",
+        "copyto somewhere",
+        "moveto somewhere",
+        "import fpath mpath",
+        "close  ",
+        "go 5",
+    ] {
+        parse_command(cmd.as_bytes()).unwrap_or_else(|err| panic!("{} failed {}", cmd, err));
+    }
+
+    assert_eq!(
+        parse_command(b"setfafsfoo").unwrap_err().to_string(),
+        Parsing {
+            inner: "setfafsfoo".into(),
+            kind: "".into(),
+        }
+        .to_string(),
+    );
+    assert_eq!(
+        parse_command(b"set foo").unwrap_err().to_string(),
+        BadValue {
+            inner: "foo".into(),
+            suggestions: Some(&[
+                "seen",
+                "unseen",
+                "plain",
+                "threaded",
+                "compact",
+                "conversations"
+            ])
+        }
+        .to_string(),
+    );
+    assert_eq!(
+        parse_command(b"moveto ").unwrap_err().to_string(),
+        WrongNumberOfArguments {
+            too_many: false,
+            takes: (1, Some(1)),
+            given: 0,
+            __func__: "moveto",
+            inner: "".into(),
+        }
+        .to_string(),
+    );
+    assert_eq!(
+        parse_command(b"reindex 1 2 3").unwrap_err().to_string(),
+        WrongNumberOfArguments {
+            too_many: true,
+            takes: (1, Some(1)),
+            given: 2,
+            __func__: "reindex",
+            inner: "".into(),
+        }
+        .to_string(),
+    );
+}
+
+#[test]
+fn test_command_error_display() {
+    assert_eq!(
+        &CommandError::BadValue {
+            inner: "foo".into(),
+            suggestions: Some(&[
+                "seen",
+                "unseen",
+                "plain",
+                "threaded",
+                "compact",
+                "conversations"
+            ])
+        }
+        .to_string(),
+        "Bad value/argument: foo. Possible values are: seen, unseen, plain, threaded, compact, \
+         conversations"
+    );
+}

meli/src/components.rs

@@ -126,6 +126,8 @@ pub enum ScrollUpdate {
     },
 }
 
+/// A user interface component (also referred to as a UI widget).
+///
 /// Types implementing this Trait can draw on the terminal and receive events.
 /// If a type wants to skip drawing if it has not changed anything, it can hold
 /// some flag in its fields (eg `self.dirty = false`) and act upon that in their
@@ -248,6 +250,12 @@ impl Component for Box<dyn Component> {
     }
 }
 
+impl PartialEq for Box<dyn Component> {
+    fn eq(&self, other: &Self) -> bool {
+        self == other || self.id() == other.id()
+    }
+}
+
 bitflags::bitflags! {
     /// Attributes of a [`Component`] widget.
     ///
@@ -297,7 +305,7 @@ impl ComponentPath {
                 // log::trace!("continue;");
                 continue;
             }
-            cursor = cursor.children().remove(id)?;
+            cursor = cursor.children().shift_remove(id)?;
         }
         Some(cursor)
     }
@@ -312,3 +320,22 @@ impl ComponentPath {
         self.tail.last()
     }
 }
+
+pub mod prelude {
+    pub use std::borrow::Cow;
+
+    pub use indexmap::IndexMap;
+
+    pub use crate::{
+        accounts::MailboxEntry,
+        command::*,
+        components::{
+            Component, ComponentAttr, ComponentId, ComponentPath, ExtendShortcutsMaps,
+            ScrollContext, *,
+        },
+        jobs::{JobId, JobMetadata},
+        melib::{text::TextProcessing, utils::datetime, SortOrder},
+        shortcut, AccountHash, Action, Area, Attr, CellBuffer, Context, DataColumns, EnvelopeHash,
+        Key, MailboxHash, Shortcuts, StatusEvent, ThemeAttribute, UIDialog, UIEvent, UIMode,
+    };
+}

meli/src/conf/composing.rs

@@ -20,13 +20,15 @@
  */
 
 //! Configuration for composing email.
-use std::collections::HashMap;
 
+use std::path::PathBuf;
+
+use indexmap::IndexMap;
 use melib::{conf::ActionFlag, email::HeaderName};
 use serde::{de, Deserialize, Deserializer};
 
-use super::{
-    default_vals::{ask, false_val, none, true_val},
+use crate::conf::{
+    default_values::{ask, false_val, none, true_val},
     deserializers::non_empty_string,
 };
 
@@ -34,9 +36,6 @@ use super::{
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct ComposingSettings {
-    /// A command to pipe new emails to
-    /// Required
-    pub send_mail: SendMail,
     /// Command to launch editor. Can have arguments. Draft filename is given as
     /// the last argument. If it's missing, the environment variable $EDITOR is
     /// looked up.
@@ -62,7 +61,7 @@ pub struct ComposingSettings {
     /// Set default header values for new drafts
     /// Default: empty
     #[serde(default, alias = "default-header-values")]
-    pub default_header_values: HashMap<HeaderName, String>,
+    pub default_header_values: IndexMap<HeaderName, String>,
     /// Wrap header preamble when editing a draft in an editor. This allows you
     /// to write non-plain text email without the preamble creating syntax
     /// errors. They are stripped when you return from the editor. The
@@ -75,11 +74,13 @@ pub struct ComposingSettings {
     /// mail on its own. Default: true
     #[serde(default = "true_val")]
     pub store_sent_mail: bool,
-    /// The attribution line appears above the quoted reply text.
+    /// The attribution line that appears above the quoted reply text.
+    ///
     /// The format specifiers for the replied address are:
     /// - `%+f` — the sender's name and email address.
     /// - `%+n` — the sender's name (or email address, if no name is included).
     /// - `%+a` — the sender's email address.
+    ///
     /// The format string is passed to strftime(3) with the replied envelope's
     /// date. Default: "On %a, %0e %b %Y %H:%M, %+f wrote:%n"
     #[serde(default = "none")]
@@ -111,17 +112,44 @@ pub struct ComposingSettings {
     /// Disabled `compose-hooks`.
     #[serde(default, alias = "disabled-compose-hooks")]
     pub disabled_compose_hooks: Vec<String>,
+    /// Plain text file with signature that will pre-populate an email draft.
+    ///
+    /// Signatures must be explicitly enabled to be used, otherwise this setting
+    /// will be ignored.
+    ///
+    /// Default: `None`
+    #[serde(default, alias = "signature-file")]
+    pub signature_file: Option<PathBuf>,
+    /// Pre-populate email drafts with signature, if any.
+    ///
+    /// `meli` will lookup the signature value in this order:
+    ///
+    /// 1. The `signature_file` setting.
+    /// 2. `${XDG_CONFIG_DIR}/meli/<account>/signature`
+    /// 3. `${XDG_CONFIG_DIR}/meli/signature`
+    /// 4. `${XDG_CONFIG_DIR}/signature`
+    /// 5. `${HOME}/.signature`
+    /// 6. No signature otherwise.
+    ///
+    /// Default: `false`
+    #[serde(default = "false_val", alias = "use-signature")]
+    pub use_signature: bool,
+    /// Signature delimiter, that is, text that will be prefixed to your
+    /// signature to separate it from the email body.
+    ///
+    /// Default: `"\n\n-- \n"`
+    #[serde(default, alias = "signature-delimiter")]
+    pub signature_delimiter: Option<String>,
 }
 
 impl Default for ComposingSettings {
     fn default() -> Self {
         Self {
-            send_mail: SendMail::ShellCommand("false".into()),
             editor_command: None,
             embedded_pty: false,
             format_flowed: true,
             insert_user_agent: true,
-            default_header_values: HashMap::default(),
+            default_header_values: IndexMap::default(),
             store_sent_mail: true,
             wrap_header_preamble: None,
             attribution_format_string: None,
@@ -131,6 +159,9 @@ impl Default for ComposingSettings {
             reply_prefix: res(),
             custom_compose_hooks: vec![],
             disabled_compose_hooks: vec![],
+            signature_file: None,
+            use_signature: false,
+            signature_delimiter: None,
         }
     }
 }
@@ -187,6 +218,14 @@ pub enum SendMail {
     ShellCommand(String),
 }
 
+impl Default for SendMail {
+    /// Returns the `false` POSIX shell utility, in order to return an error
+    /// when called.
+    fn default() -> Self {
+        Self::ShellCommand("false".into())
+    }
+}
+
 /// Shell command compose hooks (See
 /// [`crate::mail::compose::hooks::Hook`])
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -220,9 +259,10 @@ Using a shell script
 Direct SMTP connection
 ======================
 
+    [accounts.account-name]
     send_mail = { hostname = "mail.example.com", port = 587, auth = { type = "auto", password = { type = "raw", value = "hunter2" } }, security = { type = "STARTTLS" } }
 
-    [composing.send_mail]
+    [accounts.account-name.send_mail]
     hostname = "mail.example.com"
     port = 587
     auth = { type = "auto", password = { type = "command_eval", value = "/path/to/password_script.sh" } }
@@ -284,6 +324,8 @@ impl<'de> Deserialize<'de> for SendMail {
     where
         D: Deserializer<'de>,
     {
+        use serde::de::Error;
+
         #[derive(Deserialize)]
         #[serde(untagged)]
         enum SendMailInner {
@@ -294,11 +336,17 @@ impl<'de> Deserialize<'de> for SendMail {
             ShellCommand(String),
         }
 
-        match <SendMailInner>::deserialize(deserializer) {
+        match melib::serde_path_to_error::deserialize(deserializer) {
             #[cfg(feature = "smtp")]
             Ok(SendMailInner::Smtp(v)) => Ok(Self::Smtp(v)),
             Ok(SendMailInner::ServerSubmission) => Ok(Self::ServerSubmission),
             Ok(SendMailInner::ShellCommand(v)) => Ok(Self::ShellCommand(v)),
+            Err(err)
+                if err.inner().to_string() == D::Error::missing_field("send_mail").to_string() =>
+            {
+                // Surely there should be a better way to do this...
+                Err(err.into_inner())
+            }
             Err(_err) => Err(de::Error::custom(SENDMAIL_ERR_HELP)),
         }
     }

meli/src/conf/data_types/dotaddressable.rs

@@ -0,0 +1,294 @@
+//
+// meli
+//
+// Copyright 2017- Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+use crate::conf::*;
+
+pub trait DotAddressable: serde::Serialize {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        if !path.is_empty() {
+            Err(Error::new(format!(
+                "{} has no fields, it is of type {}",
+                parent_field,
+                std::any::type_name::<Self>()
+            )))
+        } else {
+            Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string())
+        }
+    }
+}
+
+impl DotAddressable for bool {}
+
+impl DotAddressable for String {}
+impl DotAddressable for char {}
+impl DotAddressable for data_types::IndexStyle {}
+impl DotAddressable for data_types::SearchBackend {}
+impl DotAddressable for data_types::ThreadLayout {}
+impl DotAddressable for u64 {}
+impl DotAddressable for TagHash {}
+impl DotAddressable for crate::terminal::Color {}
+impl DotAddressable for crate::terminal::Attr {}
+impl DotAddressable for crate::terminal::Key {}
+impl DotAddressable for usize {}
+impl DotAddressable for Query {}
+impl DotAddressable for melib::LogLevel {}
+impl DotAddressable for PathBuf {}
+impl DotAddressable for ToggleFlag {}
+impl DotAddressable for ActionFlag {}
+impl DotAddressable for melib::SpecialUsageMailbox {}
+impl<T: DotAddressable> DotAddressable for Option<T> {}
+impl<T: DotAddressable> DotAddressable for Vec<T> {}
+// impl<K: DotAddressable + std::cmp::Eq + std::hash::Hash, V: DotAddressable>
+// DotAddressable     for HashMap<K, V>
+// {
+// }
+// impl<K: DotAddressable + std::cmp::Eq + std::hash::Hash> DotAddressable for
+// HashSet<K> {}
+impl<K: DotAddressable + std::cmp::Eq + std::hash::Hash, V: DotAddressable> DotAddressable
+    for indexmap::IndexMap<K, V>
+{
+}
+impl<K: DotAddressable + std::cmp::Eq + std::hash::Hash> DotAddressable for indexmap::IndexSet<K> {}
+impl DotAddressable for (SortField, SortOrder) {}
+
+impl DotAddressable for LogSettings {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "log_file" => self.log_file.lookup(field, tail),
+                    "maximum_level" => self.maximum_level.lookup(field, tail),
+
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for Settings {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "accounts" => self.accounts.lookup(field, tail),
+                    "pager" => self.pager.lookup(field, tail),
+                    "listing" => self.listing.lookup(field, tail),
+                    "notifications" => self.notifications.lookup(field, tail),
+                    "shortcuts" => self.shortcuts.lookup(field, tail),
+                    "tags" => Err(Error::new("unimplemented")),
+                    "composing" => Err(Error::new("unimplemented")),
+                    "pgp" => Err(Error::new("unimplemented")),
+                    "terminal" => self.terminal.lookup(field, tail),
+                    "log" => self.log.lookup(field, tail),
+
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for AccountConf {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "account" => self.account.lookup(field, tail),
+                    "conf" => self.conf.lookup(field, tail),
+                    "conf_override" => self.conf_override.lookup(field, tail),
+                    "mailbox_confs" => self.mailbox_confs.lookup(field, tail),
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for MailUIConf {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let _tail = &path[1..];
+                match *field {
+                    "pager" => Err(Error::new("unimplemented")), /* self.pager.lookup(field, */
+                    // tail),
+                    "listing" => Err(Error::new("unimplemented")), /* self.listing.lookup(field, */
+                    // tail),
+                    "notifications" => Err(Error::new("unimplemented")), /* self.notifications.lookup(field, tail), */
+                    "shortcuts" => Err(Error::new("unimplemented")),     /* self.shortcuts. */
+                    // lookup(field,
+                    // tail),
+                    "composing" => Err(Error::new("unimplemented")), /* self.composing. */
+                    // lookup(field, tail),
+                    "identity" => Err(Error::new("unimplemented")), /* self.identity. */
+                    // lookup(field,
+                    // tail)<String>,
+                    "tags" => Err(Error::new("unimplemented")), /* self.tags.lookup(field, */
+                    // tail),
+                    "themes" => Err(Error::new("unimplemented")), /* self.themes. */
+                    // lookup(field,
+                    // tail)<Themes>,
+                    "pgp" => Err(Error::new("unimplemented")), //self.pgp.lookup(field, tail),
+
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for FileMailboxConf {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "conf_override" => self.conf_override.lookup(field, tail),
+                    "mailbox_conf" => self.mailbox_conf.lookup(field, tail),
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for FileAccount {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "root_mailbox" => self.root_mailbox.lookup(field, tail),
+                    "format" => self.format.lookup(field, tail),
+                    "identity" => self.identity.lookup(field, tail),
+                    "display_name" => self.display_name.lookup(field, tail),
+                    "read_only" => self.read_only.lookup(field, tail),
+                    "subscribed_mailboxes" => self.subscribed_mailboxes.lookup(field, tail),
+                    "mailboxes" => self.mailboxes.lookup(field, tail),
+                    "search_backend" => self.search_backend.lookup(field, tail),
+                    "manual_refresh" => self.manual_refresh.lookup(field, tail),
+                    "refresh_command" => self.refresh_command.lookup(field, tail),
+                    "conf_override" => self.conf_override.lookup(field, tail),
+                    "extra" => self.extra.lookup(field, tail),
+                    "order" => self.order.lookup(field, tail),
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for melib::AccountSettings {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "name" => self.name.lookup(field, tail),
+                    "root_mailbox" => self.root_mailbox.lookup(field, tail),
+                    "format" => self.format.lookup(field, tail),
+                    "identity" => self.identity.lookup(field, tail),
+                    "read_only" => self.read_only.lookup(field, tail),
+                    "display_name" => self.display_name.lookup(field, tail),
+                    "subscribed_mailboxes" => self.subscribed_mailboxes.lookup(field, tail),
+                    "mailboxes" => self.mailboxes.lookup(field, tail),
+                    "manual_refresh" => self.manual_refresh.lookup(field, tail),
+                    "extra" => self.extra.lookup(field, tail),
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}
+
+impl DotAddressable for melib::MailboxConf {
+    fn lookup(&self, parent_field: &str, path: &[&str]) -> Result<String> {
+        match path.first() {
+            Some(field) => {
+                let tail = &path[1..];
+                match *field {
+                    "alias" => self.alias.lookup(field, tail),
+                    "autoload" => self.autoload.lookup(field, tail),
+                    "subscribe" => self.subscribe.lookup(field, tail),
+                    "ignore" => self.ignore.lookup(field, tail),
+                    "usage" => self.usage.lookup(field, tail),
+                    "extra" => self.extra.lookup(field, tail),
+                    other => Err(Error::new(format!(
+                        "{} has no field named {}",
+                        parent_field, other
+                    ))),
+                }
+            }
+            None => Ok(toml::Value::try_from(self)
+                .map_err(|err| err.to_string())?
+                .to_string()),
+        }
+    }
+}

meli/src/conf/data_types/mod.rs

@@ -0,0 +1,163 @@
+//
+// meli
+//
+// Copyright 2024 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+pub mod dotaddressable;
+pub mod regex_pattern;
+
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+pub enum IndexStyle {
+    Plain,
+    Threaded,
+    #[default]
+    Compact,
+    Conversations,
+}
+
+impl<'de> Deserialize<'de> for IndexStyle {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = <String>::deserialize(deserializer)?;
+        match s.as_str() {
+            plain if plain.eq_ignore_ascii_case("plain") => Ok(Self::Plain),
+            threaded if threaded.eq_ignore_ascii_case("threaded") => Ok(Self::Threaded),
+            compact if compact.eq_ignore_ascii_case("compact") => Ok(Self::Compact),
+            conversations if conversations.eq_ignore_ascii_case("conversations") => {
+                Ok(Self::Conversations)
+            }
+            _ => Err(de::Error::custom(
+                "invalid `index_style` value, expected one of: \"plain\", \"threaded\", \
+                 \"compact\" or \"conversations\".",
+            )),
+        }
+    }
+}
+
+impl Serialize for IndexStyle {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::Plain => serializer.serialize_str("plain"),
+            Self::Threaded => serializer.serialize_str("threaded"),
+            Self::Compact => serializer.serialize_str("compact"),
+            Self::Conversations => serializer.serialize_str("conversations"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub enum SearchBackend {
+    None,
+    #[default]
+    Auto,
+    #[cfg(feature = "sqlite3")]
+    Sqlite3,
+}
+
+impl<'de> Deserialize<'de> for SearchBackend {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = <String>::deserialize(deserializer)?;
+        match s.as_str() {
+            #[cfg(feature = "sqlite3")]
+            sqlite3
+                if sqlite3.eq_ignore_ascii_case("sqlite3")
+                    || sqlite3.eq_ignore_ascii_case("sqlite") =>
+            {
+                Ok(Self::Sqlite3)
+            }
+            none if none.eq_ignore_ascii_case("none")
+                || none.eq_ignore_ascii_case("nothing")
+                || none.is_empty() =>
+            {
+                Ok(Self::None)
+            }
+            auto if auto.eq_ignore_ascii_case("auto") => Ok(Self::Auto),
+            _ => Err(de::Error::custom(if cfg!(feature = "sqlite3") {
+                "invalid `search_backend` value, expected one of: \"sqlite3\", \"sqlite\", \
+                 \"none\" or \"auto\"."
+            } else {
+                "invalid `search_backend` value, expected one of: \"none\" or \"auto\"."
+            })),
+        }
+    }
+}
+
+impl Serialize for SearchBackend {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            #[cfg(feature = "sqlite3")]
+            Self::Sqlite3 => serializer.serialize_str("sqlite3"),
+            Self::None => serializer.serialize_str("none"),
+            Self::Auto => serializer.serialize_str("auto"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+pub enum ThreadLayout {
+    Vertical,
+    Horizontal,
+    #[default]
+    Auto,
+}
+
+impl<'de> Deserialize<'de> for ThreadLayout {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = <String>::deserialize(deserializer)?;
+        match s.as_str() {
+            vertical if vertical.eq_ignore_ascii_case("vertical") => Ok(Self::Vertical),
+            horizontal if horizontal.eq_ignore_ascii_case("horizontal") => Ok(Self::Horizontal),
+            auto if auto.eq_ignore_ascii_case("auto") => Ok(Self::Auto),
+            _ => Err(de::Error::custom(
+                "invalid `thread_layout` value, expected one of: \"vertical\", \"horizontal\" or \
+                 \"auto\".",
+            )),
+        }
+    }
+}
+
+impl Serialize for ThreadLayout {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::Vertical => serializer.serialize_str("vertical"),
+            Self::Horizontal => serializer.serialize_str("horizontal"),
+            Self::Auto => serializer.serialize_str("auto"),
+        }
+    }
+}

meli/src/conf/data_types/regex_pattern.rs

@@ -0,0 +1,215 @@
+//
+// meli
+//
+// Copyright 2024 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+use melib::error::{Result, WrapResultIntoError};
+use serde::{Deserialize, Deserializer};
+
+const fn lf_val() -> u8 {
+    b'\n'
+}
+
+#[derive(Clone, Debug)]
+pub enum RegexValue {
+    Default {
+        pattern: regex::Regex,
+    },
+    Builder {
+        pattern: regex::Regex,
+        options: RegexOptions,
+    },
+}
+
+impl RegexValue {
+    pub fn new_with_options(pattern: &str, o: RegexOptions) -> Result<Self> {
+        let mut b = regex::RegexBuilder::new(pattern);
+        b.unicode(o.unicode)
+            .case_insensitive(o.case_insensitive)
+            .multi_line(o.multi_line)
+            .dot_matches_new_line(o.dot_matches_new_line)
+            .crlf(o.crlf)
+            .line_terminator(o.line_terminator)
+            .swap_greed(o.swap_greed)
+            .ignore_whitespace(o.ignore_whitespace)
+            .octal(o.octal);
+        if let Some(v) = o.size_limit {
+            b.size_limit(v);
+        }
+        let pattern = b
+            .build()
+            .wrap_err(|| format!("Could not compile regular expression `{}`", pattern))?;
+        Ok(Self::Builder {
+            pattern,
+            options: o,
+        })
+    }
+
+    pub fn find_iter<'w, 's>(&'w self, s: &'s str) -> FindIter<'w, 's> {
+        let (Self::Default { pattern } | Self::Builder { pattern, .. }) = self;
+        FindIter {
+            iter: pattern.find_iter(s),
+            char_indices: s.char_indices(),
+            char_offset: 0,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
+pub struct RegexOptions {
+    #[serde(default = "crate::conf::true_val")]
+    unicode: bool,
+    #[serde(default = "crate::conf::false_val")]
+    case_insensitive: bool,
+    #[serde(default = "crate::conf::false_val")]
+    multi_line: bool,
+    #[serde(default = "crate::conf::false_val")]
+    dot_matches_new_line: bool,
+    #[serde(default = "crate::conf::false_val")]
+    crlf: bool,
+    #[serde(default = "lf_val")]
+    line_terminator: u8,
+    #[serde(default = "crate::conf::false_val")]
+    swap_greed: bool,
+    #[serde(default = "crate::conf::false_val")]
+    ignore_whitespace: bool,
+    #[serde(default = "crate::conf::false_val")]
+    octal: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    size_limit: Option<usize>,
+}
+
+impl Default for RegexOptions {
+    fn default() -> Self {
+        Self {
+            unicode: true,
+            case_insensitive: false,
+            multi_line: false,
+            dot_matches_new_line: false,
+            crlf: false,
+            line_terminator: b'\n',
+            swap_greed: false,
+            ignore_whitespace: false,
+            octal: false,
+            size_limit: None,
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for RegexValue {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // [ref:FIXME]: clippy false positive, remove when resolved.
+        #![allow(clippy::collection_is_never_read)]
+
+        #[derive(Deserialize)]
+        #[serde(untagged)]
+        enum Inner<'a> {
+            Default {
+                pattern: &'a str,
+            },
+            Builder {
+                pattern: &'a str,
+                #[serde(flatten)]
+                o: RegexOptions,
+            },
+        }
+        let s = <Inner>::deserialize(deserializer);
+        Ok(
+            match s.map_err(|err| {
+                serde::de::Error::custom(format!(
+                    r#"expected one of "true", "false", "ask", found `{}`"#,
+                    err
+                ))
+            })? {
+                Inner::Default { pattern } => Self::Default {
+                    pattern: regex::Regex::new(pattern).map_err(|err| {
+                        serde::de::Error::custom(format!(
+                            "Could not compile regular expression `{}`: {}",
+                            pattern, err
+                        ))
+                    })?,
+                },
+                Inner::Builder { pattern, o } => {
+                    let mut b = regex::RegexBuilder::new(pattern);
+                    b.unicode(o.unicode)
+                        .case_insensitive(o.case_insensitive)
+                        .multi_line(o.multi_line)
+                        .dot_matches_new_line(o.dot_matches_new_line)
+                        .crlf(o.crlf)
+                        .line_terminator(o.line_terminator)
+                        .swap_greed(o.swap_greed)
+                        .ignore_whitespace(o.ignore_whitespace)
+                        .octal(o.octal);
+                    if let Some(v) = o.size_limit {
+                        b.size_limit(v);
+                    }
+                    let pattern = b.build().map_err(|err| {
+                        serde::de::Error::custom(format!(
+                            "Could not compile regular expression `{}`: {}",
+                            pattern, err
+                        ))
+                    })?;
+                    Self::Builder {
+                        pattern,
+                        options: o,
+                    }
+                }
+            },
+        )
+    }
+}
+
+pub struct FindIter<'r, 's> {
+    iter: regex::Matches<'r, 's>,
+    char_indices: std::str::CharIndices<'s>,
+    char_offset: usize,
+}
+
+impl Iterator for FindIter<'_, '_> {
+    type Item = (usize, usize);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next_byte_offset = self.iter.next()?;
+
+        let mut next_char_index = self.char_indices.next()?;
+
+        while next_byte_offset.start() < next_char_index.0 {
+            self.char_offset += 1;
+            next_char_index = self.char_indices.next()?;
+        }
+        let start = self.char_offset;
+
+        while next_byte_offset.end()
+            > self
+                .char_indices
+                .next()
+                .map(|(v, _)| v)
+                .unwrap_or_else(|| next_byte_offset.end())
+        {
+            self.char_offset += 1;
+        }
+        let end = self.char_offset + 1;
+
+        Some((start, end))
+    }
+}

meli/src/conf/default_values.rs

@@ -0,0 +1,65 @@
+//
+// meli
+//
+// Copyright 2017 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+//! default value functions for deserializing
+
+pub fn false_val<T: From<bool>>() -> T {
+    false.into()
+}
+
+pub fn true_val<T: From<bool>>() -> T {
+    true.into()
+}
+
+pub fn zero_val<T: From<usize>>() -> T {
+    0.into()
+}
+
+pub fn eighty_val<T: From<usize>>() -> T {
+    80.into()
+}
+
+pub fn none<T>() -> Option<T> {
+    None
+}
+
+pub fn internal_value_false<T: From<melib::conf::ToggleFlag>>() -> T {
+    melib::conf::ToggleFlag::InternalVal(false).into()
+}
+
+pub fn internal_value_true<T: From<melib::conf::ToggleFlag>>() -> T {
+    melib::conf::ToggleFlag::InternalVal(true).into()
+}
+
+pub fn action_internal_value_false<T: From<melib::ActionFlag>>() -> T {
+    melib::conf::ActionFlag::InternalVal(false).into()
+}
+
+//pub fn action_internal_value_true<
+//    T: From<melib::conf::ActionFlag>,
+//>() -> T {
+//    melib::conf::ActionFlag::InternalVal(true).into()
+//}
+
+pub fn ask<T: From<melib::conf::ActionFlag>>() -> T {
+    melib::conf::ActionFlag::Ask.into()
+}

meli/src/conf/listing.rs

@@ -21,7 +21,11 @@
 
 use melib::{search::Query, Error, Result, ToggleFlag};
 
-use super::{default_vals::*, DotAddressable, IndexStyle};
+use crate::conf::{
+    data_types::{IndexStyle, ThreadLayout},
+    default_values::*,
+    DotAddressable,
+};
 
 /// Settings for mail listings
 ///
@@ -167,6 +171,14 @@ pub struct ListingSettings {
     /// Hide sidebar on launch. Default: "false"
     #[serde(default = "false_val", alias = "hide-sidebar-on-launch")]
     pub hide_sidebar_on_launch: bool,
+
+    /// Default: ' '
+    #[serde(default = "default_divider")]
+    pub mail_view_divider: char,
+
+    /// Default: "auto"
+    #[serde(default)]
+    pub thread_layout: ThreadLayout,
 }
 
 const fn default_divider() -> char {
@@ -203,6 +215,8 @@ impl Default for ListingSettings {
             relative_menu_indices: true,
             relative_list_indices: true,
             hide_sidebar_on_launch: false,
+            mail_view_divider: default_divider(),
+            thread_layout: ThreadLayout::default(),
         }
     }
 }
@@ -246,6 +260,8 @@ impl DotAddressable for ListingSettings {
                     "relative_menu_indices" => self.relative_menu_indices.lookup(field, tail),
                     "relative_list_indices" => self.relative_list_indices.lookup(field, tail),
                     "hide_sidebar_on_launch" => self.hide_sidebar_on_launch.lookup(field, tail),
+                    "mail_view_divider" => self.mail_view_divider.lookup(field, tail),
+                    "thread_layout" => self.thread_layout.lookup(field, tail),
                     other => Err(Error::new(format!(
                         "{} has no field named {}",
                         parent_field, other

meli/src/conf/notifications.rs

@@ -21,8 +21,8 @@
 
 use melib::{Error, Result, ToggleFlag};
 
-use super::{
-    default_vals::{internal_value_false, none, true_val},
+use crate::conf::{
+    default_values::{internal_value_false, none, true_val},
     DotAddressable,
 };
 

meli/src/conf/pager.rs

@@ -24,7 +24,7 @@
 use indexmap::IndexMap;
 use melib::{Error, Result, ToggleFlag};
 
-use super::{default_vals::*, deserializers::*, DotAddressable};
+use crate::conf::{default_values::*, deserializers::*, DotAddressable};
 
 /// Settings for the pager function.
 #[derive(Clone, Debug, Deserialize, Serialize)]

meli/src/conf/pgp.rs

@@ -21,7 +21,7 @@
 
 use melib::conf::ActionFlag;
 
-use super::default_vals::*;
+use crate::conf::default_values::*;
 
 /// Settings for digital signing and encryption
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -60,6 +60,10 @@ pub struct PGPSettings {
     #[serde(default = "none", alias = "encrypt-key")]
     pub encrypt_key: Option<String>,
 
+    /// Default: true
+    #[serde(default = "true_val", alias = "encrypt-for-self")]
+    pub encrypt_for_self: bool,
+
     /// Allow remote lookups
     /// Default: False
     #[serde(
@@ -99,6 +103,7 @@ impl Default for PGPSettings {
             auto_decrypt: true.into(),
             auto_sign: false.into(),
             auto_encrypt: false.into(),
+            encrypt_for_self: true,
             sign_key: None,
             decrypt_key: None,
             encrypt_key: None,

meli/src/conf/preprocessing.rs

@@ -0,0 +1,281 @@
+//
+// meli
+//
+// Copyright 2017 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+//! Preprocess configuration files by unfolding `include` macros.
+
+use std::{
+    io::{self, BufRead, Read, Write},
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+    sync::Arc,
+};
+
+use melib::{
+    error::{Error, ErrorKind, Result, ResultIntoError, WrapResultIntoError},
+    utils::parsec::*,
+    ShellExpandTrait,
+};
+
+/// Try to parse line into a path to be included.
+pub fn include_directive<'a>() -> impl Parser<'a, Option<&'a str>> {
+    move |input: &'a str| {
+        enum State {
+            Start,
+            Path,
+        }
+        use State::*;
+        let mut state = State::Start;
+
+        let mut i = 0;
+        while i < input.len() {
+            match (&state, input.as_bytes()[i]) {
+                (Start, b'#') => {
+                    return Ok(("", None));
+                }
+                (Start, b) if (b as char).is_whitespace() => { /* consume */ }
+                (Start, _) if input.as_bytes()[i..].starts_with(b"include(") => {
+                    i += "include(".len();
+                    state = Path;
+                    continue;
+                }
+                (Start, _) => {
+                    return Ok(("", None));
+                }
+                (Path, b'"') | (Path, b'\'') | (Path, b'`') => {
+                    let mut end = i + 1;
+                    while end < input.len() && input.as_bytes()[end] != input.as_bytes()[i] {
+                        end += 1;
+                    }
+                    if end == input.len() {
+                        return Err(input);
+                    }
+                    let ret = &input[i + 1..end];
+                    end += 1;
+                    if end < input.len() && input.as_bytes()[end] != b')' {
+                        /* Nothing else allowed in line */
+                        return Err(input);
+                    }
+                    end += 1;
+                    while end < input.len() {
+                        if !(input.as_bytes()[end] as char).is_whitespace() {
+                            /* Nothing else allowed in line */
+                            return Err(input);
+                        }
+                        end += 1;
+                    }
+                    return Ok(("", Some(ret)));
+                }
+                (Path, _) => return Err(input),
+            }
+            i += 1;
+        }
+        Ok(("", None))
+    }
+}
+
+/// Expands `include` macros in path.
+fn pp_helper(path: &Path, level: u8) -> Result<String> {
+    if level > 7 {
+        return Err(Error::new(format!(
+            "Maximum recursion limit reached while unfolding include directives in {}. Have you \
+             included a config file within itself?",
+            path.display()
+        ))
+        .set_kind(ErrorKind::ValueError));
+    }
+    let mut contents = String::new();
+    let mut file = std::fs::File::open(path)?;
+    file.read_to_string(&mut contents)?;
+    let mut ret = String::with_capacity(contents.len());
+
+    for (i, l) in contents.lines().enumerate() {
+        if let (_, Some(sub_path)) = include_directive().parse(l).map_err(|l| {
+            Error::new(format!(
+                "Malformed include directive in line {} of file {}: {}\nConfiguration uses the \
+                 standard m4 macro include(\"filename\").",
+                i,
+                path.display(),
+                l
+            ))
+            .set_kind(ErrorKind::ValueError)
+        })? {
+            let mut p = Path::new(sub_path).expand();
+            if p.is_relative() {
+                /* We checked that path is ok above so we can do unwrap here */
+                let prefix = path.parent().unwrap();
+                p = prefix.join(p)
+            }
+
+            ret.push_str(&pp_helper(&p, level + 1).chain_err_related_path(&p)?);
+        } else {
+            ret.push_str(l);
+            ret.push('\n');
+        }
+    }
+
+    Ok(ret)
+}
+
+fn pp_inner(path: &Path) -> Result<String> {
+    let p_buf: PathBuf = if path.is_relative() {
+        path.expand().canonicalize()?
+    } else {
+        path.expand()
+    };
+
+    let mut ret = expand_config(&p_buf)?;
+    if let Ok(xdg_dirs) = xdg::BaseDirectories::with_prefix("meli") {
+        for theme_mailbox in xdg_dirs.find_config_files("themes") {
+            let read_dir =
+                std::fs::read_dir(&theme_mailbox).chain_err_related_path(&theme_mailbox)?;
+            for theme in read_dir {
+                let theme_path = theme?.path();
+                if let Some(extension) = theme_path.extension() {
+                    if extension == "toml" {
+                        ret.push_str(
+                            &pp_helper(&theme_path, 0).chain_err_related_path(&theme_path)?,
+                        );
+                    }
+                }
+            }
+        }
+    }
+    Ok(ret)
+}
+
+/// Expands `include` macros in configuration file and other configuration
+/// files (eg. themes) in the filesystem.
+pub fn pp(path: &Path) -> Result<String> {
+    pp_inner(path)
+        .wrap_err(|| "Could not preprocess configuration file")
+        .chain_err_related_path(path)
+        .chain_err_kind(ErrorKind::Configuration)
+}
+
+pub fn expand_config(conf_path: &Path) -> Result<String> {
+    fn inner(conf_path: &Path) -> Result<String> {
+        let _paths = get_included_configs(conf_path)?;
+        const M4_PREAMBLE: &str = r#"define(`builtin_include', defn(`include'))dnl
+define(`include', `builtin_include(substr($1,1,decr(decr(len($1)))))dnl')dnl
+"#;
+        let mut contents = String::new();
+        contents.clear();
+        let mut file = std::fs::File::open(conf_path)?;
+        file.read_to_string(&mut contents)?;
+
+        let mut handle = Command::new("m4")
+            .current_dir(conf_path.parent().unwrap_or_else(|| Path::new("/")))
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?;
+        let mut stdin = handle.stdin.take().unwrap();
+        stdin.write_all(M4_PREAMBLE.as_bytes())?;
+        stdin.write_all(contents.as_bytes())?;
+        drop(stdin);
+        let stdout = handle.wait_with_output()?.stdout;
+        Ok(String::from_utf8_lossy(&stdout).to_string())
+    }
+
+    inner(conf_path).chain_err_related_path(conf_path)
+}
+
+pub fn get_included_configs(conf_path: &Path) -> Result<Vec<PathBuf>> {
+    const M4_PREAMBLE: &str = r#"divert(-1)dnl
+define(`include', `divert(0)$1
+divert(-1)
+')dnl
+changequote(`"', `"')dnl
+"#;
+    let mut ret = vec![];
+    let prefix = conf_path.parent().unwrap().to_path_buf();
+    let mut stack = vec![(None::<PathBuf>, conf_path.to_path_buf())];
+    let mut contents = String::new();
+    while let Some((parent, p)) = stack.pop() {
+        if !p.exists() || p.is_dir() {
+            return Err(Error::new(format!(
+                "Path {}{included}{in_parent} {msg}.",
+                p.display(),
+                included = if parent.is_some() {
+                    " which is included in "
+                } else {
+                    ""
+                },
+                in_parent = if let Some(parent) = parent {
+                    std::borrow::Cow::Owned(parent.display().to_string())
+                } else {
+                    std::borrow::Cow::Borrowed("")
+                },
+                msg = if !p.exists() {
+                    "does not exist"
+                } else {
+                    "is a directory, not a text file"
+                }
+            ))
+            .set_kind(ErrorKind::ValueError));
+        }
+        contents.clear();
+        let mut file = std::fs::File::open(&p).chain_err_related_path(&p)?;
+        file.read_to_string(&mut contents)
+            .chain_err_related_path(&p)?;
+
+        let mut handle = match Command::new("m4")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+        {
+            Ok(handle) => handle,
+            Err(err) => match err.kind() {
+                io::ErrorKind::NotFound => {
+                    return Err(Error::new(
+                        "`m4` executable not found in PATH. Please provide an m4 binary.",
+                    )
+                    .set_kind(ErrorKind::Platform))
+                }
+                _ => {
+                    return Err(Error::new("Could not process configuration with `m4`")
+                        .set_source(Some(Arc::new(err)))
+                        .set_kind(ErrorKind::Platform))
+                }
+            },
+        };
+
+        let mut stdin = handle.stdin.take().unwrap();
+        stdin.write_all(M4_PREAMBLE.as_bytes())?;
+        stdin.write_all(contents.as_bytes())?;
+        drop(stdin);
+        let stdout = handle.wait_with_output()?.stdout.clone();
+        for subpath in stdout.lines() {
+            let subpath = subpath?;
+            let path = &Path::new(&subpath);
+            if path.is_absolute() {
+                stack.push((Some(p.to_path_buf()), path.to_path_buf()));
+            } else {
+                stack.push((Some(p.to_path_buf()), prefix.join(path)));
+            }
+        }
+        ret.push(p.to_path_buf());
+    }
+
+    Ok(ret)
+}

meli/src/conf/shortcuts.rs

@@ -90,7 +90,7 @@ impl DotAddressable for Shortcuts {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct CommandShortcut {
     pub shortcut: Key,
     pub command: Vec<String>,
@@ -174,10 +174,12 @@ shortcut_key_values! { "listing",
         search |> "Search within list of e-mails." |> Key::Char('/'),
         refresh |> "Manually request a mailbox refresh." |> Key::F(5),
         set_seen |> "Set thread as seen." |> Key::Char('n'),
+        send_to_trash |> "Send entry to trash folder." |> Key::Char('D'),
         union_modifier |> "Union modifier." |> Key::Ctrl('u'),
         diff_modifier |> "Difference modifier." |> Key::Ctrl('d'),
         intersection_modifier |> "Intersection modifier." |> Key::Ctrl('i'),
-        select_entry |> "Select thread entry." |> Key::Char('v'),
+        select_entry |> "Select thread entry." |> Key::Char('V'),
+        select_motion |> "Perform select motion with a movement." |> Key::Char('v'),
         increase_sidebar |> "Increase sidebar width." |> Key::Ctrl('f'),
         decrease_sidebar |> "Decrease sidebar width." |> Key::Ctrl('d'),
         next_entry |> "Focus on next entry." |> Key::Ctrl('n'),
@@ -197,6 +199,7 @@ shortcut_key_values! { "contact-list",
         scroll_down |> "Scroll down list." |> Key::Char('j'),
         create_contact |> "Create new contact." |> Key::Char('c'),
         edit_contact |> "Edit contact under cursor." |> Key::Char('e'),
+        export_contact |> "Export contact under cursor to .vcf." |> Key::Char('E'),
         delete_contact |> "Delete contact under cursor." |> Key::Char('d'),
         mail_contact |> "Mail contact under cursor." |> Key::Char('m'),
         next_account |> "Go to next account." |> Key::Char('H'),

meli/src/conf/tags.rs

@@ -21,24 +21,22 @@
 
 //! E-mail tag configuration and {de,}serializing.
 
-use std::collections::{HashMap, HashSet};
-
+use indexmap::{IndexMap, IndexSet};
 use melib::{Error, Result, TagHash};
 use serde::{Deserialize, Deserializer};
 
-use super::DotAddressable;
-use crate::terminal::Color;
+use crate::{conf::DotAddressable, terminal::Color};
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct TagsSettings {
     #[serde(default, deserialize_with = "tag_color_de")]
-    pub colors: HashMap<TagHash, Color>,
+    pub colors: IndexMap<TagHash, Color>,
     #[serde(default, deserialize_with = "tag_set_de", alias = "ignore-tags")]
-    pub ignore_tags: HashSet<TagHash>,
+    pub ignore_tags: IndexSet<TagHash>,
 }
 
-pub fn tag_set_de<'de, D, T: std::convert::From<HashSet<TagHash>>>(
+pub fn tag_set_de<'de, D, T: std::convert::From<IndexSet<TagHash>>>(
     deserializer: D,
 ) -> std::result::Result<T, D::Error>
 where
@@ -47,11 +45,11 @@ where
     Ok(<Vec<String>>::deserialize(deserializer)?
         .into_iter()
         .map(|tag| TagHash::from_bytes(tag.as_bytes()))
-        .collect::<HashSet<TagHash>>()
+        .collect::<IndexSet<TagHash>>()
         .into())
 }
 
-pub fn tag_color_de<'de, D, T: std::convert::From<HashMap<TagHash, Color>>>(
+pub fn tag_color_de<'de, D, T: std::convert::From<IndexMap<TagHash, Color>>>(
     deserializer: D,
 ) -> std::result::Result<T, D::Error>
 where
@@ -64,7 +62,7 @@ where
         C(Color),
     }
 
-    Ok(<HashMap<String, _Color>>::deserialize(deserializer)?
+    Ok(<IndexMap<String, _Color>>::deserialize(deserializer)?
         .into_iter()
         .map(|(tag, color)| {
             (
@@ -75,7 +73,7 @@ where
                 },
             )
         })
-        .collect::<HashMap<TagHash, Color>>()
+        .collect::<IndexMap<TagHash, Color>>()
         .into())
 }
 

meli/src/conf/terminal.rs

@@ -79,7 +79,7 @@ impl TerminalSettings {
         // Don't use color if
         // - Either NO_COLOR is set and user hasn't explicitly set use_colors or
         // - User has explicitly set use_colors to false
-        !((std::env::var("NO_COLOR").is_ok()
+        !((std::env::var_os("NO_COLOR").is_some()
             && (self.use_color.is_false() || self.use_color.is_internal()))
             || (self.use_color.is_false() && !self.use_color.is_internal()))
     }
@@ -120,19 +120,96 @@ impl DotAddressable for TerminalSettings {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(untagged)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ProgressSpinnerSequence {
     Integer(usize),
     Custom {
         frames: Vec<String>,
-        #[serde(default = "interval_ms_val")]
         interval_ms: u64,
     },
 }
 
+impl ProgressSpinnerSequence {
+    pub const fn interval_ms(&self) -> u64 {
+        match self {
+            Self::Integer(_) => interval_ms_val(),
+            Self::Custom {
+                frames: _,
+                interval_ms,
+            } => *interval_ms,
+        }
+    }
+}
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
 const fn interval_ms_val() -> u64 {
     crate::utilities::ProgressSpinner::INTERVAL_MS
 }
 
 impl DotAddressable for ProgressSpinnerSequence {}
+
+impl<'de> Deserialize<'de> for ProgressSpinnerSequence {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Clone, Debug, Deserialize, Serialize)]
+        #[serde(untagged)]
+        enum Inner {
+            Integer(usize),
+            Frames(Vec<String>),
+            Custom {
+                frames: Vec<String>,
+                #[serde(default = "interval_ms_val")]
+                interval_ms: u64,
+            },
+        }
+        let s = <Inner>::deserialize(deserializer)?;
+        match s {
+            Inner::Integer(i) => Ok(Self::Integer(i)),
+            Inner::Frames(frames) => Ok(Self::Custom {
+                frames,
+                interval_ms: interval_ms_val(),
+            }),
+            Inner::Custom {
+                frames,
+                interval_ms,
+            } => Ok(Self::Custom {
+                frames,
+                interval_ms,
+            }),
+        }
+    }
+}
+
+impl Serialize for ProgressSpinnerSequence {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::Integer(i) => serializer.serialize_i64(*i as i64),
+            Self::Custom {
+                frames,
+                interval_ms,
+            } => {
+                if *interval_ms == interval_ms_val() {
+                    use serde::ser::SerializeSeq;
+                    let mut seq = serializer.serialize_seq(Some(frames.len()))?;
+                    for element in frames {
+                        seq.serialize_element(element)?;
+                    }
+                    seq.end()
+                } else {
+                    use serde::ser::SerializeMap;
+
+                    let mut map = serializer.serialize_map(Some(2))?;
+                    map.serialize_entry("frames", frames)?;
+                    map.serialize_entry("interval_ms", interval_ms)?;
+                    map.end()
+                }
+            }
+        }
+    }
+}

meli/src/conf/tests.rs

@@ -0,0 +1,384 @@
+//
+// meli
+//
+// Copyright 2024 Emmanouil Pitsidianakis <manos@pitsidianak.is>
+//
+// This file is part of meli.
+//
+// meli is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// meli is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with meli. If not, see <http://www.gnu.org/licenses/>.
+//
+// SPDX-License-Identifier: EUPL-1.2 OR GPL-3.0-or-later
+
+use std::{
+    borrow::Cow,
+    fmt::Write as FmtWrite,
+    fs::{self, OpenOptions},
+    io::Write,
+    path::PathBuf,
+};
+
+use crate::{
+    conf::{themes::*, FileSettings},
+    terminal::Color,
+};
+
+pub struct ConfigFile {
+    pub path: PathBuf,
+    pub file: fs::File,
+}
+
+impl ConfigFile {
+    pub fn new(
+        content: &str,
+        dir: &tempfile::TempDir,
+    ) -> std::result::Result<Self, std::io::Error> {
+        let mut filename = String::with_capacity(2 * 16);
+        for byte in melib::utils::random::random_u64().to_be_bytes() {
+            write!(&mut filename, "{:02X}", byte).unwrap();
+        }
+        let mut path = dir.path().to_path_buf();
+        path.push(&*filename);
+        let mut file = OpenOptions::new()
+            .create_new(true)
+            .append(true)
+            .open(&path)?;
+        file.write_all(content.as_bytes())?;
+        Ok(Self { path, file })
+    }
+}
+
+impl Drop for ConfigFile {
+    fn drop(&mut self) {
+        let _ = fs::remove_file(&self.path);
+    }
+}
+
+pub const TEST_CONFIG: &str = r#"
+[accounts.account-name]
+root_mailbox = "/path/to/root/mailbox"
+format = "Maildir"
+send_mail = 'false'
+listing.index_style = "Conversations" # or [plain, threaded, compact]
+identity="email@example.com"
+display_name = "Name"
+subscribed_mailboxes = ["INBOX", "INBOX/Sent", "INBOX/Drafts", "INBOX/Junk"]
+
+# Set mailbox-specific settings
+  [accounts.account-name.mailboxes]
+  "INBOX" = { rename="Inbox" }
+  "drafts" = { rename="Drafts" }
+  "foobar-devel" = { ignore = true } # don't show notifications for this mailbox
+
+# Setting up an mbox account
+[accounts.mbox]
+root_mailbox = "/var/mail/username"
+format = "mbox"
+send_mail = 'false'
+listing.index_style = "Compact"
+identity="username@hostname.local"
+"#;
+
+pub const EXTRA_CONFIG: &str = r#"
+[accounts.mbox]
+root_mailbox = "/"
+format = "mbox"
+send_mail = 'false'
+index_style = "Compact"
+identity="username@hostname.local"
+    "#;
+pub const IMAP_CONFIG: &str = r#"
+[accounts.imap]
+root_mailbox = "INBOX"
+format = "imap"
+send_mail = 'false'
+identity="username@example.com"
+server_username = "null"
+server_hostname = "example.com"
+server_password_command = "false"
+    "#;
+
+#[test]
+fn test_conf_config_parse() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let new_file = ConfigFile::new(TEST_CONFIG, &tempdir).unwrap();
+    let err = FileSettings::validate(new_file.path.clone(), true).unwrap_err();
+    assert_eq!(
+        err.summary.as_ref(),
+        "Configuration error (account-name): root_mailbox `/path/to/root/mailbox` is not a valid \
+         directory."
+    );
+
+    /* Test unrecognised configuration entries error */
+
+    let new_file = ConfigFile::new(EXTRA_CONFIG, &tempdir).unwrap();
+    let err = FileSettings::validate(new_file.path.clone(), true).unwrap_err();
+    assert_eq!(
+        err.summary.as_ref(),
+        "Unrecognised configuration values: {\"index_style\": \"Compact\"}"
+    );
+
+    /* Test IMAP config */
+
+    let new_file = ConfigFile::new(IMAP_CONFIG, &tempdir).unwrap();
+    FileSettings::validate(new_file.path.clone(), true).expect("could not parse IMAP config");
+
+    /* Test sample config */
+
+    // Sample config contains `crate::conf::composing::SendMail::Smtp` variant which
+    // only exists if meli is build with `smtp` feature.
+    if cfg!(feature = "smtp") {
+        let example_config = FileSettings::EXAMPLE_CONFIG.replace("\n#", "\n");
+        let re = regex::Regex::new(r#"root_mailbox\s*=\s*"[^"]*""#).unwrap();
+        let example_config = re.replace_all(
+            &example_config,
+            &format!(r#"root_mailbox = "{}""#, tempdir.path().to_str().unwrap()),
+        );
+
+        let new_file = ConfigFile::new(&example_config, &tempdir).unwrap();
+        let config = FileSettings::validate(new_file.path.clone(), true)
+            .expect("Could not parse example config!");
+        for (accname, acc) in config.accounts.iter() {
+            if !acc.extra.is_empty() {
+                panic!(
+                    "In example config, account `{}` has unrecognised configuration entries: {:?}",
+                    accname, acc.extra
+                );
+            }
+        }
+    }
+
+    if let Err(err) = tempdir.close() {
+        eprintln!("Could not cleanup tempdir: {}", err);
+    }
+}
+
+#[test]
+fn test_conf_theme_parsing() {
+    /* MUST SUCCEED: default themes should be valid */
+    let def = Themes::default();
+    def.validate().unwrap();
+    /* MUST SUCCEED: new user theme `hunter2`, theme `dark` has user
+     * redefinitions */
+    const TEST_STR: &str = r#"[dark]
+"mail.listing.tag_default" = { fg = "White", bg = "HotPink3" }
+"mail.listing.attachment_flag" = { fg = "mail.listing.tag_default.bg" }
+"mail.view.headers" = { bg = "mail.listing.tag_default.fg" }
+
+["hunter2"]
+"mail.view.body" = { fg = "Black", bg = "White"}"#;
+    let parsed: Themes = toml::from_str(TEST_STR).unwrap();
+    assert!(parsed.other_themes.contains_key("hunter2"));
+    assert_eq!(
+        unlink_bg(
+            &parsed.dark,
+            &ColorField::Bg,
+            &Cow::from("mail.listing.tag_default")
+        ),
+        Color::Byte(132)
+    );
+    assert_eq!(
+        unlink_fg(
+            &parsed.dark,
+            &ColorField::Fg,
+            &Cow::from("mail.listing.attachment_flag")
+        ),
+        Color::Byte(132)
+    );
+    assert_eq!(
+        unlink_bg(
+            &parsed.dark,
+            &ColorField::Bg,
+            &Cow::from("mail.view.headers")
+        ),
+        Color::Byte(15), // White
+    );
+    parsed.validate().unwrap();
+    /* MUST FAIL: theme `dark` contains a cycle */
+    const HAS_CYCLE: &str = r#"[dark]
+"mail.listing.compact.even" = { fg = "mail.listing.compact.odd" }
+"mail.listing.compact.odd" = { fg = "mail.listing.compact.even" }
+"#;
+    let parsed: Themes = toml::from_str(HAS_CYCLE).unwrap();
+    parsed.validate().unwrap_err();
+    /* MUST FAIL: theme `dark` contains an invalid key */
+    const HAS_INVALID_KEYS: &str = r#"[dark]
+"asdfsafsa" = { fg = "Black" }
+"#;
+    let parsed: std::result::Result<Themes, _> = toml::from_str(HAS_INVALID_KEYS);
+    parsed.unwrap_err();
+    /* MUST SUCCEED: alias $Jebediah resolves to a valid color */
+    const TEST_ALIAS_STR: &str = r##"[dark]
+color_aliases= { "Jebediah" = "#b4da55" }
+"mail.listing.tag_default" = { fg = "$Jebediah" }
+"##;
+    let parsed: Themes = toml::from_str(TEST_ALIAS_STR).unwrap();
+    parsed.validate().unwrap();
+    assert_eq!(
+        unlink_fg(
+            &parsed.dark,
+            &ColorField::Fg,
+            &Cow::from("mail.listing.tag_default")
+        ),
+        Color::Rgb(180, 218, 85)
+    );
+    /* MUST FAIL: Misspell color alias $Jebediah as $Jebedia */
+    const TEST_INVALID_ALIAS_STR: &str = r##"[dark]
+color_aliases= { "Jebediah" = "#b4da55" }
+"mail.listing.tag_default" = { fg = "$Jebedia" }
+"##;
+    let parsed: Themes = toml::from_str(TEST_INVALID_ALIAS_STR).unwrap();
+    parsed.validate().unwrap_err();
+    /* MUST FAIL: Color alias $Jebediah is defined as itself */
+    const TEST_CYCLIC_ALIAS_STR: &str = r#"[dark]
+color_aliases= { "Jebediah" = "$Jebediah" }
+"mail.listing.tag_default" = { fg = "$Jebediah" }
+"#;
+    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR).unwrap();
+    parsed.validate().unwrap_err();
+    /* MUST FAIL: Attr alias $Jebediah is defined as itself */
+    const TEST_CYCLIC_ALIAS_ATTR_STR: &str = r#"[dark]
+attr_aliases= { "Jebediah" = "$Jebediah" }
+"mail.listing.tag_default" = { attrs = "$Jebediah" }
+"#;
+    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_ATTR_STR).unwrap();
+    parsed.validate().unwrap_err();
+    /* MUST FAIL: alias $Jebediah resolves to a cycle */
+    const TEST_CYCLIC_ALIAS_STR_2: &str = r#"[dark]
+color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default" }
+"mail.listing.tag_default" = { fg = "$Jebediah" }
+"#;
+    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_2).unwrap();
+    parsed.validate().unwrap_err();
+    /* MUST SUCCEED: alias $Jebediah resolves to a key's field */
+    const TEST_CYCLIC_ALIAS_STR_3: &str = r#"[dark]
+color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.bg" }
+"mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
+"#;
+    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_3).unwrap();
+    parsed.validate().unwrap();
+    /* MUST FAIL: alias $Jebediah resolves to an invalid key */
+    const TEST_INVALID_LINK_KEY_FIELD_STR: &str = r#"[dark]
+color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.attrs" }
+"mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
+"#;
+    let parsed: Themes = toml::from_str(TEST_INVALID_LINK_KEY_FIELD_STR).unwrap();
+    parsed.validate().unwrap_err();
+}
+
+#[test]
+fn test_conf_theme_key_values() {
+    use std::{collections::VecDeque, fs::File, io::Read, path::PathBuf};
+    let mut rust_files: VecDeque<PathBuf> = VecDeque::new();
+    let mut dirs_queue: VecDeque<PathBuf> = VecDeque::new();
+    dirs_queue.push_back("src/".into());
+    let re_whitespace = regex::Regex::new(r"\s*").unwrap();
+    let re_conf = regex::Regex::new(r#"value\([&]?context,"([^"]*)""#).unwrap();
+
+    while let Some(dir) = dirs_queue.pop_front() {
+        for entry in std::fs::read_dir(&dir).unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            if path.is_dir() {
+                dirs_queue.push_back(path);
+            } else if path.extension().map(|os_s| os_s == "rs").unwrap_or(false) {
+                rust_files.push_back(path);
+            }
+        }
+    }
+    for file_path in rust_files {
+        let mut file = File::open(&file_path).unwrap();
+        let mut content = String::new();
+        file.read_to_string(&mut content).unwrap();
+        let content = re_whitespace.replace_all(&content, "");
+        for mat in re_conf.captures_iter(&content) {
+            let theme_key = &mat[1];
+            if !DEFAULT_KEYS.contains(&theme_key) {
+                panic!(
+                    "Source file {} contains a hardcoded theme key str, {:?}, that is not \
+                     included in the DEFAULT_KEYS table.",
+                    file_path.display(),
+                    theme_key
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn test_conf_progress_spinner_sequence() {
+    use crate::{conf::terminal::ProgressSpinnerSequence, utilities::ProgressSpinner};
+
+    let int_0 = ProgressSpinnerSequence::Integer(5);
+    assert_eq!(
+        toml::Value::try_from(&int_0).unwrap(),
+        toml::Value::try_from(5).unwrap()
+    );
+
+    let frames = ProgressSpinnerSequence::Custom {
+        frames: vec![
+            "⠁".to_string(),
+            "⠂".to_string(),
+            "⠄".to_string(),
+            "⡀".to_string(),
+            "⢀".to_string(),
+            "⠠".to_string(),
+            "⠐".to_string(),
+            "⠈".to_string(),
+        ],
+        interval_ms: ProgressSpinner::INTERVAL_MS,
+    };
+    assert_eq!(frames.interval_ms(), ProgressSpinner::INTERVAL_MS);
+    assert_eq!(
+        toml::Value::try_from(&frames).unwrap(),
+        toml::Value::try_from(["⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"]).unwrap()
+    );
+    let frames = ProgressSpinnerSequence::Custom {
+        frames: vec![
+            "⠁".to_string(),
+            "⠂".to_string(),
+            "⠄".to_string(),
+            "⡀".to_string(),
+            "⢀".to_string(),
+            "⠠".to_string(),
+            "⠐".to_string(),
+            "⠈".to_string(),
+        ],
+        interval_ms: ProgressSpinner::INTERVAL_MS + 1,
+    };
+    assert_eq!(
+        toml::Value::try_from(&frames).unwrap(),
+        toml::Value::try_from(indexmap::indexmap! {
+            "frames" => toml::Value::try_from(["⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"]).unwrap(),
+            "interval_ms" => toml::Value::try_from(ProgressSpinner::INTERVAL_MS + 1).unwrap()
+        })
+        .unwrap()
+    );
+    assert_eq!(
+        toml::from_str::<ProgressSpinnerSequence>(
+            r#"frames = ["⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"]
+interval_ms = 51"#
+        )
+        .unwrap(),
+        frames
+    );
+    assert_eq!(
+        toml::from_str::<indexmap::IndexMap<String, ProgressSpinnerSequence>>(
+            r#"sequence = { frames = ["⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"], interval_ms = 51 }"#
+        )
+        .unwrap(),
+        indexmap::indexmap! {
+            "sequence".to_string() => frames,
+        },
+    );
+}

meli/src/conf/themes.rs

@@ -43,6 +43,7 @@ use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 use smallvec::SmallVec;
 
 use crate::{
+    conf::data_types::regex_pattern::{RegexOptions, RegexValue},
     terminal::{Attr, Color},
     Context,
 };
@@ -115,7 +116,7 @@ pub fn attrs(context: &Context, key: &'static str) -> Attr {
 }
 
 #[inline(always)]
-fn unlink<'k, 't: 'k>(theme: &'t Theme, key: &'k str) -> ThemeAttribute {
+pub fn unlink<'k, 't: 'k>(theme: &'t Theme, key: &'k str) -> ThemeAttribute {
     ThemeAttribute {
         fg: unlink_fg(theme, &ColorField::Fg, key),
         bg: unlink_bg(theme, &ColorField::Bg, key),
@@ -124,7 +125,11 @@ fn unlink<'k, 't: 'k>(theme: &'t Theme, key: &'k str) -> ThemeAttribute {
 }
 
 #[inline(always)]
-fn unlink_fg<'k, 't: 'k>(theme: &'t Theme, mut field: &'k ColorField, mut key: &'k str) -> Color {
+pub fn unlink_fg<'k, 't: 'k>(
+    theme: &'t Theme,
+    mut field: &'k ColorField,
+    mut key: &'k str,
+) -> Color {
     loop {
         match field {
             ColorField::LikeSelf | ColorField::Fg => match &theme[key].fg {
@@ -175,7 +180,11 @@ fn unlink_fg<'k, 't: 'k>(theme: &'t Theme, mut field: &'k ColorField, mut key: &
 }
 
 #[inline(always)]
-fn unlink_bg<'k, 't: 'k>(theme: &'t Theme, mut field: &'k ColorField, mut key: &'k str) -> Color {
+pub fn unlink_bg<'k, 't: 'k>(
+    theme: &'t Theme,
+    mut field: &'k ColorField,
+    mut key: &'k str,
+) -> Color {
     loop {
         match field {
             ColorField::LikeSelf | ColorField::Bg => match &theme[key].bg {
@@ -225,7 +234,7 @@ fn unlink_bg<'k, 't: 'k>(theme: &'t Theme, mut field: &'k ColorField, mut key: &
 }
 
 #[inline(always)]
-fn unlink_attrs<'k, 't: 'k>(theme: &'t Theme, mut key: &'k str) -> Attr {
+pub fn unlink_attrs<'k, 't: 'k>(theme: &'t Theme, mut key: &'k str) -> Attr {
     loop {
         match &theme[key].attrs {
             ThemeValue::Link(ref new_key, ()) => key = new_key,
@@ -247,7 +256,7 @@ fn unlink_attrs<'k, 't: 'k>(theme: &'t Theme, mut key: &'k str) -> Attr {
     }
 }
 
-const DEFAULT_KEYS: &[&str] = &[
+pub const DEFAULT_KEYS: &[&str] = &[
     "theme_default",
     "text.normal",
     "text.unfocused",
@@ -308,6 +317,7 @@ const DEFAULT_KEYS: &[&str] = &[
     "mail.listing.conversations.highlighted",
     "mail.listing.conversations.selected",
     "mail.listing.conversations.highlighted_selected",
+    "mail.view.divider",
     "mail.view.headers",
     "mail.view.headers_names",
     "mail.view.headers_area",
@@ -349,10 +359,16 @@ pub struct ThemeAttributeInner {
 
 impl Default for ThemeAttributeInner {
     fn default() -> Self {
+        Self::inherited("theme_default")
+    }
+}
+
+impl ThemeAttributeInner {
+    pub fn inherited(key: &'static str) -> Self {
         Self {
-            fg: "theme_default".into(),
-            bg: "theme_default".into(),
-            attrs: "theme_default".into(),
+            fg: key.into(),
+            bg: key.into(),
+            attrs: key.into(),
         }
     }
 }
@@ -390,8 +406,14 @@ enum ThemeValue<T: ThemeLink> {
 }
 
 impl From<&'static str> for ThemeValue<Color> {
-    fn from(from: &'static str) -> Self {
-        Self::Link(from.into(), ColorField::LikeSelf)
+    fn from(s: &'static str) -> Self {
+        if let Some(stripped) = s.strip_suffix(".fg") {
+            Self::Link(Cow::Borrowed(stripped), ColorField::Fg)
+        } else if let Some(stripped) = s.strip_suffix(".bg") {
+            Self::Link(Cow::Borrowed(stripped), ColorField::Bg)
+        } else {
+            Self::Link(s.into(), ColorField::LikeSelf)
+        }
     }
 }
 
@@ -512,30 +534,23 @@ pub struct Themes {
 pub struct Theme {
     color_aliases: IndexMap<Cow<'static, str>, ThemeValue<Color>>,
     attr_aliases: IndexMap<Cow<'static, str>, ThemeValue<Attr>>,
-    #[cfg(feature = "regexp")]
     text_format_regexps: IndexMap<Cow<'static, str>, SmallVec<[TextFormatterSetting; 32]>>,
     pub keys: IndexMap<Cow<'static, str>, ThemeAttributeInner>,
 }
 
-#[cfg(feature = "regexp")]
 pub use regexp::text_format_regexps;
-#[cfg(feature = "regexp")]
 use regexp::*;
 
-#[cfg(feature = "regexp")]
 mod regexp {
     use super::*;
-    use crate::terminal::FormatTag;
+    use crate::{conf::data_types::regex_pattern::RegexValue, terminal::FormatTag};
 
     pub(super) const DEFAULT_TEXT_FORMATTER_KEYS: &[&str] =
         &["pager.envelope.body", "listing.from", "listing.subject"];
 
-    #[derive(Clone)]
-    pub struct RegexpWrapper(pub pcre2::bytes::Regex);
-
     #[derive(Clone, Debug)]
     pub(super) struct TextFormatterSetting {
-        pub(super) regexp: RegexpWrapper,
+        pub(super) regexp: RegexValue,
         pub(super) fg: Option<ThemeValue<Color>>,
         pub(super) bg: Option<ThemeValue<Color>>,
         pub(super) attrs: Option<ThemeValue<Attr>>,
@@ -544,108 +559,10 @@ mod regexp {
 
     #[derive(Clone, Debug)]
     pub struct TextFormatter<'r> {
-        pub regexp: &'r RegexpWrapper,
+        pub regexp: &'r RegexValue,
         pub tag: FormatTag,
     }
 
-    impl Default for RegexpWrapper {
-        fn default() -> Self {
-            Self(pcre2::bytes::Regex::new("").unwrap())
-        }
-    }
-
-    impl std::fmt::Debug for RegexpWrapper {
-        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-            std::fmt::Debug::fmt(self.0.as_str(), fmt)
-        }
-    }
-
-    impl std::hash::Hash for RegexpWrapper {
-        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-            self.0.as_str().hash(state)
-        }
-    }
-
-    impl Eq for RegexpWrapper {}
-
-    impl PartialEq for RegexpWrapper {
-        fn eq(&self, other: &Self) -> bool {
-            self.0.as_str().eq(other.0.as_str())
-        }
-    }
-
-    impl RegexpWrapper {
-        pub(super) fn new(
-            pattern: &str,
-            caseless: bool,
-            dotall: bool,
-            extended: bool,
-            multi_line: bool,
-            ucp: bool,
-            jit_if_available: bool,
-        ) -> std::result::Result<Self, pcre2::Error> {
-            Ok(Self(
-                pcre2::bytes::RegexBuilder::new()
-                    .caseless(caseless)
-                    .dotall(dotall)
-                    .extended(extended)
-                    .multi_line(multi_line)
-                    .ucp(ucp)
-                    .jit_if_available(jit_if_available)
-                    .build(pattern)?,
-            ))
-        }
-
-        pub fn find_iter<'w, 's>(&'w self, s: &'s str) -> FindIter<'w, 's> {
-            FindIter {
-                pcre_iter: self.0.find_iter(s.as_bytes()),
-                char_indices: s.char_indices(),
-                char_offset: 0,
-            }
-        }
-    }
-
-    pub struct FindIter<'r, 's> {
-        pcre_iter: pcre2::bytes::Matches<'r, 's>,
-        char_indices: std::str::CharIndices<'s>,
-        char_offset: usize,
-    }
-
-    impl<'r, 's> Iterator for FindIter<'r, 's> {
-        type Item = (usize, usize);
-
-        fn next(&mut self) -> Option<Self::Item> {
-            loop {
-                let next_byte_offset = self.pcre_iter.next()?;
-                if next_byte_offset.is_err() {
-                    continue;
-                }
-                let next_byte_offset = next_byte_offset.unwrap();
-
-                let mut next_char_index = self.char_indices.next()?;
-
-                while next_byte_offset.start() < next_char_index.0 {
-                    self.char_offset += 1;
-                    next_char_index = self.char_indices.next()?;
-                }
-                let start = self.char_offset;
-
-                while next_byte_offset.end()
-                    > self
-                        .char_indices
-                        .next()
-                        .map(|(v, _)| v)
-                        .unwrap_or_else(|| next_byte_offset.end())
-                {
-                    self.char_offset += 1;
-                }
-                let end = self.char_offset + 1;
-
-                return Some((start, end));
-            }
-        }
-    }
-
     #[inline(always)]
     pub fn text_format_regexps<'ctx>(
         context: &'ctx Context,
@@ -767,14 +684,6 @@ impl<'de> Deserialize<'de> for Themes {
     where
         D: Deserializer<'de>,
     {
-        #[cfg(feature = "regexp")]
-        const fn false_val() -> bool {
-            false
-        }
-        #[cfg(feature = "regexp")]
-        const fn true_val() -> bool {
-            true
-        }
         #[derive(Deserialize)]
         struct ThemesOptions {
             #[serde(default)]
@@ -790,27 +699,15 @@ impl<'de> Deserialize<'de> for Themes {
             color_aliases: IndexMap<Cow<'static, str>, ThemeValue<Color>>,
             #[serde(default)]
             attr_aliases: IndexMap<Cow<'static, str>, ThemeValue<Attr>>,
-            #[cfg(feature = "regexp")]
             #[serde(default)]
             text_format_regexps: IndexMap<Cow<'static, str>, IndexMap<String, RegexpOptions>>,
             #[serde(flatten, default)]
             keys: IndexMap<Cow<'static, str>, ThemeAttributeInnerOptions>,
         }
-        #[cfg(feature = "regexp")]
         #[derive(Default, Deserialize)]
         struct RegexpOptions {
-            #[serde(default = "false_val")]
-            caseless: bool,
-            #[serde(default = "false_val")]
-            dotall: bool,
-            #[serde(default = "false_val")]
-            extended: bool,
-            #[serde(default = "false_val")]
-            multi_line: bool,
-            #[serde(default = "true_val")]
-            ucp: bool,
-            #[serde(default = "false_val")]
-            jit_if_available: bool,
+            #[serde(flatten)]
+            o: RegexOptions,
             #[serde(default)]
             priority: u8,
             #[serde(flatten)]
@@ -819,6 +716,8 @@ impl<'de> Deserialize<'de> for Themes {
         #[derive(Default, Deserialize)]
         #[serde(deny_unknown_fields)]
         struct ThemeAttributeInnerOptions {
+            #[serde(default)]
+            from: Option<Cow<'static, str>>,
             #[serde(default)]
             fg: Option<ThemeValue<Color>>,
             #[serde(default)]
@@ -828,163 +727,62 @@ impl<'de> Deserialize<'de> for Themes {
         }
 
         let mut ret = Self::default();
-        let mut s = <ThemesOptions>::deserialize(deserializer)?;
-        for tk in s.other_themes.keys() {
-            ret.other_themes.insert(tk.clone(), ret.dark.clone());
-        }
+        let ThemesOptions {
+            light,
+            dark,
+            other_themes,
+        } = <ThemesOptions>::deserialize(deserializer)?;
 
-        for (k, v) in ret.light.iter_mut() {
-            if let Some(mut att) = s.light.keys.remove(k) {
-                if let Some(att) = att.fg.take() {
-                    v.fg = att;
-                }
-                if let Some(att) = att.bg.take() {
-                    v.bg = att;
-                }
-                if let Some(att) = att.attrs.take() {
-                    v.attrs = att;
-                }
-            }
-        }
-        if !s.light.keys.is_empty() {
-            return Err(de::Error::custom(format!(
-                "light theme contains unrecognized theme keywords: {}",
-                s.light
-                    .keys
-                    .keys()
-                    .map(|k| k.as_ref())
-                    .collect::<SmallVec<[_; 128]>>()
-                    .join(", ")
-            )));
-        }
-        ret.light.color_aliases = s.light.color_aliases;
-        ret.light.attr_aliases = s.light.attr_aliases;
-        #[cfg(feature = "regexp")]
-        for (k, v) in s.light.text_format_regexps {
-            let mut acc = SmallVec::new();
-            for (rs, v) in v {
-                match RegexpWrapper::new(
-                    &rs,
-                    v.caseless,
-                    v.dotall,
-                    v.extended,
-                    v.multi_line,
-                    v.ucp,
-                    v.jit_if_available,
-                ) {
-                    Ok(regexp) => {
-                        acc.push(TextFormatterSetting {
-                            regexp,
-                            fg: v.rest.fg,
-                            bg: v.rest.bg,
-                            attrs: v.rest.attrs,
-                            priority: v.priority,
-                        });
-                    }
-                    Err(err) => {
-                        return Err(de::Error::custom(err.to_string()));
-                    }
-                }
-            }
-            ret.light.text_format_regexps.insert(k, acc);
-        }
-        for (k, v) in ret.dark.iter_mut() {
-            if let Some(mut att) = s.dark.keys.remove(k) {
-                if let Some(att) = att.fg.take() {
-                    v.fg = att;
-                }
-                if let Some(att) = att.bg.take() {
-                    v.bg = att;
-                }
-                if let Some(att) = att.attrs.take() {
-                    v.attrs = att;
-                }
-            }
-        }
-        if !s.dark.keys.is_empty() {
-            return Err(de::Error::custom(format!(
-                "dark theme contains unrecognized theme keywords: {}",
-                s.dark
-                    .keys
-                    .keys()
-                    .map(|k| k.as_ref())
-                    .collect::<SmallVec<[_; 128]>>()
-                    .join(", ")
-            )));
-        }
-        ret.dark.color_aliases = s.dark.color_aliases;
-        ret.dark.attr_aliases = s.dark.attr_aliases;
-        #[cfg(feature = "regexp")]
-        for (k, v) in s.dark.text_format_regexps {
-            let mut acc = SmallVec::new();
-            for (rs, v) in v {
-                match RegexpWrapper::new(
-                    &rs,
-                    v.caseless,
-                    v.dotall,
-                    v.extended,
-                    v.multi_line,
-                    v.ucp,
-                    v.jit_if_available,
-                ) {
-                    Ok(regexp) => {
-                        acc.push(TextFormatterSetting {
-                            regexp,
-                            fg: v.rest.fg,
-                            bg: v.rest.bg,
-                            attrs: v.rest.attrs,
-                            priority: v.priority,
-                        });
-                    }
-                    Err(err) => {
-                        return Err(de::Error::custom(err.to_string()));
-                    }
-                }
-            }
-            ret.dark.text_format_regexps.insert(k, acc);
-        }
-        for (tk, t) in ret.other_themes.iter_mut() {
-            let mut theme = s.other_themes.remove(tk).unwrap();
-            for (k, v) in t.iter_mut() {
-                if let Some(mut att) = theme.keys.remove(k) {
-                    if let Some(att) = att.fg.take() {
+        fn construct_theme<'de, D>(
+            name: Cow<'_, str>,
+            theme: &mut Theme,
+            mut s: ThemeOptions,
+        ) -> std::result::Result<(), D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            for (k, v) in theme.iter_mut() {
+                if let Some(ThemeAttributeInnerOptions {
+                    from,
+                    fg,
+                    bg,
+                    attrs,
+                }) = s.keys.shift_remove(k)
+                {
+                    if let Some(att) = fg {
                         v.fg = att;
+                    } else if let Some(ref parent) = from {
+                        v.fg = ThemeValue::Link(parent.clone(), ColorField::LikeSelf);
                     }
-                    if let Some(att) = att.bg.take() {
+                    if let Some(att) = bg {
                         v.bg = att;
+                    } else if let Some(ref parent) = from {
+                        v.bg = ThemeValue::Link(parent.clone(), ColorField::LikeSelf);
                     }
-                    if let Some(att) = att.attrs.take() {
+                    if let Some(att) = attrs {
                         v.attrs = att;
+                    } else if let Some(parent) = from {
+                        v.attrs = ThemeValue::Link(parent, ());
                     }
                 }
             }
-            if !theme.keys.is_empty() {
+            if !s.keys.is_empty() {
                 return Err(de::Error::custom(format!(
                     "{} theme contains unrecognized theme keywords: {}",
-                    tk,
-                    theme
-                        .keys
+                    name,
+                    s.keys
                         .keys()
                         .map(|k| k.as_ref())
                         .collect::<SmallVec<[_; 128]>>()
                         .join(", ")
                 )));
             }
-            t.color_aliases = theme.color_aliases;
-            t.attr_aliases = theme.attr_aliases;
-            #[cfg(feature = "regexp")]
-            for (k, v) in theme.text_format_regexps {
+            theme.color_aliases = s.color_aliases;
+            theme.attr_aliases = s.attr_aliases;
+            for (k, v) in s.text_format_regexps {
                 let mut acc = SmallVec::new();
                 for (rs, v) in v {
-                    match RegexpWrapper::new(
-                        &rs,
-                        v.caseless,
-                        v.dotall,
-                        v.extended,
-                        v.multi_line,
-                        v.ucp,
-                        v.jit_if_available,
-                    ) {
+                    match RegexValue::new_with_options(&rs, v.o) {
                         Ok(regexp) => {
                             acc.push(TextFormatterSetting {
                                 regexp,
@@ -999,8 +797,17 @@ impl<'de> Deserialize<'de> for Themes {
                         }
                     }
                 }
-                t.text_format_regexps.insert(k, acc);
+                theme.text_format_regexps.insert(k, acc);
             }
+            Ok(())
+        }
+
+        construct_theme::<D>(Cow::Borrowed(self::DARK), &mut ret.dark, dark)?;
+        construct_theme::<D>(Cow::Borrowed(self::LIGHT), &mut ret.light, light)?;
+        for (name, theme_opts) in other_themes {
+            let mut theme = ret.dark.clone();
+            construct_theme::<D>(Cow::Borrowed(&name), &mut theme, theme_opts)?;
+            ret.other_themes.insert(name, theme);
         }
         Ok(ret)
     }
@@ -1118,7 +925,6 @@ impl Themes {
                 }
             }))
             .collect::<SmallVec<[(Option<_>, &'_ str, &'_ str, &'_ str); 128]>>();
-        #[cfg(feature = "regexp")]
         {
             for (key, v) in &theme.text_format_regexps {
                 if !regexp::DEFAULT_TEXT_FORMATTER_KEYS.contains(&key.as_ref()) {
@@ -1297,6 +1103,12 @@ impl Default for Themes {
         let other_themes = IndexMap::default();
 
         macro_rules! add {
+            ($key:literal from $parent_key:literal, $($theme:ident={ $($name:ident : $val:expr),*$(,)? }),*$(,)?) => {
+                add!($key);
+                $($theme.insert($key.into(), ThemeAttributeInner {
+                    $($name: $val.into()),*
+                        ,..ThemeAttributeInner::inherited($parent_key) }));*
+            };
             ($key:literal, $($theme:ident={ $($name:ident : $val:expr),*$(,)? }),*$(,)?) => {
                 add!($key);
                 $($theme.insert($key.into(), ThemeAttributeInner {
@@ -1323,7 +1135,7 @@ impl Default for Themes {
         add!("text.highlight", dark = { fg: Color::Blue, bg: "theme_default", attrs: Attr::REVERSE }, light = { fg: Color::Blue, bg: "theme_default", attrs: Attr::REVERSE });
 
         /* rest */
-        add!("highlight", dark = { fg: Color::Byte(240), bg: Color::Byte(237), attrs: Attr::BOLD }, light = { fg: Color::Byte(240), bg: Color::Byte(237), attrs: Attr::BOLD });
+        add!("highlight", dark = { fg: "theme_default.bg", bg: "theme_default.fg", attrs: Attr::BOLD }, light = { fg: Color::Byte(240), bg: Color::Byte(237), attrs: Attr::BOLD });
 
         add!("status.bar", dark = { fg: Color::Byte(123), bg: Color::Byte(26) }, light = { fg: Color::Byte(123), bg: Color::Byte(26) });
         add!("status.command_bar", dark = { fg: Color::Byte(219), bg: Color::Byte(88) }, light = { fg: Color::Byte(219), bg: Color::Byte(88) });
@@ -1365,11 +1177,11 @@ impl Default for Themes {
                 attrs: Attr::BOLD,
             }
         );
-        add!("mail.sidebar_unread_count", dark = { fg: Color::Byte(243) });
-        add!("mail.sidebar_index", dark = { fg: Color::Byte(243) });
-        add!("mail.sidebar_highlighted", dark = { fg: Color::Byte(233), bg: Color::Byte(15) });
+        add!("mail.sidebar_unread_count" from "mail.sidebar", dark = { fg: Color::Byte(243) });
+        add!("mail.sidebar_index" from "mail.sidebar", dark = { fg: Color::Byte(243) });
+        add!("mail.sidebar_highlighted" from "mail.sidebar", dark = { fg: Color::Byte(233), bg: Color::Byte(15) });
         add!(
-            "mail.sidebar_highlighted_unread_count",
+            "mail.sidebar_highlighted_unread_count" from "mail.sidebar_highlighted",
             light = {
                 fg: "mail.sidebar_highlighted",
                 bg: "mail.sidebar_highlighted"
@@ -1380,7 +1192,7 @@ impl Default for Themes {
             }
         );
         add!(
-            "mail.sidebar_highlighted_index",
+            "mail.sidebar_highlighted_index" from "mail.sidebar_highlighted",
             light = {
                 fg: "mail.sidebar_index",
                 bg: "mail.sidebar_highlighted",
@@ -1391,14 +1203,14 @@ impl Default for Themes {
             },
         );
         add!(
-            "mail.sidebar_highlighted_account",
+            "mail.sidebar_highlighted_account" from "mail.sidebar_highlighted",
             dark = {
                 fg: Color::Byte(15),
                 bg: Color::Byte(233),
             }
         );
         add!(
-            "mail.sidebar_highlighted_account_name",
+            "mail.sidebar_highlighted_account_name" from "mail.sidebar_highlighted",
             dark = {
                 fg: "mail.sidebar_highlighted_account",
                 bg: "mail.sidebar_highlighted_account",
@@ -1411,7 +1223,7 @@ impl Default for Themes {
             }
         );
         add!(
-            "mail.sidebar_highlighted_account_unread_count",
+            "mail.sidebar_highlighted_account_unread_count" from "mail.sidebar_highlighted",
             light = {
                 fg: "mail.sidebar_unread_count",
                 bg: "mail.sidebar_highlighted_account",
@@ -1422,7 +1234,7 @@ impl Default for Themes {
             }
         );
         add!(
-            "mail.sidebar_highlighted_account_index",
+            "mail.sidebar_highlighted_account_index" from "mail.sidebar_highlighted",
             light = {
                 fg: "mail.sidebar_index",
                 bg: "mail.sidebar_highlighted_account"
@@ -1432,6 +1244,7 @@ impl Default for Themes {
                 bg: "mail.sidebar_highlighted_account"
             }
         );
+        add!("mail.view.divider");
 
         /* CompactListing */
         add!("mail.listing.compact.even",
@@ -1751,7 +1564,6 @@ impl Default for Themes {
                 keys: light,
                 attr_aliases: Default::default(),
                 color_aliases: Default::default(),
-                #[cfg(feature = "regexp")]
                 text_format_regexps: DEFAULT_TEXT_FORMATTER_KEYS
                     .iter()
                     .map(|&k| (k.into(), SmallVec::new()))
@@ -1761,7 +1573,6 @@ impl Default for Themes {
                 keys: dark,
                 attr_aliases: Default::default(),
                 color_aliases: Default::default(),
-                #[cfg(feature = "regexp")]
                 text_format_regexps: DEFAULT_TEXT_FORMATTER_KEYS
                     .iter()
                     .map(|&k| (k.into(), SmallVec::new()))
@@ -1826,7 +1637,7 @@ impl Serialize for Themes {
 }
 
 /* Check Theme linked values for cycles */
-fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
+pub fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
     #[derive(Clone, Copy, Eq, Hash, PartialEq)]
     enum Course {
         Fg,
@@ -2092,155 +1903,3 @@ fn is_cyclic(theme: &Theme) -> std::result::Result<(), String> {
 
     Ok(())
 }
-
-#[test]
-fn test_theme_parsing() {
-    /* MUST SUCCEED: default themes should be valid */
-    let def = Themes::default();
-    def.validate().unwrap();
-    /* MUST SUCCEED: new user theme `hunter2`, theme `dark` has user
-     * redefinitions */
-    const TEST_STR: &str = r#"[dark]
-"mail.listing.tag_default" = { fg = "White", bg = "HotPink3" }
-"mail.listing.attachment_flag" = { fg = "mail.listing.tag_default.bg" }
-"mail.view.headers" = { bg = "mail.listing.tag_default.fg" }
-
-["hunter2"]
-"mail.view.body" = { fg = "Black", bg = "White"}"#;
-    let parsed: Themes = toml::from_str(TEST_STR).unwrap();
-    assert!(parsed.other_themes.contains_key("hunter2"));
-    assert_eq!(
-        unlink_bg(
-            &parsed.dark,
-            &ColorField::Bg,
-            &Cow::from("mail.listing.tag_default")
-        ),
-        Color::Byte(132)
-    );
-    assert_eq!(
-        unlink_fg(
-            &parsed.dark,
-            &ColorField::Fg,
-            &Cow::from("mail.listing.attachment_flag")
-        ),
-        Color::Byte(132)
-    );
-    assert_eq!(
-        unlink_bg(
-            &parsed.dark,
-            &ColorField::Bg,
-            &Cow::from("mail.view.headers")
-        ),
-        Color::Byte(15), // White
-    );
-    parsed.validate().unwrap();
-    /* MUST FAIL: theme `dark` contains a cycle */
-    const HAS_CYCLE: &str = r#"[dark]
-"mail.listing.compact.even" = { fg = "mail.listing.compact.odd" }
-"mail.listing.compact.odd" = { fg = "mail.listing.compact.even" }
-"#;
-    let parsed: Themes = toml::from_str(HAS_CYCLE).unwrap();
-    parsed.validate().unwrap_err();
-    /* MUST FAIL: theme `dark` contains an invalid key */
-    const HAS_INVALID_KEYS: &str = r#"[dark]
-"asdfsafsa" = { fg = "Black" }
-"#;
-    let parsed: std::result::Result<Themes, _> = toml::from_str(HAS_INVALID_KEYS);
-    parsed.unwrap_err();
-    /* MUST SUCCEED: alias $Jebediah resolves to a valid color */
-    const TEST_ALIAS_STR: &str = r##"[dark]
-color_aliases= { "Jebediah" = "#b4da55" }
-"mail.listing.tag_default" = { fg = "$Jebediah" }
-"##;
-    let parsed: Themes = toml::from_str(TEST_ALIAS_STR).unwrap();
-    parsed.validate().unwrap();
-    assert_eq!(
-        unlink_fg(
-            &parsed.dark,
-            &ColorField::Fg,
-            &Cow::from("mail.listing.tag_default")
-        ),
-        Color::Rgb(180, 218, 85)
-    );
-    /* MUST FAIL: Misspell color alias $Jebediah as $Jebedia */
-    const TEST_INVALID_ALIAS_STR: &str = r##"[dark]
-color_aliases= { "Jebediah" = "#b4da55" }
-"mail.listing.tag_default" = { fg = "$Jebedia" }
-"##;
-    let parsed: Themes = toml::from_str(TEST_INVALID_ALIAS_STR).unwrap();
-    parsed.validate().unwrap_err();
-    /* MUST FAIL: Color alias $Jebediah is defined as itself */
-    const TEST_CYCLIC_ALIAS_STR: &str = r#"[dark]
-color_aliases= { "Jebediah" = "$Jebediah" }
-"mail.listing.tag_default" = { fg = "$Jebediah" }
-"#;
-    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR).unwrap();
-    parsed.validate().unwrap_err();
-    /* MUST FAIL: Attr alias $Jebediah is defined as itself */
-    const TEST_CYCLIC_ALIAS_ATTR_STR: &str = r#"[dark]
-attr_aliases= { "Jebediah" = "$Jebediah" }
-"mail.listing.tag_default" = { attrs = "$Jebediah" }
-"#;
-    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_ATTR_STR).unwrap();
-    parsed.validate().unwrap_err();
-    /* MUST FAIL: alias $Jebediah resolves to a cycle */
-    const TEST_CYCLIC_ALIAS_STR_2: &str = r#"[dark]
-color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default" }
-"mail.listing.tag_default" = { fg = "$Jebediah" }
-"#;
-    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_2).unwrap();
-    parsed.validate().unwrap_err();
-    /* MUST SUCCEED: alias $Jebediah resolves to a key's field */
-    const TEST_CYCLIC_ALIAS_STR_3: &str = r#"[dark]
-color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.bg" }
-"mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
-"#;
-    let parsed: Themes = toml::from_str(TEST_CYCLIC_ALIAS_STR_3).unwrap();
-    parsed.validate().unwrap();
-    /* MUST FAIL: alias $Jebediah resolves to an invalid key */
-    const TEST_INVALID_LINK_KEY_FIELD_STR: &str = r#"[dark]
-color_aliases= { "Jebediah" = "$JebediahJr", "JebediahJr" = "mail.listing.tag_default.attrs" }
-"mail.listing.tag_default" = { fg = "$Jebediah", bg = "Black" }
-"#;
-    let parsed: Themes = toml::from_str(TEST_INVALID_LINK_KEY_FIELD_STR).unwrap();
-    parsed.validate().unwrap_err();
-}
-
-#[test]
-fn test_theme_key_values() {
-    use std::{collections::VecDeque, fs::File, io::Read, path::PathBuf};
-    let mut rust_files: VecDeque<PathBuf> = VecDeque::new();
-    let mut dirs_queue: VecDeque<PathBuf> = VecDeque::new();
-    dirs_queue.push_back("src/".into());
-    let re_whitespace = regex::Regex::new(r"\s*").unwrap();
-    let re_conf = regex::Regex::new(r#"value\([&]?context,"([^"]*)""#).unwrap();
-
-    while let Some(dir) = dirs_queue.pop_front() {
-        for entry in std::fs::read_dir(&dir).unwrap() {
-            let entry = entry.unwrap();
-            let path = entry.path();
-            if path.is_dir() {
-                dirs_queue.push_back(path);
-            } else if path.extension().map(|os_s| os_s == "rs").unwrap_or(false) {
-                rust_files.push_back(path);
-            }
-        }
-    }
-    for file_path in rust_files {
-        let mut file = File::open(&file_path).unwrap();
-        let mut content = String::new();
-        file.read_to_string(&mut content).unwrap();
-        let content = re_whitespace.replace_all(&content, "");
-        for mat in re_conf.captures_iter(&content) {
-            let theme_key = &mat[1];
-            if !DEFAULT_KEYS.contains(&theme_key) {
-                panic!(
-                    "Source file {} contains a hardcoded theme key str, {:?}, that is not \
-                     included in the DEFAULT_KEYS table.",
-                    file_path.display(),
-                    theme_key
-                );
-            }
-        }
-    }
-}

meli/src/contacts/editor.rs

@@ -19,12 +19,16 @@
  * along with meli. If not, see <http://www.gnu.org/licenses/>.
  */
 
+use std::borrow::Cow;
+
 use indexmap::IndexMap;
 use melib::Card;
 
 use crate::{
-    terminal::*, CellBuffer, Component, ComponentId, Context, Field, FormWidget, Key, StatusEvent,
-    ThemeAttribute, UIDialog, UIEvent,
+    terminal::*,
+    utilities::{FormButtonAction, FormWidget},
+    CellBuffer, Component, ComponentId, Context, Field, Key, StatusEvent, ThemeAttribute, UIDialog,
+    UIEvent,
 };
 
 #[derive(Debug)]
@@ -40,7 +44,7 @@ pub struct ContactManager {
     parent_id: Option<ComponentId>,
     pub card: Card,
     mode: ViewMode,
-    form: FormWidget<bool>,
+    form: FormWidget<FormButtonAction>,
     pub account_pos: usize,
     content: Screen<Virtual>,
     theme_default: ThemeAttribute,
@@ -65,7 +69,7 @@ impl ContactManager {
             mode: ViewMode::Edit,
             form: FormWidget::default(),
             account_pos: 0,
-            content: Screen::<Virtual>::new(),
+            content: Screen::<Virtual>::new(theme_default),
             theme_default,
             dirty: true,
             has_changes: false,
@@ -77,28 +81,7 @@ impl ContactManager {
         if !self.content.resize_with_context(100, 1, context) {
             return;
         }
-        let mut area = self.content.area();
-
-        let (x, _) = self.content.grid_mut().write_string(
-            "Last edited: ",
-            self.theme_default.fg,
-            self.theme_default.bg,
-            self.theme_default.attrs,
-            area,
-            None,
-            None,
-        );
-        area = area.skip_cols(x);
-        let (x, y) = self.content.grid_mut().write_string(
-            &self.card.last_edited(),
-            self.theme_default.fg,
-            self.theme_default.bg,
-            self.theme_default.attrs,
-            area,
-            None,
-            None,
-        );
-        area = area.skip(x, y);
+        let area = self.content.area();
 
         if self.card.external_resource() {
             self.mode = ViewMode::ReadOnly;
@@ -111,15 +94,43 @@ impl ContactManager {
                 None,
                 None,
             );
+        } else {
+            let (x, _) = self.content.grid_mut().write_string(
+                "Last edited: ",
+                self.theme_default.fg,
+                self.theme_default.bg,
+                self.theme_default.attrs,
+                area,
+                None,
+                None,
+            );
+            self.content.grid_mut().write_string(
+                &self.card.last_edited(),
+                self.theme_default.fg,
+                self.theme_default.bg,
+                self.theme_default.attrs,
+                area.skip_cols(x),
+                None,
+                None,
+            );
         }
 
         self.form = FormWidget::new(
-            ("Save".into(), true),
+            if self.card.external_resource() {
+                ("Cancel(Esc)".into(), FormButtonAction::Cancel)
+            } else {
+                ("Save".into(), FormButtonAction::Accept)
+            },
             /* cursor_up_shortcut */ context.settings.shortcuts.general.scroll_up.clone(),
             /* cursor_down_shortcut */
             context.settings.shortcuts.general.scroll_down.clone(),
         );
-        self.form.add_button(("Cancel(Esc)".into(), false));
+        if !self.card.external_resource() {
+            self.form
+                .add_button(("Export".into(), FormButtonAction::Other("Export")));
+            self.form
+                .add_button(("Cancel(Esc)".into(), FormButtonAction::Cancel));
+        }
         self.form
             .push(("NAME".into(), self.card.name().to_string()));
         self.form.push((
@@ -153,15 +164,12 @@ impl Component for ContactManager {
 
         if self.is_dirty() {
             grid.clear_area(area, self.theme_default);
-            grid.copy_area(self.content.grid(), area.skip_rows(2), self.content.area());
+            grid.copy_area(self.content.grid(), area, self.content.area());
             self.dirty = false;
         }
 
-        self.form.draw(
-            grid,
-            area.skip_rows(2 + self.content.area().height()),
-            context,
-        );
+        self.form
+            .draw(grid, area.skip_rows(self.content.area().height()), context);
         if let ViewMode::Discard(ref mut selector) = self.mode {
             /* Let user choose whether to quit with/without saving or cancel */
             selector.draw(grid, area, context);
@@ -200,8 +208,8 @@ impl Component for ContactManager {
                 if self.form.process_event(event, context) {
                     match self.form.buttons_result() {
                         None => {}
-                        Some(true) => {
-                            let fields = std::mem::take(&mut self.form).collect().unwrap();
+                        Some(FormButtonAction::Accept) => {
+                            let fields = std::mem::take(&mut self.form).collect();
                             let fields: IndexMap<String, String> = fields
                                 .into_iter()
                                 .map(|(s, v)| {
@@ -217,16 +225,43 @@ impl Component for ContactManager {
                             let mut new_card = Card::from(fields);
                             new_card.set_id(*self.card.id());
                             context.accounts[self.account_pos]
-                                .address_book
+                                .contacts
                                 .add_card(new_card);
                             context.replies.push_back(UIEvent::StatusEvent(
                                 StatusEvent::DisplayMessage("Saved.".into()),
                             ));
                             self.unrealize(context);
                         }
-                        Some(false) => {
+                        Some(FormButtonAction::Cancel) => {
                             self.unrealize(context);
                         }
+                        Some(FormButtonAction::Other("Export")) => {
+                            let card = if self.has_changes {
+                                let fields = self.form.clone().collect();
+                                let fields: IndexMap<String, String> = fields
+                                    .into_iter()
+                                    .map(|(s, v)| {
+                                        (
+                                            s.to_string(),
+                                            match v {
+                                                Field::Text(v) => v.as_str().to_string(),
+                                                Field::Choice(mut v, c, _) => {
+                                                    v.remove(c).to_string()
+                                                }
+                                            },
+                                        )
+                                    })
+                                    .collect();
+                                let mut card = Card::from(fields);
+                                card.set_id(*self.card.id());
+                                Cow::Owned(card)
+                            } else {
+                                Cow::Borrowed(&self.card)
+                            };
+                            super::export_to_vcard(&card, self.account_pos, context);
+                            return true;
+                        }
+                        Some(FormButtonAction::Reset | FormButtonAction::Other(_)) => {}
                     }
                     self.set_dirty(true);
                     if matches!(event, UIEvent::InsertInput(_)) {

meli/src/contacts/list.rs

@@ -88,6 +88,7 @@ impl ContactList {
                 index: i,
             })
             .collect();
+        let theme_default = crate::conf::value(context, "theme_default");
         Self {
             accounts,
             cursor_pos: 0,
@@ -96,8 +97,8 @@ impl ContactList {
             account_pos: 0,
             id_positions: Vec::new(),
             mode: ViewMode::List,
-            data_columns: DataColumns::default(),
-            theme_default: crate::conf::value(context, "theme_default"),
+            data_columns: DataColumns::new(theme_default),
+            theme_default,
             highlight_theme: crate::conf::value(context, "highlight"),
             initialized: false,
             dirty: true,
@@ -121,17 +122,17 @@ impl ContactList {
     fn initialize(&mut self, context: &Context) {
         self.data_columns.clear();
         let account = &context.accounts[self.account_pos];
-        let book = &account.address_book;
-        self.length = book.len();
+        let contacts = &account.contacts;
+        self.length = contacts.len();
 
         self.id_positions.clear();
-        if self.id_positions.capacity() < book.len() {
-            self.id_positions.reserve(book.len());
+        if self.id_positions.capacity() < contacts.len() {
+            self.id_positions.reserve(contacts.len());
         }
         self.dirty = true;
         let mut min_width = ("Name".len(), "E-mail".len(), 0, "external".len(), 0, 0);
 
-        for c in book.values() {
+        for c in contacts.values() {
             /* name */
             let name = c.name().split_graphemes().len();
             if name > 0 {
@@ -163,8 +164,8 @@ impl ContactList {
         );
 
         let account = &context.accounts[self.account_pos];
-        let book = &account.address_book;
-        let mut book_values = book.values().collect::<Vec<&Card>>();
+        let contacts = &account.contacts;
+        let mut book_values = contacts.values().collect::<Vec<&Card>>();
         book_values.sort_unstable_by_key(|c| c.name());
         for (idx, c) in book_values.iter().enumerate() {
             self.id_positions.push(*c.id());
@@ -244,14 +245,13 @@ impl ContactList {
         }
     }
 
-    fn highlight_line(&mut self, grid: &mut CellBuffer, area: Area, idx: usize) {
+    fn highlight_line(&self, grid: &mut CellBuffer, area: Area, idx: usize) {
         /* Reset previously highlighted line */
         let mut theme = if idx == self.new_cursor_pos {
             self.highlight_theme
         } else {
             self.theme_default
         };
-        theme.fg = self.theme_default.fg;
         if !grid.use_color {
             theme.attrs |= Attr::REVERSE;
         }
@@ -294,7 +294,7 @@ impl ContactList {
         };
 
         grid.change_theme(area, account_attrs);
-        let s = format!(" [{}]", context.accounts[a.index].address_book.len());
+        let s = format!(" [{}]", context.accounts[a.index].contacts.len());
         /* Print account name */
         grid.write_string(
             &a.name,
@@ -582,7 +582,6 @@ impl Component for ContactList {
                         )));
                     return true;
                 }
-
                 UIEvent::Input(ref key)
                     if shortcut!(key == shortcuts[Shortcuts::CONTACT_LIST]["edit_contact"]) =>
                 {
@@ -590,8 +589,8 @@ impl Component for ContactList {
                         return true;
                     }
                     let account = &mut context.accounts[self.account_pos];
-                    let book = &mut account.address_book;
-                    let card = book[&self.id_positions[self.cursor_pos]].clone();
+                    let contacts = &mut account.contacts;
+                    let card = contacts[&self.id_positions[self.cursor_pos]].clone();
                     let mut manager = Box::new(ContactManager::new(context));
                     manager.set_parent_id(self.id);
                     manager.card = card;
@@ -605,6 +604,20 @@ impl Component for ContactList {
                         )));
                     return true;
                 }
+                UIEvent::Input(ref key)
+                    if shortcut!(key == shortcuts[Shortcuts::CONTACT_LIST]["export_contact"]) =>
+                {
+                    if self.length == 0 {
+                        return true;
+                    }
+                    let card = {
+                        let account = &context.accounts[self.account_pos];
+                        let contacts = &account.contacts;
+                        contacts[&self.id_positions[self.cursor_pos]].clone()
+                    };
+                    super::export_to_vcard(&card, self.account_pos, context);
+                    return true;
+                }
                 UIEvent::Input(ref key)
                     if shortcut!(key == shortcuts[Shortcuts::CONTACT_LIST]["mail_contact"]) =>
                 {
@@ -613,8 +626,8 @@ impl Component for ContactList {
                     }
                     let account = &context.accounts[self.account_pos];
                     let account_hash = account.hash();
-                    let book = &account.address_book;
-                    let card = &book[&self.id_positions[self.cursor_pos]];
+                    let contacts = &account.contacts;
+                    let card = &contacts[&self.id_positions[self.cursor_pos]];
                     let mut draft: Draft = Draft::default();
                     *draft.headers_mut().get_mut("To").unwrap() =
                         format!("{} <{}>", &card.name(), &card.email());
@@ -636,7 +649,7 @@ impl Component for ContactList {
                     }
                     // [ref:TODO]: add a confirmation dialog?
                     context.accounts[self.account_pos]
-                        .address_book
+                        .contacts
                         .remove_card(self.id_positions[self.cursor_pos]);
                     self.initialized = false;
                     self.set_dirty(true);
@@ -724,7 +737,7 @@ impl Component for ContactList {
                     self.menu_visibility = !self.menu_visibility;
                     self.set_dirty(true);
                 }
-                UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Alt(''))
+                UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1b'))
                     if !self.cmd_buf.is_empty() =>
                 {
                     self.cmd_buf.clear();
@@ -923,7 +936,7 @@ impl Component for ContactList {
     fn status(&self, context: &Context) -> String {
         format!(
             "{} entries",
-            context.accounts[self.account_pos].address_book.len()
+            context.accounts[self.account_pos].contacts.len()
         )
     }
 }

meli/src/contacts/mod.rs

@@ -19,5 +19,57 @@
  * along with meli. If not, see <http://www.gnu.org/licenses/>.
  */
 
+use melib::Card;
+
+use crate::{
+    types::{sanitize_filename, File, NotificationType, UIEvent},
+    Context,
+};
+
 pub mod editor;
 pub mod list;
+
+pub fn export_to_vcard(card: &Card, account_pos: usize, context: &mut Context) {
+    let mut output_dir = context.accounts[account_pos]
+        .settings
+        .account
+        .vcard_folder()
+        .map(|s| std::path::Path::new(s).to_path_buf());
+    let filename = sanitize_filename(format!(
+        "{prefix}{name}{suffix}{space}{additionalname}",
+        prefix = card.name_prefix(),
+        name = card.name(),
+        suffix = card.name_suffix(),
+        space = if card.additionalname().trim().is_empty() {
+            ""
+        } else {
+            " "
+        },
+        additionalname = card.additionalname()
+    ));
+    let res = File::create_temp_file(
+        card.to_vcard_string().as_bytes(),
+        filename.as_deref(),
+        output_dir.as_mut(),
+        Some("vcf"),
+        false,
+    );
+    match res {
+        Ok(f) => {
+            context.replies.push_back(UIEvent::Notification {
+                title: Some("Exported .vcf".into()),
+                body: format!("Exported contact to vcard file to\n{}", f.path().display()).into(),
+                kind: Some(NotificationType::Info),
+                source: None,
+            });
+        }
+        Err(err) => {
+            context.replies.push_back(UIEvent::Notification {
+                title: Some("Could not export contact.".into()),
+                body: err.to_string().into(),
+                kind: Some(NotificationType::Error(err.kind)),
+                source: Some(err),
+            });
+        }
+    }
+}

meli/src/jobs.rs

@@ -26,7 +26,10 @@ use std::{
     future::Future,
     iter,
     panic::catch_unwind,
-    sync::{Arc, Mutex},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Mutex,
+    },
     thread,
     time::Duration,
 };
@@ -42,8 +45,44 @@ use melib::{log, smol, utils::datetime, uuid::Uuid, UnixTimestamp};
 
 use crate::types::{StatusEvent, ThreadEvent, UIEvent};
 
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub enum IsAsync {
+    Async,
+    Blocking,
+}
+
 type AsyncTask = async_task::Runnable;
 
+#[derive(Clone, Debug)]
+struct FinishedTimestamp(Arc<Mutex<UnixTimestamp>>);
+
+impl FinishedTimestamp {
+    fn finished(&self) -> Option<UnixTimestamp> {
+        match self.0.lock() {
+            Ok(v) if *v == 0 => None,
+            Ok(v) => Some(*v),
+            Err(poison) => {
+                let mut guard = poison.into_inner();
+                if *guard == 0 {
+                    *guard = UnixTimestamp::default();
+                }
+                Some(*guard)
+            }
+        }
+    }
+
+    fn set_finished(&self, new_value: Option<UnixTimestamp>) {
+        let new_value = new_value.unwrap_or_default();
+        match self.0.lock() {
+            Ok(mut f) => *f = new_value,
+            Err(poison) => {
+                let mut guard = poison.into_inner();
+                *guard = new_value;
+            }
+        }
+    }
+}
+
 fn find_task(
     local: &Worker<MeliTask>,
     global: &Injector<MeliTask>,
@@ -113,12 +152,38 @@ pub struct MeliTask {
 #[derive(Clone, Debug)]
 /// A spawned future's metadata for book-keeping.
 pub struct JobMetadata {
-    pub id: JobId,
-    pub desc: Cow<'static, str>,
-    pub timer: bool,
-    pub started: UnixTimestamp,
-    pub finished: Option<UnixTimestamp>,
-    pub succeeded: bool,
+    id: JobId,
+    desc: Cow<'static, str>,
+    timer: bool,
+    started: UnixTimestamp,
+    finished: FinishedTimestamp,
+    succeeded: bool,
+}
+
+impl JobMetadata {
+    pub fn id(&self) -> &JobId {
+        &self.id
+    }
+
+    pub fn description(&self) -> &str {
+        &self.desc
+    }
+
+    pub fn is_timer(&self) -> bool {
+        self.timer
+    }
+
+    pub fn started(&self) -> UnixTimestamp {
+        self.started
+    }
+
+    pub fn finished(&self) -> Option<UnixTimestamp> {
+        self.finished.finished()
+    }
+
+    pub fn succeeded(&self) -> bool {
+        self.succeeded
+    }
 }
 
 #[derive(Debug)]
@@ -139,7 +204,7 @@ struct TimerPrivate {
     value: Duration,
     active: bool,
     handle: Option<async_task::Task<()>>,
-    cancel: Arc<Mutex<bool>>,
+    cancel: Arc<AtomicBool>,
 }
 
 #[derive(Debug)]
@@ -238,7 +303,26 @@ impl JobExecutor {
 
     /// Spawns a future with a generic return value `R`
     #[inline(always)]
-    pub fn spawn_specialized<F, R>(&self, desc: Cow<'static, str>, future: F) -> JoinHandle<R>
+    pub fn spawn<F, R>(
+        &self,
+        desc: Cow<'static, str>,
+        future: F,
+        is_async: IsAsync,
+    ) -> JoinHandle<R>
+    where
+        F: Future<Output = R> + Send + 'static,
+        R: Send + 'static,
+    {
+        if matches!(is_async, IsAsync::Async) {
+            self.spawn_specialized(desc, future)
+        } else {
+            self.spawn_blocking(desc, future)
+        }
+    }
+
+    /// Spawns a future with a generic return value `R`
+    #[inline(always)]
+    fn spawn_specialized<F, R>(&self, desc: Cow<'static, str>, future: F) -> JoinHandle<R>
     where
         F: Future<Output = R> + Send + 'static,
         R: Send + 'static,
@@ -247,8 +331,10 @@ impl JobExecutor {
         let finished_sender = self.sender.clone();
         let job_id = JobId::new();
         let injector = self.global_queue.clone();
-        let cancel = Arc::new(Mutex::new(false));
-        let cancel2 = cancel.clone();
+        // We do not use `AtomicU64` because it's not portable, so ignore the lint.
+        #[allow(clippy::mutex_integer)]
+        let finished = FinishedTimestamp(Arc::new(Mutex::new(0)));
+        let cancel = Arc::new(AtomicBool::new(false));
 
         self.jobs.lock().unwrap().insert(
             job_id,
@@ -256,34 +342,41 @@ impl JobExecutor {
                 id: job_id,
                 desc: desc.clone(),
                 started: datetime::now(),
-                finished: None,
+                finished: finished.clone(),
                 succeeded: true,
                 timer: false,
             },
         );
 
         // Create a task and schedule it for execution.
-        let (handle, task) = async_task::spawn(
-            async move {
-                let res = future.await;
-                let _ = sender.send(res);
-                finished_sender
-                    .send(ThreadEvent::JobFinished(job_id))
-                    .unwrap();
-            },
-            move |task| {
-                if *cancel.lock().unwrap() {
-                    return;
-                }
-                let desc = desc.clone();
-                injector.push(MeliTask {
-                    task,
-                    id: job_id,
-                    desc,
-                    timer: false,
-                })
-            },
-        );
+        let (handle, task) = {
+            let cancel = cancel.clone();
+            let finished = finished.clone();
+            async_task::spawn(
+                async move {
+                    let res = future.await;
+                    let _ = sender.send(res);
+                    if let Ok(mut guard) = finished.0.lock() {
+                        *guard = datetime::now();
+                    }
+                    finished_sender
+                        .send(ThreadEvent::JobFinished(job_id))
+                        .unwrap();
+                },
+                move |task| {
+                    if cancel.load(Ordering::SeqCst) {
+                        return;
+                    }
+                    let desc = desc.clone();
+                    injector.push(MeliTask {
+                        task,
+                        id: job_id,
+                        desc,
+                        timer: false,
+                    })
+                },
+            )
+        };
         handle.schedule();
         for unparker in self.parkers.iter() {
             unparker.unpark();
@@ -291,7 +384,8 @@ impl JobExecutor {
 
         JoinHandle {
             task: Arc::new(Mutex::new(Some(task))),
-            cancel: cancel2,
+            cancel,
+            finished,
             chan: receiver,
             job_id,
         }
@@ -300,7 +394,7 @@ impl JobExecutor {
     /// Spawns a future with a generic return value `R` that might block on a
     /// new thread
     #[inline(always)]
-    pub fn spawn_blocking<F, R>(&self, desc: Cow<'static, str>, future: F) -> JoinHandle<R>
+    fn spawn_blocking<F, R>(&self, desc: Cow<'static, str>, future: F) -> JoinHandle<R>
     where
         F: Future<Output = R> + Send + 'static,
         R: Send + 'static,
@@ -314,7 +408,7 @@ impl JobExecutor {
     pub fn create_timer(self: Arc<Self>, interval: Duration, value: Duration) -> Timer {
         let timer = TimerPrivate {
             interval,
-            cancel: Arc::new(Mutex::new(false)),
+            cancel: Arc::new(AtomicBool::new(false)),
             value,
             active: true,
             handle: None,
@@ -342,46 +436,48 @@ impl JobExecutor {
         let sender = self.sender.clone();
         let injector = self.global_queue.clone();
         let timers = self.timers.clone();
-        let cancel = Arc::new(Mutex::new(false));
-        let cancel2 = cancel.clone();
-        let (task, handle) = async_task::spawn(
-            async move {
-                let mut value = value;
-                loop {
-                    smol::Timer::after(value).await;
-                    sender
-                        .send(ThreadEvent::UIEvent(UIEvent::Timer(id)))
-                        .unwrap();
-                    if let Some(interval) = timers.lock().unwrap().get(&id).and_then(|timer| {
-                        if timer.interval.as_millis() == 0 && timer.interval.as_secs() == 0 {
-                            None
-                        } else if timer.active {
-                            Some(timer.interval)
+        let cancel = Arc::new(AtomicBool::new(false));
+        let (task, handle) = {
+            let cancel = cancel.clone();
+            async_task::spawn(
+                async move {
+                    let mut value = value;
+                    loop {
+                        smol::Timer::after(value).await;
+                        sender
+                            .send(ThreadEvent::UIEvent(UIEvent::Timer(id)))
+                            .unwrap();
+                        if let Some(interval) = timers.lock().unwrap().get(&id).and_then(|timer| {
+                            if timer.interval.as_millis() == 0 && timer.interval.as_secs() == 0 {
+                                None
+                            } else if timer.active {
+                                Some(timer.interval)
+                            } else {
+                                None
+                            }
+                        }) {
+                            value = interval;
                         } else {
-                            None
+                            break;
                         }
-                    }) {
-                        value = interval;
-                    } else {
-                        break;
                     }
-                }
-            },
-            move |task| {
-                if *cancel.lock().unwrap() {
-                    return;
-                }
-                injector.push(MeliTask {
-                    task,
-                    id: job_id,
-                    desc: "timer".into(),
-                    timer: true,
-                })
-            },
-        );
+                },
+                move |task| {
+                    if cancel.load(Ordering::SeqCst) {
+                        return;
+                    }
+                    injector.push(MeliTask {
+                        task,
+                        id: job_id,
+                        desc: Cow::Borrowed("timer"),
+                        timer: true,
+                    })
+                },
+            )
+        };
         self.timers.lock().unwrap().entry(id).and_modify(|timer| {
             timer.handle = Some(handle);
-            timer.cancel = cancel2;
+            timer.cancel = cancel;
             timer.active = true;
         });
         task.schedule();
@@ -394,7 +490,7 @@ impl JobExecutor {
         let mut timers_lck = self.timers.lock().unwrap();
         if let Some(timer) = timers_lck.get_mut(&id) {
             timer.active = false;
-            *timer.cancel.lock().unwrap() = true;
+            timer.cancel.store(true, Ordering::SeqCst);
         }
     }
 
@@ -407,7 +503,7 @@ impl JobExecutor {
 
     pub fn set_job_finished(&self, id: JobId) {
         self.jobs.lock().unwrap().entry(id).and_modify(|entry| {
-            entry.finished = Some(datetime::now());
+            entry.finished.set_finished(Some(datetime::now()));
         });
     }
 
@@ -425,20 +521,29 @@ pub type JobChannel<T> = oneshot::Receiver<T>;
 pub struct JoinHandle<T> {
     pub task: Arc<Mutex<Option<async_task::Task<()>>>>,
     pub chan: JobChannel<T>,
-    pub cancel: Arc<Mutex<bool>>,
+    pub cancel: Arc<AtomicBool>,
+    finished: FinishedTimestamp,
     pub job_id: JobId,
 }
 
 impl<T> JoinHandle<T> {
     pub fn cancel(&self) -> Option<StatusEvent> {
-        let mut lck = self.cancel.lock().unwrap();
-        if !*lck {
-            *lck = true;
+        let was_active = self.cancel.swap(true, Ordering::SeqCst);
+        if was_active {
+            self.finished.set_finished(Some(datetime::now()));
             Some(StatusEvent::JobCanceled(self.job_id))
         } else {
             None
         }
     }
+
+    pub fn finished(&self) -> Option<UnixTimestamp> {
+        self.finished.finished()
+    }
+
+    pub fn is_canceled(&self) -> bool {
+        self.cancel.load(Ordering::SeqCst)
+    }
 }
 
 impl<T> std::cmp::PartialEq<JobId> for JoinHandle<T> {
@@ -447,17 +552,8 @@ impl<T> std::cmp::PartialEq<JobId> for JoinHandle<T> {
     }
 }
 
-/*
-use std::pin::Pin;
-use std::task::{Context, Poll};
-impl Future for JoinHandle {
-    type Output = Result<()>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match Pin::new(&mut self.inner).poll(cx) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(output) => Poll::Ready(output.expect("task failed")),
-        }
+impl<T> Drop for JoinHandle<T> {
+    fn drop(&mut self) {
+        _ = self.cancel();
     }
 }
-*/

meli/src/lib.rs

@@ -21,6 +21,7 @@
 
 #![deny(
     rustdoc::redundant_explicit_links,
+    unsafe_op_in_unsafe_fn,
     /* groups */
     clippy::correctness,
     clippy::suspicious,
@@ -42,6 +43,7 @@
     //clippy::ptr_as_ptr,
     clippy::doc_markdown,
     clippy::expect_fun_call,
+    clippy::or_fun_call,
     clippy::bool_to_int_with_if,
     clippy::borrow_as_ptr,
     clippy::cast_ptr_alignment,
@@ -139,19 +141,17 @@ pub use crate::mail::*;
 
 pub mod notifications;
 
-pub mod mailbox_management;
-pub use mailbox_management::*;
+pub mod manage;
+pub use manage::*;
 
-pub mod jobs_view;
-pub use jobs_view::*;
-
-#[cfg(feature = "svgscreenshot")]
-pub mod svg;
+// #[cfg(feature = "svgscreenshot")]
+// pub mod svg;
 
 #[macro_use]
 pub mod conf;
 pub use crate::conf::{
-    DotAddressable, IndexStyle, SearchBackend, Settings, Shortcuts, ThemeAttribute,
+    data_types::{IndexStyle, SearchBackend},
+    DotAddressable, Settings, Shortcuts, ThemeAttribute,
 };
 
 #[cfg(feature = "sqlite3")]
@@ -162,3 +162,7 @@ pub mod mailcap;
 
 pub mod accounts;
 pub use self::accounts::Account;
+
+pub mod patch_retrieve;
+
+pub mod version_migrations;

meli/src/mail.rs

@@ -21,18 +21,21 @@
 
 //! Entities that handle Mail specific functions.
 
+use std::{future::Future, pin::Pin};
+
 use indexmap::IndexMap;
 use melib::{
     backends::{AccountHash, Mailbox, MailboxHash},
     email::{attachment_types::*, attachments::*},
+    text::{TextProcessing, Truncate},
     thread::ThreadNodeHash,
 };
+use uuid::Uuid;
 
 use super::*;
-use crate::{
-    melib::text::{TextProcessing, Truncate},
-    uuid::Uuid,
-};
+
+pub type AttachmentBoxFuture = Pin<Box<dyn Future<Output = Result<AttachmentBuilder>> + Send>>;
+pub type AttachmentFilterBox = Box<dyn FnOnce(AttachmentBuilder) -> AttachmentBoxFuture + Send>;
 
 pub mod listing;
 pub use crate::listing::*;

meli/src/mail/compose.rs

@@ -20,7 +20,9 @@
  */
 
 use std::{
+    borrow::Cow,
     convert::TryInto,
+    fmt::Write as _,
     future::Future,
     io::Write,
     pin::Pin,
@@ -31,13 +33,19 @@ use std::{
 use indexmap::IndexSet;
 use melib::{
     email::attachment_types::{ContentType, MultipartType},
-    list_management, Address, AddressBook, Draft, HeaderName, SpecialUsageMailbox, SubjectPrefix,
-    UnixTimestamp,
+    list_management,
+    parser::BytesExt,
+    Address, Contacts, Draft, HeaderName, SpecialUsageMailbox, SubjectPrefix, UnixTimestamp,
 };
 use nix::sys::wait::WaitStatus;
 
 use super::*;
-use crate::{accounts::JobRequest, jobs::JoinHandle, terminal::embedded::Terminal};
+use crate::{
+    accounts::JobRequest,
+    jobs::{IsAsync, JoinHandle},
+    terminal::embedded::Terminal,
+    types::{sanitize_filename, File},
+};
 
 #[cfg(feature = "gpgme")]
 pub mod gpg;
@@ -126,7 +134,7 @@ enum ViewMode {
     EmbeddedPty,
     SelectRecipients(UIDialog<Address>),
     #[cfg(feature = "gpgme")]
-    SelectEncryptKey(bool, gpg::KeySelection),
+    SelectKey(bool, gpg::KeySelection),
     Send(UIConfirmationDialog),
     WaitingForSendResult(UIDialog<char>, JoinHandle<Result<()>>),
 }
@@ -236,7 +244,41 @@ impl Composer {
                 format!("meli {}", option_env!("CARGO_PKG_VERSION").unwrap_or("0.0")),
             );
         }
-        if *account_settings!(context[account_hash].composing.format_flowed) {
+        let format_flowed = *account_settings!(context[account_hash].composing.format_flowed);
+        if *account_settings!(context[account_hash].composing.use_signature) {
+            let override_value = account_settings!(context[account_hash].composing.signature_file)
+                .as_deref()
+                .map(Cow::Borrowed)
+                .filter(|p| p.as_ref().is_file());
+            let account_value = || {
+                context.accounts[&account_hash]
+                    .signature_file()
+                    .map(Cow::Owned)
+            };
+            if let Some(path) = override_value.or_else(account_value) {
+                match std::fs::read_to_string(path.as_ref()).chain_err_related_path(path.as_ref()) {
+                    Ok(sig) => {
+                        let mut delimiter =
+                            account_settings!(context[account_hash].composing.signature_delimiter)
+                                .as_deref()
+                                .map(Cow::Borrowed)
+                                .unwrap_or_else(|| Cow::Borrowed("\n\n-- \n"));
+                        if format_flowed {
+                            delimiter = Cow::Owned(delimiter.replace(" \n", " \n\n"));
+                        }
+                        _ = write!(&mut ret.draft.body, "{}{}", delimiter.as_ref(), sig);
+                    }
+                    Err(err) => {
+                        log::error!(
+                            "Could not open signature file for account `{}`: {}.",
+                            context.accounts[&account_hash].name(),
+                            err
+                        );
+                    }
+                }
+            }
+        }
+        if format_flowed {
             ret.pager.set_reflow(melib::text::Reflow::FormatFlowed);
         }
         ret
@@ -331,15 +373,15 @@ impl Composer {
                         if !acc.is_empty() {
                             acc.push(' ');
                         }
-                        acc.push_str(&x.to_string());
+                        acc.push_str(&x.display_brackets().to_string());
                         acc
                     }),
-                envelope.message_id_display()
+                envelope.message_id().display_brackets()
             ),
         );
         ret.draft.set_header(
             HeaderName::IN_REPLY_TO,
-            envelope.message_id_display().into(),
+            envelope.message_id().display_brackets().to_string(),
         );
 
         if let Some(reply_to) = envelope.other_headers().get(HeaderName::TO) {
@@ -391,7 +433,7 @@ impl Composer {
                 .settings
                 .account()
                 .main_identity_address();
-            to.remove(&ours);
+            to.shift_remove(&ours);
             ret.draft.set_header(HeaderName::TO, {
                 let mut ret: String =
                     to.into_iter()
@@ -415,7 +457,7 @@ impl Composer {
                 .set_header(HeaderName::TO, envelope.field_from_to_string());
         }
         ret.draft.body = {
-            let mut ret = attribution_string(
+            let mut quoted = attribution_string(
                 account_settings!(
                     context[ret.account_hash]
                         .composing
@@ -432,11 +474,12 @@ impl Composer {
                 ),
             );
             for l in reply_body.lines() {
-                ret.push('>');
-                ret.push_str(l);
-                ret.push('\n');
+                quoted.push('>');
+                quoted.push_str(l);
+                quoted.push('\n');
             }
-            ret
+            _ = write!(&mut quoted, "{}", ret.draft.body);
+            quoted
         };
 
         ret.account_hash = coordinates.0;
@@ -536,7 +579,7 @@ To: {}
             let mut attachment = AttachmentBuilder::new(b"");
             let mut disposition: ContentDisposition = ContentDispositionKind::Attachment.into();
             {
-                disposition.filename = Some(format!("{}.eml", env.message_id_raw()));
+                disposition.filename = Some(format!("{}.eml", env.message_id()));
             }
             attachment
                 .set_raw(bytes.to_vec())
@@ -632,7 +675,7 @@ To: {}
                     k.into(),
                     headers[k].to_string(),
                     Box::new(move |c, term| {
-                        let book: &AddressBook = &c.accounts[&account_hash].address_book;
+                        let book: &Contacts = &c.accounts[&account_hash].contacts;
                         let results: Vec<String> = book.search(term);
                         results
                             .into_iter()
@@ -649,23 +692,22 @@ To: {}
                             .values()
                             .map(|acc| {
                                 let addr = acc.settings.account.main_identity_address();
-                                let desc =
-                                    match account_settings!(c[acc.hash()].composing.send_mail) {
-                                        crate::conf::composing::SendMail::ShellCommand(ref cmd) => {
-                                            let mut cmd = cmd.as_str();
-                                            cmd.truncate_at_boundary(10);
-                                            format!("{} [exec: {}]", acc.name(), cmd)
-                                        }
-                                        #[cfg(feature = "smtp")]
-                                        crate::conf::composing::SendMail::Smtp(ref inner) => {
-                                            let mut hostname = inner.hostname.as_str();
-                                            hostname.truncate_at_boundary(10);
-                                            format!("{} [smtp: {}]", acc.name(), hostname)
-                                        }
-                                        crate::conf::composing::SendMail::ServerSubmission => {
-                                            format!("{} [server submission]", acc.name())
-                                        }
-                                    };
+                                let desc = match account_settings!(c[acc.hash()].send_mail) {
+                                    crate::conf::composing::SendMail::ShellCommand(ref cmd) => {
+                                        let mut cmd = cmd.as_str();
+                                        cmd.truncate_at_boundary(10);
+                                        format!("{} [exec: {}]", acc.name(), cmd)
+                                    }
+                                    #[cfg(feature = "smtp")]
+                                    crate::conf::composing::SendMail::Smtp(ref inner) => {
+                                        let mut hostname = inner.hostname.as_str();
+                                        hostname.truncate_at_boundary(10);
+                                        format!("{} [smtp: {}]", acc.name(), hostname)
+                                    }
+                                    crate::conf::composing::SendMail::ServerSubmission => {
+                                        format!("{} [server submission]", acc.name())
+                                    }
+                                };
 
                                 (addr.to_string(), desc)
                             })
@@ -683,6 +725,12 @@ To: {}
         let attachments_no = self.draft.attachments().len();
         let theme_default = crate::conf::value(context, "theme_default");
         grid.clear_area(area, theme_default);
+        let our_map: ShortcutMap =
+            account_settings!(context[self.account_hash].shortcuts.composing).key_values();
+        let mut shortcuts: ShortcutMaps = Default::default();
+        shortcuts.insert(Shortcuts::COMPOSING, our_map);
+        let toggle_shortcut = Key::Char('\n');
+        let edit_shortcut = &shortcuts[Shortcuts::COMPOSING]["edit"];
         #[cfg(feature = "gpgme")]
         if self
             .gpg_state
@@ -694,18 +742,20 @@ To: {}
                 .gpg_state
                 .sign_keys
                 .iter()
-                .map(|k| k.fingerprint())
+                .map(|k| k.to_string())
                 .collect::<Vec<_>>()
                 .join(", ");
 
             grid.write_string(
                 &format!(
-                    "☑ sign with {}",
+                    "☑ sign with [toggle: {}, edit: {}] {}",
+                    toggle_shortcut,
+                    edit_shortcut,
                     if self.gpg_state.sign_keys.is_empty() {
                         "default key"
                     } else {
                         key_list.as_str()
-                    }
+                    },
                 ),
                 theme_default.fg,
                 if self.cursor == Cursor::Sign {
@@ -720,7 +770,10 @@ To: {}
             );
         } else {
             grid.write_string(
-                "☐ don't sign",
+                &format!(
+                    "☐ don't sign [toggle: {}, edit: {}]",
+                    toggle_shortcut, edit_shortcut,
+                ),
                 theme_default.fg,
                 if self.cursor == Cursor::Sign {
                     crate::conf::value(context, "highlight").bg
@@ -744,18 +797,28 @@ To: {}
                 .gpg_state
                 .encrypt_keys
                 .iter()
-                .map(|k| k.fingerprint())
+                .map(|k| k.to_string())
                 .collect::<Vec<_>>()
                 .join(", ");
 
             grid.write_string(
                 &format!(
-                    "{}{}",
+                    "{}{}{}",
                     if self.gpg_state.encrypt_keys.is_empty() {
-                        "☐ no keys to encrypt with!"
+                        "☐ no keys selected to encrypt with"
                     } else {
-                        "☑ encrypt with "
+                        "☑ encrypt with"
                     },
+                    &format!(
+                        " [toggle: {}, edit: {}]{}",
+                        toggle_shortcut,
+                        edit_shortcut,
+                        if self.gpg_state.encrypt_keys.is_empty() {
+                            ""
+                        } else {
+                            " "
+                        }
+                    ),
                     if self.gpg_state.encrypt_keys.is_empty() {
                         ""
                     } else {
@@ -775,7 +838,10 @@ To: {}
             );
         } else {
             grid.write_string(
-                "☐ don't encrypt",
+                &format!(
+                    "☐ don't encrypt [toggle: {}, edit: {}]",
+                    toggle_shortcut, edit_shortcut,
+                ),
                 theme_default.fg,
                 if self.cursor == Cursor::Encrypt {
                     crate::conf::value(context, "highlight").bg
@@ -790,7 +856,7 @@ To: {}
         }
         if attachments_no == 0 {
             grid.write_string(
-                "no attachments",
+                &format!("no attachments [edit: {}]", edit_shortcut),
                 theme_default.fg,
                 if self.cursor == Cursor::Attachments {
                     crate::conf::value(context, "highlight").bg
@@ -804,7 +870,7 @@ To: {}
             );
         } else {
             grid.write_string(
-                &format!("{} attachments ", attachments_no),
+                &format!("{} attachments [edit: {}]", attachments_no, edit_shortcut),
                 theme_default.fg,
                 if self.cursor == Cursor::Attachments {
                     crate::conf::value(context, "highlight").bg
@@ -870,6 +936,36 @@ To: {}
             }
         }
     }
+
+    #[cfg(feature = "gpgme")]
+    fn create_key_selection_widget(
+        &self,
+        secret: bool,
+        header: &HeaderName,
+        context: &Context,
+    ) -> Result<gpg::KeySelectionLoading> {
+        let (_, mut list) = melib::email::parser::address::rfc2822address_list(
+            self.form.values()[header.as_str()].as_str().as_bytes(),
+        )
+        .map_err(|_err| -> Error { format!("No valid address in `{header}:`").into() })?;
+        if list.is_empty() {
+            return Err(format!("No valid address in `{header}:`").into());
+        }
+        let first = list.remove(0);
+        let patterns = (
+            first.get_email(),
+            list.into_iter()
+                .map(|addr| addr.get_email())
+                .collect::<Vec<String>>(),
+        );
+        gpg::KeySelectionLoading::new(
+            secret,
+            account_settings!(context[self.account_hash].pgp.allow_remote_lookup).is_true(),
+            patterns,
+            *account_settings!(context[self.account_hash].pgp.allow_remote_lookup),
+            context,
+        )
+    }
 }
 
 impl Component for Composer {
@@ -884,6 +980,11 @@ impl Component for Composer {
                 self.gpg_state.sign_mail =
                     Some(*account_settings!(context[self.account_hash].pgp.auto_sign));
             }
+            #[cfg(feature = "gpgme")]
+            {
+                self.gpg_state.encrypt_for_self =
+                    *account_settings!(context[self.account_hash].pgp.encrypt_for_self);
+            }
             if !self.draft.headers().contains_key(HeaderName::FROM)
                 || self.draft.headers()[HeaderName::FROM].is_empty()
             {
@@ -931,12 +1032,27 @@ impl Component for Composer {
 
         if self.dirty {
             grid.clear_area(area.nth_row(0), crate::conf::value(context, "highlight"));
+            let our_map: ShortcutMap =
+                account_settings!(context[self.account_hash].shortcuts.composing).key_values();
+            let mut shortcuts: ShortcutMaps = Default::default();
+            shortcuts.insert(Shortcuts::COMPOSING, our_map);
+            let scroll_down_shortcut = &shortcuts[Shortcuts::COMPOSING]["scroll_down"];
+            let scroll_up_shortcut = &shortcuts[Shortcuts::COMPOSING]["scroll_up"];
+            let field_shortcut = Key::Char('\n');
+            let edit_shortcut = &shortcuts[Shortcuts::COMPOSING]["edit"];
             grid.write_string(
-                if self.reply_context.is_some() {
-                    "COMPOSING REPLY"
-                } else {
-                    "COMPOSING MESSAGE"
-                },
+                &format!(
+                    "COMPOSING {} [scroll down: {}, scroll up: {}, edit fields: {}, edit body: {}]",
+                    if self.reply_context.is_some() {
+                        "REPLY"
+                    } else {
+                        "MESSAGE"
+                    },
+                    scroll_down_shortcut,
+                    scroll_up_shortcut,
+                    field_shortcut,
+                    edit_shortcut
+                ),
                 crate::conf::value(context, "highlight").fg,
                 crate::conf::value(context, "highlight").bg,
                 crate::conf::value(context, "highlight").attrs,
@@ -1002,11 +1118,11 @@ impl Component for Composer {
                     let stopped_message: String =
                         format!("Process with PID {} has stopped.", guard.child_pid);
                     let stopped_message_2: String = format!(
-                        "-press '{}' (edit shortcut) to re-activate.",
+                        "- re-activate '{}' (edit shortcut)",
                         shortcuts[Shortcuts::COMPOSING]["edit"]
                     );
                     const STOPPED_MESSAGE_3: &str =
-                        "-press Ctrl-C to forcefully kill it and return to editor.";
+                        "- press Ctrl-C to forcefully kill it and return to editor";
                     let max_len = std::cmp::max(
                         stopped_message.len(),
                         std::cmp::max(stopped_message_2.len(), STOPPED_MESSAGE_3.len()),
@@ -1069,30 +1185,50 @@ impl Component for Composer {
                 .draw(grid, inner_area, context);
             }
             ViewMode::Send(ref mut s) => {
-                s.draw(grid, body_area, context);
+                let inner_area = area.center_inside((
+                    area.width().saturating_sub(2),
+                    area.height().saturating_sub(2),
+                ));
+                s.draw(grid, inner_area, context);
             }
             #[cfg(feature = "gpgme")]
-            ViewMode::SelectEncryptKey(
+            ViewMode::SelectKey(
                 _,
                 gpg::KeySelection::Loaded {
                     ref mut widget,
                     keys: _,
                 },
             ) => {
-                widget.draw(grid, body_area, context);
+                let inner_area = area.center_inside((
+                    area.width().saturating_sub(2),
+                    area.height().saturating_sub(2),
+                ));
+                widget.draw(grid, inner_area, context);
             }
             #[cfg(feature = "gpgme")]
-            ViewMode::SelectEncryptKey(_, _) => {}
+            ViewMode::SelectKey(_, _) => {}
             ViewMode::SelectRecipients(ref mut s) => {
-                s.draw(grid, body_area, context);
+                let inner_area = area.center_inside((
+                    area.width().saturating_sub(2),
+                    area.height().saturating_sub(2),
+                ));
+                s.draw(grid, inner_area, context);
             }
             ViewMode::Discard(_, ref mut s) => {
+                let inner_area = area.center_inside((
+                    area.width().saturating_sub(2),
+                    area.height().saturating_sub(2),
+                ));
                 /* Let user choose whether to quit with/without saving or cancel */
-                s.draw(grid, body_area, context);
+                s.draw(grid, inner_area, context);
             }
             ViewMode::WaitingForSendResult(ref mut s, _) => {
+                let inner_area = area.center_inside((
+                    area.width().saturating_sub(2),
+                    area.height().saturating_sub(2),
+                ));
                 /* Let user choose whether to wait for success or cancel */
-                s.draw(grid, body_area, context);
+                s.draw(grid, inner_area, context);
             }
         }
 
@@ -1175,7 +1311,7 @@ impl Component for Composer {
                 {
                     if matches!(
                         widget.buttons.result(),
-                        Some(FormButtonActions::Cancel | FormButtonActions::Accept)
+                        Some(FormButtonAction::Cancel | FormButtonAction::Accept)
                     ) {
                         self.mode = ViewMode::Edit;
                     }
@@ -1198,10 +1334,11 @@ impl Component for Composer {
                         Flag::SEEN,
                     ) {
                         Ok(job) => {
-                            let handle = context
-                                .main_loop_handler
-                                .job_executor
-                                .spawn_blocking("compose::submit".into(), job);
+                            let handle = context.main_loop_handler.job_executor.spawn(
+                                "compose::submit".into(),
+                                job,
+                                IsAsync::Blocking,
+                            );
                             context
                                 .replies
                                 .push_back(UIEvent::StatusEvent(StatusEvent::NewJob(
@@ -1271,10 +1408,9 @@ impl Component for Composer {
                 self.set_dirty(true);
             }
             #[cfg(feature = "gpgme")]
-            (
-                ViewMode::SelectEncryptKey(_, ref mut selector),
-                UIEvent::ComponentUnrealize(ref id),
-            ) if *id == selector.id() => {
+            (ViewMode::SelectKey(_, ref mut selector), UIEvent::ComponentUnrealize(ref id))
+                if *id == selector.id() =>
+            {
                 self.mode = ViewMode::Edit;
                 self.set_dirty(true);
                 return true;
@@ -1403,16 +1539,16 @@ impl Component for Composer {
             }
             #[cfg(feature = "gpgme")]
             (
-                ViewMode::SelectEncryptKey(is_encrypt, ref mut selector),
+                ViewMode::SelectKey(is_encrypt, ref mut selector),
                 UIEvent::FinishedUIDialog(id, result),
             ) if *id == selector.id() => {
-                if let Some(Some(key)) = result.downcast_mut::<Option<melib::gpgme::Key>>() {
+                if let Some(Some(keys)) = result.downcast_mut::<Option<Vec<melib::gpgme::Key>>>() {
                     if *is_encrypt {
                         self.gpg_state.encrypt_keys.clear();
-                        self.gpg_state.encrypt_keys.push(key.clone());
+                        self.gpg_state.encrypt_keys = std::mem::take(keys);
                     } else {
                         self.gpg_state.sign_keys.clear();
-                        self.gpg_state.sign_keys.push(key.clone());
+                        self.gpg_state.sign_keys = std::mem::take(keys);
                     }
                 }
                 self.mode = ViewMode::Edit;
@@ -1420,7 +1556,7 @@ impl Component for Composer {
                 return true;
             }
             #[cfg(feature = "gpgme")]
-            (ViewMode::SelectEncryptKey(_, ref mut selector), _) => {
+            (ViewMode::SelectKey(_, ref mut selector), _) => {
                 if selector.process_event(event, context) {
                     self.set_dirty(true);
                     return true;
@@ -1689,39 +1825,28 @@ impl Component for Composer {
                     && shortcut!(key == shortcuts[Shortcuts::COMPOSING]["edit"]) =>
             {
                 #[cfg(feature = "gpgme")]
-                match melib::email::parser::address::rfc2822address_list(
-                    self.form.values()["From"].as_str().as_bytes(),
-                )
-                .map_err(|_err| -> Error { "No valid sender address in `From:`".into() })
-                .and_then(|(_, list)| {
-                    list.first()
-                        .cloned()
-                        .ok_or_else(|| "No valid sender address in `From:`".into())
-                })
-                .and_then(|addr| {
-                    gpg::KeySelection::new(
-                        false,
-                        account_settings!(context[self.account_hash].pgp.allow_remote_lookup)
-                            .is_true(),
-                        addr.get_email(),
-                        *account_settings!(context[self.account_hash].pgp.allow_remote_lookup),
-                        context,
-                    )
-                }) {
-                    Ok(widget) => {
-                        self.gpg_state.sign_mail = Some(ActionFlag::from(true));
-                        self.mode = ViewMode::SelectEncryptKey(false, widget);
-                    }
-                    Err(err) => {
-                        context.replies.push_back(UIEvent::Notification {
-                            title: Some("Could not list keys.".into()),
-                            source: None,
-                            body: format!("libgpgme error: {err}").into(),
-                            kind: Some(NotificationType::Error(melib::error::ErrorKind::External)),
-                        });
+                {
+                    match self
+                        .create_key_selection_widget(false, &HeaderName::FROM, context)
+                        .map(Into::into)
+                    {
+                        Ok(widget) => {
+                            self.gpg_state.sign_mail = Some(ActionFlag::from(true));
+                            self.mode = ViewMode::SelectKey(false, widget);
+                        }
+                        Err(err) => {
+                            context.replies.push_back(UIEvent::Notification {
+                                title: Some("Could not list keys.".into()),
+                                source: None,
+                                body: format!("libgpgme error: {err}").into(),
+                                kind: Some(NotificationType::Error(
+                                    melib::error::ErrorKind::External,
+                                )),
+                            });
+                        }
                     }
+                    self.set_dirty(true);
                 }
-                self.set_dirty(true);
                 return true;
             }
             UIEvent::Input(ref key)
@@ -1730,39 +1855,63 @@ impl Component for Composer {
                     && shortcut!(key == shortcuts[Shortcuts::COMPOSING]["edit"]) =>
             {
                 #[cfg(feature = "gpgme")]
-                match melib::email::parser::address::rfc2822address_list(
-                    self.form.values()["To"].as_str().as_bytes(),
-                )
-                .map_err(|_err| -> Error { "No valid recipient addresses in `To:`".into() })
-                .and_then(|(_, list)| {
-                    list.first()
-                        .cloned()
-                        .ok_or_else(|| "No valid recipient addresses in `To:`".into())
-                })
-                .and_then(|addr| {
-                    gpg::KeySelection::new(
-                        false,
-                        account_settings!(context[self.account_hash].pgp.allow_remote_lookup)
-                            .is_true(),
-                        addr.get_email(),
-                        *account_settings!(context[self.account_hash].pgp.allow_remote_lookup),
-                        context,
-                    )
-                }) {
-                    Ok(widget) => {
-                        self.gpg_state.encrypt_mail = Some(ActionFlag::from(true));
-                        self.mode = ViewMode::SelectEncryptKey(true, widget);
-                    }
-                    Err(err) => {
-                        context.replies.push_back(UIEvent::Notification {
-                            title: Some("Could not list keys.".into()),
-                            source: None,
-                            body: format!("libgpgme error: {err}").into(),
-                            kind: Some(NotificationType::Error(melib::error::ErrorKind::External)),
+                {
+                    let mut result =
+                        self.create_key_selection_widget(false, &HeaderName::TO, context);
+                    if !self.form.values()[HeaderName::CC.as_str()]
+                        .as_str()
+                        .is_empty()
+                    {
+                        result = result.and_then(|mut to_result| {
+                            let cc_result =
+                                self.create_key_selection_widget(false, &HeaderName::CC, context)?;
+                            to_result.merge(cc_result);
+                            Ok(to_result)
                         });
                     }
+                    if !self.form.values()[HeaderName::BCC.as_str()]
+                        .as_str()
+                        .is_empty()
+                    {
+                        result = result.and_then(|mut to_result| {
+                            let bcc_result =
+                                self.create_key_selection_widget(false, &HeaderName::BCC, context)?;
+                            to_result.merge(bcc_result);
+                            Ok(to_result)
+                        });
+                    }
+                    if !self.form.values()[HeaderName::FROM.as_str()]
+                        .as_str()
+                        .is_empty()
+                    {
+                        result = result.and_then(|mut to_result| {
+                            let from_result = self.create_key_selection_widget(
+                                false,
+                                &HeaderName::FROM,
+                                context,
+                            )?;
+                            to_result.merge(from_result);
+                            Ok(to_result)
+                        });
+                    }
+                    match result.map(Into::into) {
+                        Ok(widget) => {
+                            self.gpg_state.encrypt_mail = Some(ActionFlag::from(true));
+                            self.mode = ViewMode::SelectKey(true, widget);
+                        }
+                        Err(err) => {
+                            context.replies.push_back(UIEvent::Notification {
+                                title: Some("Could not list keys.".into()),
+                                source: None,
+                                body: format!("libgpgme error: {err}").into(),
+                                kind: Some(NotificationType::Error(
+                                    melib::error::ErrorKind::External,
+                                )),
+                            });
+                        }
+                    }
+                    self.set_dirty(true);
                 }
-                self.set_dirty(true);
                 return true;
             }
             UIEvent::Input(ref key)
@@ -1863,10 +2012,25 @@ impl Component for Composer {
                     account_settings!(context[self.account_hash].composing.wrap_header_preamble)
                         .clone(),
                 );
+                let filename = format!(
+                    "{date}_{subject}_{to}_{in_reply_to}",
+                    date = self.draft.headers.get(HeaderName::DATE).unwrap_or_default(),
+                    subject = self
+                        .draft
+                        .headers
+                        .get(HeaderName::SUBJECT)
+                        .unwrap_or_default(),
+                    to = self.draft.headers.get(HeaderName::TO).unwrap_or_default(),
+                    in_reply_to = self
+                        .draft
+                        .headers
+                        .get(HeaderName::IN_REPLY_TO)
+                        .unwrap_or_default()
+                );
 
                 let f = match File::create_temp_file(
                     self.draft.to_edit_string().as_bytes(),
-                    None,
+                    sanitize_filename(filename).as_deref(),
                     None,
                     Some("eml"),
                     true,
@@ -1989,8 +2153,8 @@ impl Component for Composer {
                 self.set_dirty(true);
                 return true;
             }
-            UIEvent::Action(ref a) => match a {
-                Action::Compose(ComposeAction::AddAttachmentPipe(ref command)) => {
+            UIEvent::Action(Action::Tab(ComposerAction(ref a))) => match a {
+                ComposerTabAction::AddAttachmentPipe(ref command) => {
                     if command.is_empty() {
                         context.replies.push_back(UIEvent::Notification {
                             title: None,
@@ -2059,7 +2223,7 @@ impl Component for Composer {
                         }
                     }
                 }
-                Action::Compose(ComposeAction::AddAttachment(ref path)) => {
+                ComposerTabAction::AddAttachment(ref path) => {
                     let attachment = match melib::email::compose::attachment_from_file(path) {
                         Ok(a) => a,
                         Err(err) => {
@@ -2078,7 +2242,7 @@ impl Component for Composer {
                     self.set_dirty(true);
                     return true;
                 }
-                Action::Compose(ComposeAction::AddAttachmentFilePicker(ref command)) => {
+                ComposerTabAction::AddAttachmentFilePicker(ref command) => {
                     let command = if let Some(cmd) =
                         command
                             .as_ref()
@@ -2106,14 +2270,16 @@ impl Component for Composer {
                     match Command::new("sh")
                         .args(["-c", command])
                         .stdin(Stdio::inherit())
-                        .stdout(Stdio::inherit())
+                        .stdout(Stdio::piped())
                         .stderr(Stdio::piped())
                         .spawn()
-                        .and_then(|child| Ok(child.wait_with_output()?.stderr))
+                        .and_then(|child| Ok(child.wait_with_output()?.stdout))
                     {
-                        Ok(stderr) => {
-                            log::trace!("stderr: {}", &String::from_utf8_lossy(&stderr));
-                            for path in stderr.split(|c| [b'\0', b'\t', b'\n'].contains(c)) {
+                        Ok(stdout) => {
+                            for path in stdout
+                                .split(|c| [b'\0', b'\t', b'\n'].contains(c))
+                                .filter(|p| !p.trim().is_empty())
+                            {
                                 match melib::email::compose::attachment_from_file(
                                     &String::from_utf8_lossy(path).as_ref(),
                                 ) {
@@ -2161,7 +2327,7 @@ impl Component for Composer {
                     self.set_dirty(true);
                     return true;
                 }
-                Action::Compose(ComposeAction::RemoveAttachment(idx)) => {
+                ComposerTabAction::RemoveAttachment(idx) => {
                     if *idx + 1 > self.draft.attachments().len() {
                         context.replies.push_back(UIEvent::StatusEvent(
                             StatusEvent::DisplayMessage(
@@ -2180,7 +2346,7 @@ impl Component for Composer {
                     self.set_dirty(true);
                     return true;
                 }
-                Action::Compose(ComposeAction::SaveDraft) => {
+                ComposerTabAction::SaveDraft => {
                     save_draft(
                         self.draft.clone().finalise().unwrap().as_bytes(),
                         context,
@@ -2191,8 +2357,15 @@ impl Component for Composer {
                     self.set_dirty(true);
                     return true;
                 }
+                ComposerTabAction::DiscardDraft => {
+                    context
+                        .replies
+                        .push_back(UIEvent::Action(Tab(Kill(self.id))));
+                    self.set_dirty(true);
+                    return true;
+                }
                 #[cfg(feature = "gpgme")]
-                Action::Compose(ComposeAction::ToggleSign) => {
+                ComposerTabAction::ToggleSign => {
                     let is_true = self
                         .gpg_state
                         .sign_mail
@@ -2203,7 +2376,7 @@ impl Component for Composer {
                     return true;
                 }
                 #[cfg(feature = "gpgme")]
-                Action::Compose(ComposeAction::ToggleEncrypt) => {
+                ComposerTabAction::ToggleEncrypt => {
                     let is_true = self
                         .gpg_state
                         .encrypt_mail
@@ -2213,7 +2386,6 @@ impl Component for Composer {
                     self.set_dirty(true);
                     return true;
                 }
-                _ => {}
             },
             UIEvent::Input(ref key)
                 if context
@@ -2264,7 +2436,7 @@ impl Component for Composer {
                 widget.is_dirty() || self.pager.is_dirty() || self.form.is_dirty()
             }
             #[cfg(feature = "gpgme")]
-            ViewMode::SelectEncryptKey(_, ref widget) => {
+            ViewMode::SelectKey(_, ref widget) => {
                 widget.is_dirty() || self.pager.is_dirty() || self.form.is_dirty()
             }
             ViewMode::Send(ref widget) => {
@@ -2288,7 +2460,7 @@ impl Component for Composer {
                 widget.set_dirty(value);
             }
             #[cfg(feature = "gpgme")]
-            ViewMode::SelectEncryptKey(_, ref mut widget) => {
+            ViewMode::SelectKey(_, ref mut widget) => {
                 widget.set_dirty(value);
             }
             ViewMode::Send(ref mut widget) => {
@@ -2489,7 +2661,7 @@ pub fn send_draft(
         }
     }
     let bytes = draft.finalise().unwrap();
-    let send_mail = account_settings!(context[account_hash].composing.send_mail).clone();
+    let send_mail = account_settings!(context[account_hash].send_mail).clone();
     let ret =
         context.accounts[&account_hash].send(bytes.clone(), send_mail, complete_in_background);
     save_draft(bytes.as_bytes(), context, mailbox_type, flags, account_hash);
@@ -2544,16 +2716,7 @@ pub fn send_draft_async(
     let format_flowed = *account_settings!(context[account_hash].composing.format_flowed);
     let event_sender = context.main_loop_handler.sender.clone();
     #[cfg(feature = "gpgme")]
-    #[allow(clippy::type_complexity)]
-    let mut filters_stack: Vec<
-        Box<
-            dyn FnOnce(
-                    AttachmentBuilder,
-                )
-                    -> Pin<Box<dyn Future<Output = Result<AttachmentBuilder>> + Send>>
-                + Send,
-        >,
-    > = vec![];
+    let mut filters_stack: Vec<AttachmentFilterBox> = vec![];
     #[cfg(feature = "gpgme")]
     if gpg_state.sign_mail.unwrap_or(ActionFlag::False).is_true()
         && !gpg_state
@@ -2562,6 +2725,10 @@ pub fn send_draft_async(
             .is_true()
     {
         filters_stack.push(Box::new(crate::mail::pgp::sign_filter(
+            (account_settings!(context[account_hash].pgp.auto_sign).is_true()
+                && gpg_state.sign_keys.is_empty())
+            .then(|| account_settings!(context[account_hash].pgp.sign_key).clone())
+            .flatten(),
             gpg_state.sign_keys,
         )?));
     } else if gpg_state
@@ -2570,24 +2737,43 @@ pub fn send_draft_async(
         .is_true()
     {
         filters_stack.push(Box::new(crate::mail::pgp::encrypt_filter(
-            if gpg_state.sign_mail.unwrap_or(ActionFlag::False).is_true() {
-                Some(gpg_state.sign_keys.clone())
-            } else {
-                None
-            },
+            gpg_state.encrypt_for_self.then_some(()).map_or_else(
+                || Ok(None),
+                |()| {
+                    draft.headers().get(HeaderName::FROM).map_or_else(
+                        || Ok(None),
+                        |s| Some(melib::Address::try_from(s)).transpose(),
+                    )
+                },
+            )?,
+            (gpg_state.sign_mail.unwrap_or(ActionFlag::False).is_true()
+                && gpg_state.sign_keys.is_empty())
+            .then(|| account_settings!(context[account_hash].pgp.sign_key).clone())
+            .flatten(),
+            gpg_state
+                .sign_mail
+                .unwrap_or(ActionFlag::False)
+                .is_true()
+                .then(|| gpg_state.sign_keys.clone()),
+            gpg_state
+                .encrypt_keys
+                .is_empty()
+                .then(|| account_settings!(context[account_hash].pgp.encrypt_key).clone())
+                .flatten(),
             gpg_state.encrypt_keys,
         )?));
     }
-    let send_mail = account_settings!(context[account_hash].composing.send_mail).clone();
+    let send_mail = account_settings!(context[account_hash].send_mail).clone();
     let send_cb = context.accounts[&account_hash].send_async(send_mail);
     let mut content_type = ContentType::default();
-    if format_flowed {
-        if let ContentType::Text {
+    if let (
+        true,
+        ContentType::Text {
             ref mut parameters, ..
-        } = content_type
-        {
-            parameters.push((b"format".to_vec(), b"flowed".to_vec()));
-        }
+        },
+    ) = (format_flowed, &mut content_type)
+    {
+        parameters.push((b"format".to_vec(), b"flowed".to_vec()));
     }
     let mut body: AttachmentBuilder = Attachment::new(
         content_type,

meli/src/mail/compose/edit_attachments.rs

@@ -32,7 +32,7 @@ pub enum EditAttachmentCursor {
 pub enum EditAttachmentMode {
     Overview,
     Edit {
-        inner: Box<FormWidget<FormButtonActions>>,
+        inner: Box<FormWidget<FormButtonAction>>,
         no: usize,
     },
 }
@@ -42,7 +42,7 @@ pub struct EditAttachments {
     /// For shortcut setting retrieval.
     pub account_hash: Option<AccountHash>,
     pub mode: EditAttachmentMode,
-    pub buttons: ButtonWidget<FormButtonActions>,
+    pub buttons: ButtonWidget<FormButtonAction>,
     pub cursor: EditAttachmentCursor,
     pub dirty: bool,
     pub id: ComponentId,
@@ -50,8 +50,8 @@ pub struct EditAttachments {
 
 impl EditAttachments {
     pub fn new(account_hash: Option<AccountHash>) -> Self {
-        //ButtonWidget::new(("Add".into(), FormButtonActions::Other("add")));
-        let mut buttons = ButtonWidget::new(("Go Back".into(), FormButtonActions::Cancel));
+        //ButtonWidget::new(("Add".into(), FormButtonAction::Other("add")));
+        let mut buttons = ButtonWidget::new(("Go Back".into(), FormButtonAction::Cancel));
         buttons.set_focus(true);
         buttons.set_cursor(1);
         Self {
@@ -70,7 +70,7 @@ impl EditAttachmentsRefMut<'_, '_> {
         &self,
         no: usize,
         context: &Context,
-    ) -> Option<Box<FormWidget<FormButtonActions>>> {
+    ) -> Option<Box<FormWidget<FormButtonAction>>> {
         if no >= self.draft.attachments().len() {
             return None;
         }
@@ -79,7 +79,7 @@ impl EditAttachmentsRefMut<'_, '_> {
         let shortcuts = self.shortcuts(context);
 
         let mut ret = FormWidget::new(
-            ("Save".into(), FormButtonActions::Accept),
+            ("Save".into(), FormButtonAction::Accept),
             /* cursor_up_shortcut */
             shortcuts
                 .get(Shortcuts::COMPOSING)
@@ -92,8 +92,8 @@ impl EditAttachmentsRefMut<'_, '_> {
                 .unwrap_or_else(|| context.settings.shortcuts.composing.scroll_down.clone()),
         );
 
-        ret.add_button(("Reset".into(), FormButtonActions::Reset));
-        ret.add_button(("Cancel".into(), FormButtonActions::Cancel));
+        ret.add_button(("Reset".into(), FormButtonAction::Reset));
+        ret.add_button(("Cancel".into(), FormButtonAction::Cancel));
         ret.push(("Filename".into(), filename.unwrap_or_default().to_string()));
         ret.push(("Mime type".into(), mime_type.to_string()));
         Some(Box::new(ret))
@@ -198,10 +198,10 @@ impl Component for EditAttachmentsRefMut<'_, '_> {
         {
             if inner.process_event(event, context) {
                 match inner.buttons_result() {
-                    Some(FormButtonActions::Accept) | Some(FormButtonActions::Cancel) => {
+                    Some(FormButtonAction::Accept) | Some(FormButtonAction::Cancel) => {
                         self.inner.mode = EditAttachmentMode::Overview;
                     }
-                    Some(FormButtonActions::Reset) => {
+                    Some(FormButtonAction::Reset) => {
                         let no = *no;
                         if let Some(inner) = self.new_edit_widget(no, context) {
                             self.inner.mode = EditAttachmentMode::Edit { inner, no };

meli/src/mail/compose/gpg.rs

@@ -21,15 +21,94 @@
 
 use super::*;
 
+type KeylistJoinHandle = JoinHandle<Result<Vec<melib::gpgme::Key>>>;
+
 #[derive(Debug)]
-pub enum KeySelection {
-    LoadingKeys {
-        handle: JoinHandle<Result<Vec<melib::gpgme::Key>>>,
-        progress_spinner: ProgressSpinner,
+pub struct KeySelectionLoading {
+    handles: (KeylistJoinHandle, Vec<KeylistJoinHandle>),
+    progress_spinner: ProgressSpinner,
+    secret: bool,
+    local: bool,
+    patterns: (String, Vec<String>),
+    allow_remote_lookup: ActionFlag,
+}
+
+impl KeySelectionLoading {
+    pub fn new(
         secret: bool,
         local: bool,
-        pattern: String,
+        patterns: (String, Vec<String>),
         allow_remote_lookup: ActionFlag,
+        context: &Context,
+    ) -> Result<Self> {
+        use melib::gpgme::{self, *};
+        let mut ctx = gpgme::Context::new()?;
+        if local {
+            ctx.set_auto_key_locate(LocateKey::LOCAL)?;
+        } else {
+            ctx.set_auto_key_locate(LocateKey::WKD | LocateKey::LOCAL)?;
+        }
+        let (pattern, other_patterns) = patterns;
+        let main_job = ctx.keylist(secret, Some(pattern.clone()))?;
+        let main_handle = context.main_loop_handler.job_executor.spawn(
+            "gpg::keylist".into(),
+            main_job,
+            IsAsync::Blocking,
+        );
+        let other_handles = other_patterns
+            .iter()
+            .map(|pattern| {
+                let job = ctx.keylist(secret, Some(pattern.clone()))?;
+                Ok(context.main_loop_handler.job_executor.spawn(
+                    "gpg::keylist".into(),
+                    job,
+                    IsAsync::Blocking,
+                ))
+            })
+            .collect::<Result<Vec<KeylistJoinHandle>>>()?;
+        let mut progress_spinner = ProgressSpinner::new(8, context);
+        progress_spinner.start();
+        Ok(Self {
+            handles: (main_handle, other_handles),
+            secret,
+            local,
+            patterns: (pattern, other_patterns),
+            allow_remote_lookup,
+            progress_spinner,
+        })
+    }
+
+    pub fn merge(&mut self, rhs: Self) {
+        let Self {
+            handles: (_, ref mut other_handles),
+            secret: _,
+            local: _,
+            patterns: (_, ref mut other_patterns),
+            allow_remote_lookup: _,
+            progress_spinner: _,
+        } = self;
+        let Self {
+            handles: (rhs_handle, rhs_other_handles),
+            patterns: (rhs_pattern, rhs_other_patterns),
+            secret: _,
+            local: _,
+            allow_remote_lookup: _,
+            progress_spinner: _,
+        } = rhs;
+        other_handles.push(rhs_handle);
+        other_handles.extend(rhs_other_handles);
+        other_patterns.push(rhs_pattern);
+        other_patterns.extend(rhs_other_patterns);
+    }
+}
+
+#[derive(Debug)]
+pub enum KeySelection {
+    Loading {
+        inner: KeySelectionLoading,
+        /// Accumulate results from intermediate results (i.e. not the main
+        /// pattern)
+        keys_accumulator: Vec<melib::gpgme::Key>,
     },
     Error {
         id: ComponentId,
@@ -41,51 +120,31 @@ pub enum KeySelection {
     },
 }
 
+impl From<KeySelectionLoading> for KeySelection {
+    fn from(inner: KeySelectionLoading) -> Self {
+        Self::Loading {
+            inner,
+            keys_accumulator: vec![],
+        }
+    }
+}
+
 impl std::fmt::Display for KeySelection {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "select pgp keys")
     }
 }
 
-impl KeySelection {
-    pub fn new(
-        secret: bool,
-        local: bool,
-        pattern: String,
-        allow_remote_lookup: ActionFlag,
-        context: &Context,
-    ) -> Result<Self> {
-        use melib::gpgme::*;
-        let mut ctx = Context::new()?;
-        if local {
-            ctx.set_auto_key_locate(LocateKey::LOCAL)?;
-        } else {
-            ctx.set_auto_key_locate(LocateKey::WKD | LocateKey::LOCAL)?;
-        }
-        let job = ctx.keylist(secret, Some(pattern.clone()))?;
-        let handle = context
-            .main_loop_handler
-            .job_executor
-            .spawn_specialized("gpg::keylist".into(), job);
-        let mut progress_spinner = ProgressSpinner::new(8, context);
-        progress_spinner.start();
-        Ok(Self::LoadingKeys {
-            handle,
-            secret,
-            local,
-            pattern,
-            allow_remote_lookup,
-            progress_spinner,
-        })
-    }
-}
-
 impl Component for KeySelection {
     fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
         match self {
-            Self::LoadingKeys {
-                ref mut progress_spinner,
-                ..
+            Self::Loading {
+                inner:
+                    KeySelectionLoading {
+                        ref mut progress_spinner,
+                        ..
+                    },
+                keys_accumulator: _,
             } => progress_spinner.draw(grid, area.center_inside((2, 2)), context),
             Self::Error { ref err, .. } => {
                 let theme_default = crate::conf::value(context, "theme_default");
@@ -105,16 +164,31 @@ impl Component for KeySelection {
 
     fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
         match self {
-            Self::LoadingKeys {
-                ref mut progress_spinner,
-                ref mut handle,
-                secret,
-                local,
-                ref mut pattern,
-                allow_remote_lookup,
-                ..
+            Self::Loading {
+                inner:
+                    KeySelectionLoading {
+                        ref mut progress_spinner,
+                        handles: (ref mut main_handle, ref mut other_handles),
+                        secret,
+                        local,
+                        patterns: (ref mut pattern, ref mut other_patterns),
+                        allow_remote_lookup,
+                        ..
+                    },
+                ref mut keys_accumulator,
             } => match event {
-                UIEvent::StatusEvent(StatusEvent::JobFinished(ref id)) if *id == handle.job_id => {
+                UIEvent::StatusEvent(StatusEvent::JobFinished(ref id))
+                    if *id == main_handle.job_id
+                        || other_handles.iter().any(|h| h.job_id == *id) =>
+                {
+                    let mut main_handle_ref = &mut (*main_handle);
+                    let is_main = *id == main_handle_ref.job_id;
+                    let other_handle_ref_opt = other_handles.iter_mut().find(|h| h.job_id == *id);
+                    let handle = if is_main {
+                        &mut main_handle_ref
+                    } else {
+                        &mut (*other_handle_ref_opt.unwrap())
+                    };
                     match handle.chan.try_recv() {
                         Err(_) => { /* Job was canceled */ }
                         Ok(None) => { /* something happened, perhaps a worker thread panicked */ }
@@ -122,15 +196,19 @@ impl Component for KeySelection {
                             if keys.is_empty() {
                                 let id = progress_spinner.id();
                                 if allow_remote_lookup.is_true() {
-                                    match Self::new(
+                                    match KeySelectionLoading::new(
                                         *secret,
                                         *local,
-                                        std::mem::take(pattern),
+                                        (std::mem::take(pattern), std::mem::take(other_patterns)),
                                         *allow_remote_lookup,
                                         context,
                                     ) {
-                                        Ok(w) => {
-                                            *self = w;
+                                        Ok(inner) => {
+                                            let keys_accumulator = std::mem::take(keys_accumulator);
+                                            *self = Self::Loading {
+                                                inner,
+                                                keys_accumulator,
+                                            };
                                         }
                                         Err(err) => *self = Self::Error { err, id },
                                     }
@@ -144,7 +222,11 @@ impl Component for KeySelection {
                                     }
                                 } else {
                                     *self = Self::Error {
-                                        err: Error::new(format!("No keys found for {}.", pattern)),
+                                        err: if pattern.is_empty() {
+                                            Error::new("No keys found.")
+                                        } else {
+                                            Error::new(format!("No keys found for {}.", pattern))
+                                        },
                                         id,
                                     }
                                 }
@@ -152,42 +234,74 @@ impl Component for KeySelection {
                                     context.replies.push_back(UIEvent::StatusEvent(
                                         StatusEvent::DisplayMessage(err.to_string()),
                                     ));
-                                    let res: Option<melib::gpgme::Key> = None;
+                                    // Even in case of error, we should send a FinishedUIDialog
+                                    // event so that the component parent knows we're done.
+                                    let res: Option<Vec<melib::gpgme::Key>> = None;
                                     context
                                         .replies
                                         .push_back(UIEvent::FinishedUIDialog(id, Box::new(res)));
                                 }
                                 return false;
                             }
-                            let mut widget = Box::new(UIDialog::new(
-                                "select key",
-                                keys.iter()
-                                    .map(|k| {
-                                        (
-                                            k.clone(),
-                                            if let Some(primary_uid) = k.primary_uid() {
-                                                format!("{} {}", k.fingerprint(), primary_uid)
-                                            } else {
-                                                k.fingerprint().to_string()
-                                            },
-                                        )
-                                    })
-                                    .collect::<Vec<(melib::gpgme::Key, String)>>(),
-                                true,
-                                Some(Box::new(
-                                    move |id: ComponentId, results: &[melib::gpgme::Key]| {
-                                        Some(UIEvent::FinishedUIDialog(
-                                            id,
-                                            Box::new(results.first().cloned()),
-                                        ))
-                                    },
-                                )),
-                                context,
-                            ));
-                            widget.set_dirty(true);
-                            *self = Self::Loaded { widget, keys };
+                            keys_accumulator.extend(keys);
+                            if !is_main {
+                                other_handles.retain(|h| h.job_id != *id);
+                                return false;
+                            }
+                            if other_handles.is_empty() {
+                                // We are done with all Futures, so finally transition into the
+                                // "show the user the list of keys to select" state.
+                                let mut widget = Box::new(UIDialog::new(
+                                    "select key",
+                                    keys_accumulator
+                                        .iter()
+                                        .map(|k| {
+                                            (
+                                                k.clone(),
+                                                if let Some(primary_uid) = k.primary_uid() {
+                                                    format!("{} {}", k.fingerprint(), primary_uid)
+                                                } else {
+                                                    k.fingerprint().to_string()
+                                                },
+                                            )
+                                        })
+                                        .collect::<Vec<(melib::gpgme::Key, String)>>(),
+                                    false,
+                                    Some(Box::new(
+                                        move |id: ComponentId, results: &[melib::gpgme::Key]| {
+                                            Some(UIEvent::FinishedUIDialog(
+                                                id,
+                                                Box::new(if results.is_empty() {
+                                                    None
+                                                } else {
+                                                    Some(results.to_vec())
+                                                }),
+                                            ))
+                                        },
+                                    )),
+                                    context,
+                                ));
+                                widget.set_dirty(true);
+                                *self = Self::Loaded {
+                                    widget,
+                                    keys: std::mem::take(keys_accumulator),
+                                };
+                            } else {
+                                // Main handle has finished, replace it with some other one from
+                                // other_handles.
+                                *main_handle = other_handles.remove(0);
+                            }
                         }
                         Ok(Some(Err(err))) => {
+                            context.replies.push_back(UIEvent::StatusEvent(
+                                StatusEvent::DisplayMessage(err.to_string()),
+                            ));
+                            // Even in case of error, we should send a FinishedUIDialog
+                            // event so that the component parent knows we're done.
+                            let res: Option<Vec<melib::gpgme::Key>> = None;
+                            context
+                                .replies
+                                .push_back(UIEvent::FinishedUIDialog(self.id(), Box::new(res)));
                             *self = Self::Error {
                                 err,
                                 id: ComponentId::default(),
@@ -205,9 +319,13 @@ impl Component for KeySelection {
 
     fn is_dirty(&self) -> bool {
         match self {
-            Self::LoadingKeys {
-                ref progress_spinner,
-                ..
+            Self::Loading {
+                inner:
+                    KeySelectionLoading {
+                        ref progress_spinner,
+                        ..
+                    },
+                keys_accumulator: _,
             } => progress_spinner.is_dirty(),
             Self::Error { .. } => true,
             Self::Loaded { ref widget, .. } => widget.is_dirty(),
@@ -216,9 +334,13 @@ impl Component for KeySelection {
 
     fn set_dirty(&mut self, value: bool) {
         match self {
-            Self::LoadingKeys {
-                ref mut progress_spinner,
-                ..
+            Self::Loading {
+                inner:
+                    KeySelectionLoading {
+                        ref mut progress_spinner,
+                        ..
+                    },
+                keys_accumulator: _,
             } => progress_spinner.set_dirty(value),
             Self::Error { .. } => {}
             Self::Loaded { ref mut widget, .. } => widget.set_dirty(value),
@@ -229,16 +351,20 @@ impl Component for KeySelection {
 
     fn shortcuts(&self, context: &Context) -> ShortcutMaps {
         match self {
-            Self::LoadingKeys { .. } | Self::Error { .. } => ShortcutMaps::default(),
+            Self::Loading { .. } | Self::Error { .. } => ShortcutMaps::default(),
             Self::Loaded { ref widget, .. } => widget.shortcuts(context),
         }
     }
 
     fn id(&self) -> ComponentId {
         match self {
-            Self::LoadingKeys {
-                ref progress_spinner,
-                ..
+            Self::Loading {
+                inner:
+                    KeySelectionLoading {
+                        ref progress_spinner,
+                        ..
+                    },
+                keys_accumulator: _,
             } => progress_spinner.id(),
             Self::Error { ref id, .. } => *id,
             Self::Loaded { ref widget, .. } => widget.id(),
@@ -266,3 +392,183 @@ impl Default for GpgComposeState {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{borrow::Cow, ffi::CString, thread::sleep, time::Duration};
+
+    use melib::gpgme::{EngineInfo, LocateKey, Protocol};
+    use rusty_fork::rusty_fork_test;
+
+    use super::*;
+
+    impl KeySelection {
+        fn new_mock(
+            secret: bool,
+            local: bool,
+            pattern: String,
+            allow_remote_lookup: ActionFlag,
+            context: &Context,
+            ctx: &mut melib::gpgme::Context,
+        ) -> Result<Self> {
+            if local {
+                ctx.set_auto_key_locate(LocateKey::LOCAL)?;
+            } else {
+                ctx.set_auto_key_locate(LocateKey::WKD | LocateKey::LOCAL)?;
+            }
+            let job = ctx.keylist(secret, Some(pattern.clone()))?;
+            let handle = context.main_loop_handler.job_executor.spawn(
+                "gpg::keylist".into(),
+                job,
+                IsAsync::Blocking,
+            );
+            let mut progress_spinner = ProgressSpinner::new(8, context);
+            progress_spinner.start();
+            Ok(Self::Loading {
+                inner: KeySelectionLoading {
+                    handles: (handle, vec![]),
+                    secret,
+                    local,
+                    patterns: (pattern, vec![]),
+                    allow_remote_lookup,
+                    progress_spinner,
+                },
+                keys_accumulator: vec![],
+            })
+        }
+    }
+
+    const PUBKEY: &[u8]=b"-----BEGIN PGP PUBLIC KEY BLOCK-----\r\nVersion: GnuPG v2.1.0-gitb3c71eb (GNU/Linux)\r\n\r\nmQGiBDo41NoRBADSfQazKGYf8nokq6zUKH/6INtV6MypSzSGmX2XErnARkIIPPYj\r\ncQRQ8zCbGV7ZU2ezVbzhFLUSJveE8PZUzzCrLp1O2NSyBTRcR5HVSXW95nJfY8eV\r\npOvZRAKul0BVLh81kYTsrfzaaCjh9VWNP26LoeN2r+PjZyktXe7gM3C4SwCgoTxK\r\nWUVi9HoT2HCLY7p7oig5hEcEALdCJal0UYomX3nJapIVLVZg3vkidr1RICYMb2vz\r\n58i17h8sxEtobD1vdIKNejulntaRAXs4n0tDYD9z7pRlwG1CLz1R9WxYzeOOqUDr\r\nfnVXdmU8L/oVWABat8v1V7QQhjMMf+41fuzVwDMMGqjVPLhu4X6wp3A8uyM3YDnQ\r\nVMN1A/4n2G5gHoOvjqxn8Ch5tBAdMGfO8gH4RjQOwzm2R1wPQss/yzUN1+tlMZGX\r\nK2dQ2FCWC/hDUSNaEQRlI15wxxBNZ2RQwlzE2A8v113DpvyzOtv0QO95gJ1teCXC\r\n7j/BN9asgHaBBc39JLO/TcpuI7Hf8PQ5VcP2F0UE3lczGhXbLLRESm9lIFJhbmRv\r\nbSBIYWNrZXIgKHRlc3Qga2V5IHdpdGggcGFzc3BocmFzZSAiYWJjIikgPGpvZUBl\r\neGFtcGxlLmNvbT6IYgQTEQIAIgUCTbdXqQIbIwYLCQgHAwIGFQgCCQoLBBYCAwEC\r\nHgECF4AACgkQr4IkT5zZ/VUcCACfQvSPi//9/gBv8SVrK6O4DiyD+jAAn3LEnfF1\r\n4j6MjwlqXTqol2VgQn1yuQENBDo41N0QBACedJb7Qhm50JSPe1V+rSZKLHT5nc3l\r\n2k1n7//wNsJkgDW2J7snIRjGtSzeNxMPh+hVzFidzAf3sbOlARQoBrMPPKpnJWtm\r\n6LEDf2lSwO36l0/bo6qDRmiFRJoHWytTJEjxVwRclVt4bXqHfNw9FKhZZbcKeAN2\r\noHgmBVSU6edHdwADBQP+OGAkEG4PcfSb8x191R+wkV/q2hA5Ay9z289Dx2rO28CO\r\n4M2fhhcjSmgr6x0DsrkfESCiG47UGJ169eu+QqJwk3HiF4crGN9rE5+VelBVFtrd\r\nMWkX2rPLGQWyw8iCZKbeH8g/ujmkaLovSmalzDcLe4v1xSLaP7Fnfzit0iIGZAGI\r\nRgQYEQIABgUCOjjU3QAKCRCvgiRPnNn9VVSaAJ9+rj1lIQnRl20i8Rom2Hwbe3re\r\n9QCfSYFnkZUw0yKF2DfCfqrDzdGAsbaIRgQYEQIABgUCOjjU3gAKCRCvgiRPnNn9\r\nVe4iAJ9FrGMlFR7s+GWf1scTeeyrthKrPQCfSpc/Yps72aFI7hPfyIa9MuerVZ4=\r\n=QRit\r\n-----END PGP PUBLIC KEY BLOCK-----\r\n";
+
+    rusty_fork_test! {
+    #[test]
+    fn test_gpg_verify_sig() {
+        let tempdir = tempfile::tempdir().unwrap();
+        {
+            #[allow(unused_unsafe)]
+            unsafe {
+                std::env::set_var("GNUPGHOME", tempdir.path());
+            }
+
+            #[allow(unused_unsafe)]
+            unsafe {
+                std::env::set_var("GPG_AGENT_INFO", "");
+            }
+        }
+
+        let mut ctx = Context::new_mock(&tempdir);
+        let mut gpgme_ctx = match melib::gpgme::Context::new() {
+            Ok(v) => v,
+            Err(err) if err.kind.is_not_found() => {
+                eprintln!("INFO: libgpgme could not be loaded, skipping this test.");
+                return;
+            }
+            err => err.unwrap(),
+        };
+        let current_engine_info = gpgme_ctx.engine_info().unwrap();
+        let prev_len = current_engine_info.len();
+        let Some(EngineInfo {
+            file_name: Some(engine_file_name),
+            ..
+        }) = current_engine_info
+            .into_iter()
+            .find(|eng| eng.protocol == Protocol::OpenPGP)
+        else {
+            eprintln!("WARN: No openpg protocol engine returned from gpgme.");
+            return;
+        };
+        gpgme_ctx
+            .set_engine_info(
+                Protocol::OpenPGP,
+                Some(Cow::Owned(CString::new(engine_file_name).unwrap())),
+                Some(Cow::Owned(
+                    CString::new(tempdir.path().display().to_string()).unwrap(),
+                )),
+            )
+            .unwrap();
+        let new_engine_info = gpgme_ctx.engine_info().unwrap();
+        assert_eq!(
+            new_engine_info.len(),
+            prev_len,
+            "new_engine_info was expected to have {} entry/ies but has {}: {:#?}",
+            prev_len,
+            new_engine_info.len(),
+            new_engine_info
+        );
+        assert_eq!(
+            new_engine_info[0].home_dir,
+            Some(tempdir.path().display().to_string()),
+            "new_engine_info was expected to have temp dir as home_dir but has: {:#?}",
+            new_engine_info[0].home_dir
+        );
+        let mut pubkey_data = Some(gpgme_ctx.new_data_mem(PUBKEY).unwrap());
+        for _ in 0..2 {
+            let mut key_sel = KeySelection::new_mock(
+                false,
+                true,
+                "".to_string(),
+                false.into(),
+                &ctx,
+                &mut gpgme_ctx,
+            )
+            .unwrap();
+            let component_id = key_sel.id();
+
+            for _ in 0..2 {
+                sleep(Duration::from_secs(2));
+            }
+            while let Ok(ev) = ctx.receiver.try_recv() {
+                // if !matches!(ev, ThreadEvent::UIEvent(UIEvent::Timer(_))) {
+                //     dbg!(&ev);
+                // }
+                if let ThreadEvent::UIEvent(mut ev) = ev {
+                    key_sel.process_event(&mut ev, &mut ctx);
+                } else if let ThreadEvent::JobFinished(job_id) = ev {
+                    let mut ev = UIEvent::StatusEvent(StatusEvent::JobFinished(job_id));
+                    key_sel.process_event(&mut ev, &mut ctx);
+                }
+            }
+            if let Some(pubkey_data) = pubkey_data.take() {
+                assert!(
+                    matches!(
+                        key_sel,
+                        KeySelection::Error {
+                            ref id,
+                            ref err
+                        } if *id == component_id && err.to_string() == melib::Error::new("No keys found.").to_string(),
+                    ),
+                    "key_sel should have been an error but is: {:?}",
+                    key_sel
+                );
+                gpgme_ctx.import_key(pubkey_data).unwrap();
+            } else {
+                let assert_key = |key: &melib::gpgme::Key| {
+                    key.fingerprint() == "ADAB7FCC1F4DE2616ECFA402AF82244F9CD9FD55"
+                        && key.primary_uid()
+                            == Some(melib::Address::new(
+                                Some("Joe Random Hacker".into()),
+                                "joe@example.com".into(),
+                            ))
+                        && key.can_encrypt()
+                        && key.can_sign()
+                        && !key.secret()
+                        && !key.revoked()
+                        && !key.expired()
+                        && !key.invalid()
+                };
+                assert!(
+                    matches!(
+                        key_sel,
+                        KeySelection::Loaded {
+                            ref keys,
+                            widget: _,
+                        } if keys.len() == 1 && assert_key(&keys[0]),
+                    ),
+                    "key_sel should have been an error but is: {:?}",
+                    key_sel
+                );
+            }
+        }
+    }
+    }
+}

meli/src/mail/compose/hooks.rs

@@ -22,7 +22,7 @@
 //! Pre-submission hooks for draft validation and/or transformations.
 pub use std::borrow::Cow;
 
-use melib::email::headers::HeaderName;
+use melib::{email::headers::HeaderName, src_err_arc_wrap};
 
 use super::*;
 
@@ -102,11 +102,11 @@ impl Hook {
                     .stderr(Stdio::piped())
                     .spawn()
                     .map_err(|err| -> Error {
-                        format!(
+                        Error::new(format!(
                             "could not execute `{command}`. Check if its binary is in PATH or if \
-                             the command is valid. Original error: {err}"
-                        )
-                        .into()
+                             the command is valid."
+                        ))
+                        .set_source(Some(src_err_arc_wrap! {err}))
                     })?;
                 let mut stdin = child
                     .stdin
@@ -121,7 +121,8 @@ impl Hook {
                     });
                 });
                 let output = child.wait_with_output().map_err(|err| -> Error {
-                    format!("failed to wait on hook child {name_}: {err}").into()
+                    Error::new(format!("failed to wait on hook child {name_}"))
+                        .set_source(Some(src_err_arc_wrap! {err}))
                 })?;
                 let stdout = String::from_utf8_lossy(&output.stdout);
                 let stderr = String::from_utf8_lossy(&output.stderr);
@@ -187,7 +188,10 @@ fn important_header_warn(_ctx: &mut Context, draft: &mut Draft) -> Result<()> {
     for hdr in [HeaderName::FROM, HeaderName::TO] {
         match draft.headers.get(&hdr).map(melib::Address::list_try_from) {
             Some(Ok(_)) => {}
-            Some(Err(err)) => return Err(format!("{hdr} header value is invalid ({err}).").into()),
+            Some(Err(err)) => {
+                return Err(Error::new(format!("{hdr} header value is invalid"))
+                    .set_source(Some(src_err_arc_wrap! {err})))
+            }
             None => return Err(format!("{hdr} header is missing and should be present.").into()),
         }
     }
@@ -198,8 +202,11 @@ fn important_header_warn(_ctx: &mut Context, draft: &mut Draft) -> Result<()> {
             .get(HeaderName::DATE)
             .map(melib::utils::datetime::rfc822_to_timestamp)
         {
-            Some(Err(err)) => return Err(format!("Date header value is invalid ({err}).").into()),
-            Some(Ok(0)) => return Err("Date header value is invalid.".into()),
+            Some(Err(err)) => {
+                return Err(Error::new("Date header value is invalid.")
+                    .set_source(Some(src_err_arc_wrap! {err})))
+            }
+            Some(Ok(0)) => return Err(Error::new("Date header value is invalid.")),
             _ => {}
         }
     }
@@ -211,7 +218,8 @@ fn important_header_warn(_ctx: &mut Context, draft: &mut Draft) -> Result<()> {
             .filter(|v| !v.trim().is_empty())
             .map(melib::Address::list_try_from)
         {
-            return Err(format!("{hdr} header value is invalid ({err}).").into());
+            return Err(Error::new(format!("{hdr} header value is invalid"))
+                .set_source(Some(src_err_arc_wrap! {err})));
         }
     }
     Ok(())
@@ -310,8 +318,9 @@ mod tests {
         let err_msg = hook(&mut ctx, &mut draft).unwrap_err().to_string();
         assert_eq!(
             err_msg,
-            "From header value is invalid (Parsing error. In input: \"...\",\nError: Alternative, \
-             Many1, Alternative, atom(): starts with whitespace or empty).",
+            "From header value is invalid\nCaused by:\n[2] Parsing error. In input: \
+             \"...\",\nError: Alternative, Many1, Alternative, atom(): starts with whitespace or \
+             empty",
             "HEADERWARN should complain about From value being empty: {}",
             err_msg
         );
@@ -321,8 +330,9 @@ mod tests {
         let err_msg = hook(&mut ctx, &mut draft).unwrap_err().to_string();
         assert_eq!(
             err_msg,
-            "To header value is invalid (Parsing error. In input: \"...\",\nError: Alternative, \
-             Many1, Alternative, atom(): starts with whitespace or empty).",
+            "To header value is invalid\nCaused by:\n[2] Parsing error. In input: \
+             \"...\",\nError: Alternative, Many1, Alternative, atom(): starts with whitespace or \
+             empty",
             "HEADERWARN should complain about To value being empty: {}",
             err_msg
         );
@@ -350,8 +360,8 @@ mod tests {
         let err_msg = hook(&mut ctx, &mut draft).unwrap_err().to_string();
         assert_eq!(
             err_msg,
-            "From header value is invalid (Parsing error. In input: \"user \
-             user@example.com>...\",\nError: Alternative, Tag).",
+            "From header value is invalid\nCaused by:\n[2] Parsing error. In input: \"user \
+             user@example.com>...\",\nError: Alternative, Tag",
             "HEADERWARN should complain about From value being invalid: {}",
             err_msg
         );

meli/src/mail/listing.rs

@@ -20,6 +20,7 @@
  */
 
 use std::{
+    borrow::Cow,
     collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     convert::TryFrom,
     fs::File,
@@ -40,6 +41,7 @@ use super::*;
 use crate::{
     accounts::{JobRequest, MailboxStatus},
     components::ExtendShortcutsMaps,
+    jobs::IsAsync,
 };
 
 pub const DEFAULT_ATTACHMENT_FLAG: &str = concat!("📎", emoji_text_presentation_selector!());
@@ -111,9 +113,8 @@ impl<T> RowsState<T> {
             self.env_order.insert(env_hash, index);
             self.all_envelopes.insert(env_hash);
         }
-        if !self.all_threads.contains(&thread) {
+        if self.all_threads.insert(thread) {
             self.thread_order.insert(thread, index);
-            self.all_threads.insert(thread);
             self.thread_to_env.insert(thread, env_hashes);
         } else {
             self.thread_to_env
@@ -249,6 +250,17 @@ pub enum Modifier {
     Intersection,
 }
 
+impl std::fmt::Display for Modifier {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::SymmetricDifference => write!(fmt, "><"),
+            Self::Union => write!(fmt, "+"),
+            Self::Difference => write!(fmt, "-"),
+            Self::Intersection => write!(fmt, "*"),
+        }
+    }
+}
+
 #[derive(Debug, Default)]
 /// Save theme colors to avoid looking them up again and again from settings
 pub struct ColorCache {
@@ -672,6 +684,51 @@ pub trait MailListingTrait: ListingTrait {
                         ));
                     }
                 }
+                ListingAction::SendToTrash => {
+                    use melib::backends::SpecialUsageMailbox;
+
+                    let Some(trash_mbox_hash) = account
+                        .special_use_mailbox(SpecialUsageMailbox::Trash)
+                        .or_else(|| account.special_use_mailbox(SpecialUsageMailbox::Junk))
+                    else {
+                        context.replies.push_back(UIEvent::StatusEvent(
+                            StatusEvent::DisplayMessage(
+                                "Cannot send mail to trash because no Trash folder is configured."
+                                    .to_string(),
+                            ),
+                        ));
+                        return;
+                    };
+                    let job = account.backend.write().unwrap().copy_messages(
+                        env_hashes,
+                        mailbox_hash,
+                        trash_mbox_hash,
+                        /* move? */ true,
+                    );
+                    match job {
+                        Err(err) => {
+                            context.replies.push_back(UIEvent::StatusEvent(
+                                StatusEvent::DisplayMessage(err.to_string()),
+                            ));
+                        }
+                        Ok(fut) => {
+                            let handle = account.main_loop_handler.job_executor.spawn(
+                                "move-to-trash".into(),
+                                fut,
+                                account.is_async(),
+                            );
+                            account.insert_job(
+                                handle.job_id,
+                                JobRequest::Generic {
+                                    name: "taking out the trash".into(),
+                                    handle,
+                                    on_finish: None,
+                                    log_level: LogLevel::INFO,
+                                },
+                            );
+                        }
+                    }
+                }
                 ListingAction::Delete => {
                     let job = account
                         .backend
@@ -685,10 +742,11 @@ pub trait MailListingTrait: ListingTrait {
                             ));
                         }
                         Ok(fut) => {
-                            let handle = account
-                                .main_loop_handler
-                                .job_executor
-                                .spawn_specialized("delete".into(), fut);
+                            let handle = account.main_loop_handler.job_executor.spawn(
+                                "delete".into(),
+                                fut,
+                                account.is_async(),
+                            );
                             account.insert_job(
                                 handle.job_id,
                                 JobRequest::DeleteMessages { env_hashes, handle },
@@ -713,10 +771,11 @@ pub trait MailListingTrait: ListingTrait {
                             ));
                         }
                         Ok(fut) => {
-                            let handle = account
-                                .main_loop_handler
-                                .job_executor
-                                .spawn_specialized("copy_to_mailbox".into(), fut);
+                            let handle = account.main_loop_handler.job_executor.spawn(
+                                "copy-to-mailbox".into(),
+                                fut,
+                                account.is_async(),
+                            );
                             account.insert_job(
                                 handle.job_id,
                                 JobRequest::Generic {
@@ -753,10 +812,11 @@ pub trait MailListingTrait: ListingTrait {
                             ));
                         }
                         Ok(fut) => {
-                            let handle = account
-                                .main_loop_handler
-                                .job_executor
-                                .spawn_specialized("move_to_mailbox".into(), fut);
+                            let handle = account.main_loop_handler.job_executor.spawn(
+                                "move-to-mailbox".into(),
+                                fut,
+                                account.is_async(),
+                            );
                             account.insert_job(
                                 handle.job_id,
                                 JobRequest::Generic {
@@ -795,7 +855,7 @@ pub trait MailListingTrait: ListingTrait {
                                     .collect();
                                 if path.is_dir() {
                                     if envs.len() == 1 {
-                                        path.push(format!("{}.mbox", envs[0].message_id_raw()));
+                                        path.push(format!("{}.mbox", envs[0].message_id()));
                                     } else {
                                         let now = datetime::timestamp_to_string(
                                             datetime::now(),
@@ -805,12 +865,18 @@ pub trait MailListingTrait: ListingTrait {
                                         path.push(format!(
                                             "{}-{}-{}_envelopes.mbox",
                                             now,
-                                            envs[0].message_id_raw(),
+                                            envs[0].message_id(),
                                             envs.len(),
                                         ));
                                     }
                                 }
-                                let mut file = BufWriter::new(File::create(&path)?);
+                                let mut file = BufWriter::new(
+                                    File::options()
+                                        .read(true)
+                                        .write(true)
+                                        .create_new(true)
+                                        .open(&path)?,
+                                );
                                 let mut iter = envs.iter().zip(bytes);
                                 let tags_lck = collection.tag_index.read().unwrap();
                                 if let Some((env, ref bytes)) = iter.next() {
@@ -854,10 +920,11 @@ pub trait MailListingTrait: ListingTrait {
                             let _ = sender.send(r);
                             Ok(())
                         });
-                    let handle = account
-                        .main_loop_handler
-                        .job_executor
-                        .spawn_blocking("exporting mbox".into(), fut);
+                    let handle = account.main_loop_handler.job_executor.spawn(
+                        "exporting-mbox".into(),
+                        fut,
+                        IsAsync::Blocking,
+                    );
                     account.insert_job(
                         handle.job_id,
                         JobRequest::Generic {
@@ -916,7 +983,8 @@ pub trait MailListingTrait: ListingTrait {
     }
 
     fn row_updates(&mut self) -> &mut SmallVec<[EnvelopeHash; 8]>;
-    fn selection(&mut self) -> &mut HashMap<EnvelopeHash, bool>;
+    fn selection(&self) -> &HashMap<EnvelopeHash, bool>;
+    fn selection_mut(&mut self) -> &mut HashMap<EnvelopeHash, bool>;
     fn get_focused_items(&self, _context: &Context) -> SmallVec<[EnvelopeHash; 8]>;
     fn redraw_threads_list(
         &mut self,
@@ -943,16 +1011,11 @@ pub trait ListingTrait: Component {
     fn prev_entry(&mut self, context: &mut Context);
     fn draw_list(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context);
     fn highlight_line(&mut self, grid: &mut CellBuffer, area: Area, idx: usize, context: &Context);
-    fn filter(
-        &mut self,
-        _filter_term: String,
-        _results: SmallVec<[EnvelopeHash; 512]>,
-        _context: &Context,
-    ) {
-    }
+    fn filter(&mut self, _filter_term: String, _results: Vec<EnvelopeHash>, _context: &Context) {}
     fn unfocused(&self) -> bool;
     fn view_area(&self) -> Option<Area>;
     fn set_modifier_active(&mut self, _new_val: bool);
+    fn modifier_active(&self) -> bool;
     fn set_modifier_command(&mut self, _new_val: Option<Modifier>);
     fn modifier_command(&self) -> Option<Modifier>;
     fn set_movement(&mut self, mvm: PageMovement);
@@ -1106,11 +1169,13 @@ pub struct Listing {
     show_menu_scrollbar: ShowMenuScrollbar,
     startup_checks_rate: RateLimit,
     id: ComponentId,
+    // Configurable settings
     theme_default: ThemeAttribute,
-
     sidebar_divider: char,
     sidebar_divider_theme: ThemeAttribute,
-
+    mail_view_divider: char,
+    mail_view_divider_theme: ThemeAttribute,
+    // State
     menu_visibility: bool,
     cmd_buf: String,
     /// This is the width of the right container to the entire width.
@@ -1198,6 +1263,22 @@ impl Component for Listing {
                 if self.component.unfocused() {
                     if let Some(ref mut view) = self.view {
                         view.draw(grid, self.component.view_area().unwrap_or(area), context);
+                        if let Some(view_area) = self.component.view_area() {
+                            if view_area != area {
+                                let divider_area =
+                                    area.nth_col(area.width() - view_area.width() - 1);
+                                for row in grid.bounds_iter(divider_area) {
+                                    for c in row {
+                                        grid[c]
+                                            .set_ch(self.mail_view_divider)
+                                            .set_fg(self.mail_view_divider_theme.fg)
+                                            .set_bg(self.mail_view_divider_theme.bg)
+                                            .set_attrs(self.mail_view_divider_theme.attrs);
+                                    }
+                                }
+                                context.dirty_areas.push_back(divider_area);
+                            }
+                        }
                     }
                 }
             }
@@ -1223,6 +1304,22 @@ impl Component for Listing {
                 if self.component.unfocused() {
                     if let Some(ref mut view) = self.view {
                         view.draw(grid, self.component.view_area().unwrap_or(area), context);
+                        if let Some(view_area) = self.component.view_area() {
+                            if view_area != area {
+                                let divider_area =
+                                    area.nth_col(area.width() - view_area.width() - 1);
+                                for row in grid.bounds_iter(divider_area) {
+                                    for c in row {
+                                        grid[c]
+                                            .set_ch(self.mail_view_divider)
+                                            .set_fg(self.mail_view_divider_theme.fg)
+                                            .set_bg(self.mail_view_divider_theme.bg)
+                                            .set_attrs(self.mail_view_divider_theme.attrs);
+                                    }
+                                }
+                                context.dirty_areas.push_back(divider_area);
+                            }
+                        }
                     }
                 }
             }
@@ -1238,6 +1335,9 @@ impl Component for Listing {
                 self.sidebar_divider =
                     *account_settings!(context[account_hash].listing.sidebar_divider);
                 self.sidebar_divider_theme = conf::value(context, "mail.sidebar_divider");
+                self.mail_view_divider =
+                    *account_settings!(context[account_hash].listing.mail_view_divider);
+                self.mail_view_divider_theme = conf::value(context, "mail.view.divider");
                 self.menu.grid_mut().empty();
                 self.set_dirty(true);
             }
@@ -1775,7 +1875,8 @@ impl Component for Listing {
                         | Action::Listing(a @ ListingAction::MoveToOtherAccount(_, _))
                         | Action::Listing(a @ ListingAction::ExportMbox(_, _))
                         | Action::Listing(a @ ListingAction::Flag(_))
-                        | Action::Listing(a @ ListingAction::Tag(_)) => {
+                        | Action::Listing(a @ ListingAction::Tag(_))
+                        | Action::Listing(a @ ListingAction::SendToTrash) => {
                             let focused = self.component.get_focused_items(context);
                             self.component.perform_action(context, focused, a);
                             let should_be_unselected: bool = matches!(
@@ -1783,9 +1884,10 @@ impl Component for Listing {
                                 ListingAction::Delete
                                     | ListingAction::MoveTo(_)
                                     | ListingAction::MoveToOtherAccount(_, _)
+                                    | ListingAction::SendToTrash
                             );
                             let mut row_updates: SmallVec<[EnvelopeHash; 8]> = SmallVec::new();
-                            for (k, v) in self.component.selection().iter_mut() {
+                            for (k, v) in self.component.selection_mut().iter_mut() {
                                 if *v {
                                     *v = !should_be_unselected;
                                     row_updates.push(*k);
@@ -1799,7 +1901,7 @@ impl Component for Listing {
                             let row_updates: SmallVec<[EnvelopeHash; 8]> =
                                 self.component.get_focused_items(context);
                             for h in &row_updates {
-                                if let Some(val) = self.component.selection().get_mut(h) {
+                                if let Some(val) = self.component.selection_mut().get_mut(h) {
                                     *val = false;
                                 }
                             }
@@ -1958,12 +2060,26 @@ impl Component for Listing {
                     UIEvent::Input(ref key)
                         if shortcut!(key == shortcuts[Shortcuts::GENERAL]["home_page"]) =>
                     {
+                        if !self.cmd_buf.is_empty() {
+                            self.cmd_buf.clear();
+                            self.component.set_modifier_active(false);
+                            context
+                                .replies
+                                .push_back(UIEvent::StatusEvent(StatusEvent::BufClear));
+                        }
                         self.component.set_movement(PageMovement::Home);
                         return true;
                     }
                     UIEvent::Input(ref key)
                         if shortcut!(key == shortcuts[Shortcuts::GENERAL]["end_page"]) =>
                     {
+                        if !self.cmd_buf.is_empty() {
+                            self.cmd_buf.clear();
+                            self.component.set_modifier_active(false);
+                            context
+                                .replies
+                                .push_back(UIEvent::StatusEvent(StatusEvent::BufClear));
+                        }
                         self.component.set_movement(PageMovement::End);
                         return true;
                     }
@@ -1986,6 +2102,15 @@ impl Component for Listing {
                             return true;
                         }
                     }
+                    UIEvent::Input(ref key)
+                        if shortcut!(key == shortcuts[Shortcuts::LISTING]["send_to_trash"]) =>
+                    {
+                        let mut event =
+                            UIEvent::Action(Action::Listing(ListingAction::SendToTrash));
+                        if self.process_event(&mut event, context) {
+                            return true;
+                        }
+                    }
                     UIEvent::Input(ref key)
                         if shortcut!(key == shortcuts[Shortcuts::LISTING]["refresh"]) =>
                     {
@@ -2009,18 +2134,36 @@ impl Component for Listing {
                             && shortcut!(
                                 key == shortcuts[Shortcuts::LISTING]["union_modifier"]
                             )
-                            && self.component.modifier_command().is_some() =>
+                            && self.component.modifier_active() =>
                     {
                         self.component.set_modifier_command(Some(Modifier::Union));
+                        context
+                            .replies
+                            .push_back(UIEvent::StatusEvent(StatusEvent::BufSet(
+                                if let Some(modf) = self.component.modifier_command() {
+                                    format!("{} {}", modf, self.cmd_buf)
+                                } else {
+                                    self.cmd_buf.clone()
+                                },
+                            )));
                         return true;
                     }
                     UIEvent::Input(ref key)
                         if !self.component.unfocused()
                             && shortcut!(key == shortcuts[Shortcuts::LISTING]["diff_modifier"])
-                            && self.component.modifier_command().is_some() =>
+                            && self.component.modifier_active() =>
                     {
                         self.component
                             .set_modifier_command(Some(Modifier::Difference));
+                        context
+                            .replies
+                            .push_back(UIEvent::StatusEvent(StatusEvent::BufSet(
+                                if let Some(modf) = self.component.modifier_command() {
+                                    format!("{} {}", modf, self.cmd_buf)
+                                } else {
+                                    self.cmd_buf.clone()
+                                },
+                            )));
                         return true;
                     }
                     UIEvent::Input(ref key)
@@ -2028,10 +2171,19 @@ impl Component for Listing {
                             && shortcut!(
                                 key == shortcuts[Shortcuts::LISTING]["intersection_modifier"]
                             )
-                            && self.component.modifier_command().is_some() =>
+                            && self.component.modifier_active() =>
                     {
                         self.component
                             .set_modifier_command(Some(Modifier::Intersection));
+                        context
+                            .replies
+                            .push_back(UIEvent::StatusEvent(StatusEvent::BufSet(
+                                if let Some(modf) = self.component.modifier_command() {
+                                    format!("{} {}", modf, self.cmd_buf)
+                                } else {
+                                    self.cmd_buf.clone()
+                                },
+                            )));
                         return true;
                     }
                     UIEvent::Input(ref key)
@@ -2050,14 +2202,14 @@ impl Component for Listing {
                         self.component.prev_entry(context);
                         return true;
                     }
-                    UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Alt(''))
+                    UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1b'))
                         if !self.component.unfocused() =>
                     {
                         // Clear selection.
                         let row_updates: SmallVec<[EnvelopeHash; 8]> =
                             self.component.get_focused_items(context);
                         for h in &row_updates {
-                            if let Some(val) = self.component.selection().get_mut(h) {
+                            if let Some(val) = self.component.selection_mut().get_mut(h) {
                                 *val = false;
                             }
                         }
@@ -2065,7 +2217,7 @@ impl Component for Listing {
                         self.component.set_dirty(true);
                         return true;
                     }
-                    UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Alt(''))
+                    UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1b'))
                         if !self.cmd_buf.is_empty() =>
                     {
                         self.cmd_buf.clear();
@@ -2081,7 +2233,11 @@ impl Component for Listing {
                         context
                             .replies
                             .push_back(UIEvent::StatusEvent(StatusEvent::BufSet(
-                                self.cmd_buf.clone(),
+                                if let Some(modf) = self.component.modifier_command() {
+                                    format!("{} {}", modf, self.cmd_buf)
+                                } else {
+                                    self.cmd_buf.clone()
+                                },
                             )));
                         return true;
                     }
@@ -2585,11 +2741,17 @@ impl Component for Listing {
                 context
                     .replies
                     .push_back(UIEvent::StatusEvent(StatusEvent::BufSet(
-                        self.cmd_buf.clone(),
+                        if let Some(modf) = self.component.modifier_command() {
+                            format!("{} {}", modf, self.cmd_buf)
+                        } else {
+                            self.cmd_buf.clone()
+                        },
                     )));
                 return true;
             }
-            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Alt('')) if !self.cmd_buf.is_empty() => {
+            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1b'))
+                if !self.cmd_buf.is_empty() =>
+            {
                 self.cmd_buf.clear();
                 self.component.set_modifier_active(false);
                 context
@@ -2603,7 +2765,11 @@ impl Component for Listing {
                 context
                     .replies
                     .push_back(UIEvent::StatusEvent(StatusEvent::BufSet(
-                        self.cmd_buf.clone(),
+                        if let Some(modf) = self.component.modifier_command() {
+                            format!("{} {}", modf, self.cmd_buf)
+                        } else {
+                            self.cmd_buf.clone()
+                        },
                     )));
                 return true;
             }
@@ -2673,7 +2839,7 @@ impl Component for Listing {
         });
         let mut config_map = context.settings.shortcuts.listing.key_values();
         if self.focus != ListingFocus::Menu {
-            config_map.remove("open_mailbox");
+            config_map.shift_remove("open_mailbox");
         }
         map.insert(Shortcuts::LISTING, config_map);
 
@@ -2805,7 +2971,7 @@ impl Listing {
                 account: 0,
                 menu: MenuEntryCursor::Mailbox(0),
             },
-            menu: Screen::<Virtual>::new(),
+            menu: Screen::<Virtual>::new(crate::conf::value(context, "mail.sidebar")),
             menu_scrollbar_show_timer: context.main_loop_handler.job_executor.clone().create_timer(
                 std::time::Duration::from_secs(0),
                 std::time::Duration::from_millis(1200),
@@ -2822,6 +2988,10 @@ impl Listing {
                 context[first_account_hash].listing.sidebar_divider
             ),
             sidebar_divider_theme: conf::value(context, "mail.sidebar_divider"),
+            mail_view_divider: *account_settings!(
+                context[first_account_hash].listing.mail_view_divider
+            ),
+            mail_view_divider_theme: conf::value(context, "mail.view.divider"),
             menu_visibility: !*account_settings!(
                 context[first_account_hash].listing.hide_sidebar_on_launch
             ),
@@ -2964,7 +3134,65 @@ impl Listing {
         let must_highlight_account: bool = cursor.account == self.accounts[aidx].index;
 
         let mut lines: Vec<Line> = Vec::new();
+        let mail_sidebar_highlighted_value =
+            crate::conf::value(context, "mail.sidebar_highlighted");
+        let mail_sidebar_highlighted_account_name_value =
+            crate::conf::value(context, "mail.sidebar_highlighted_account_name");
+        let mail_sidebar_account_name_value =
+            crate::conf::value(context, "mail.sidebar_account_name");
+        let mail_sidebar_highlighted_index_value =
+            crate::conf::value(context, "mail.sidebar_highlighted_index");
+        let mail_sidebar_highlighted_unread_count_value =
+            crate::conf::value(context, "mail.sidebar_highlighted_unread_count");
+        let mail_sidebar_highlighted_account_value =
+            crate::conf::value(context, "mail.sidebar_highlighted_account");
+        let mail_sidebar_highlighted_account_index_value =
+            crate::conf::value(context, "mail.sidebar_highlighted_account_index");
+        let mail_sidebar_highlighted_account_unread_count_value =
+            crate::conf::value(context, "mail.sidebar_highlighted_account_unread_count");
+        let mail_sidebar_value = crate::conf::value(context, "mail.sidebar");
+        let mail_sidebar_index_value = crate::conf::value(context, "mail.sidebar_index");
+        let mail_sidebar_unread_count_value =
+            crate::conf::value(context, "mail.sidebar_unread_count");
+        let has_sibling_str: &str = account_settings!(
+            context[self.accounts[aidx].hash]
+                .listing
+                .sidebar_mailbox_tree_has_sibling
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(" ");
+        let no_sibling_str: &str = account_settings!(
+            context[self.accounts[aidx].hash]
+                .listing
+                .sidebar_mailbox_tree_no_sibling
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(" ");
 
+        let has_sibling_leaf_str: &str = account_settings!(
+            context[self.accounts[aidx].hash]
+                .listing
+                .sidebar_mailbox_tree_has_sibling_leaf
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(" ");
+
+        let no_sibling_leaf_str: &str = account_settings!(
+            context[self.accounts[aidx].hash]
+                .listing
+                .sidebar_mailbox_tree_no_sibling_leaf
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(" ");
+        let relative_menu_indices = *account_settings!(
+            context[self.accounts[aidx].hash]
+                .listing
+                .relative_menu_indices
+        );
         for (
             i,
             &MailboxMenuEntry {
@@ -3010,18 +3238,17 @@ impl Listing {
 
         let account_attrs = if must_highlight_account {
             if cursor.menu == MenuEntryCursor::Status {
-                let mut v = crate::conf::value(context, "mail.sidebar_highlighted");
+                let mut v = mail_sidebar_highlighted_value;
                 if !context.settings.terminal.use_color() {
                     v.attrs |= Attr::REVERSE;
                 }
                 v
             } else {
-                crate::conf::value(context, "mail.sidebar_highlighted_account_name")
+                mail_sidebar_highlighted_account_name_value
             }
         } else {
-            crate::conf::value(context, "mail.sidebar_account_name")
+            mail_sidebar_account_name_value
         };
-
         // Print account name first
         self.menu.grid_mut().write_string(
             &self.accounts[aidx].name,
@@ -3046,7 +3273,6 @@ impl Listing {
             );
             return 0;
         }
-        area = self.menu.area().skip_rows(account_y);
 
         let lines_len = lines.len();
         let mut idx = 0;
@@ -3096,9 +3322,9 @@ impl Listing {
                     _ => false,
                 } {
                     let mut ret = (
-                        crate::conf::value(context, "mail.sidebar_highlighted"),
-                        crate::conf::value(context, "mail.sidebar_highlighted_index"),
-                        crate::conf::value(context, "mail.sidebar_highlighted_unread_count"),
+                        mail_sidebar_highlighted_value,
+                        mail_sidebar_highlighted_index_value,
+                        mail_sidebar_highlighted_unread_count_value,
                     );
 
                     if !context.settings.terminal.use_color() {
@@ -3109,21 +3335,19 @@ impl Listing {
                     ret
                 } else {
                     (
-                        crate::conf::value(context, "mail.sidebar_highlighted_account"),
-                        crate::conf::value(context, "mail.sidebar_highlighted_account_index"),
-                        crate::conf::value(
-                            context,
-                            "mail.sidebar_highlighted_account_unread_count",
-                        ),
+                        mail_sidebar_highlighted_account_value,
+                        mail_sidebar_highlighted_account_index_value,
+                        mail_sidebar_highlighted_account_unread_count_value,
                     )
                 }
             } else {
                 (
-                    crate::conf::value(context, "mail.sidebar"),
-                    crate::conf::value(context, "mail.sidebar_index"),
-                    crate::conf::value(context, "mail.sidebar_unread_count"),
+                    mail_sidebar_value,
+                    mail_sidebar_index_value,
+                    mail_sidebar_unread_count_value,
                 )
             };
+            self.menu.grid_mut().change_theme(area.nth_row(y + 1), att);
 
             // Calculate how many columns the mailbox index tags should occupy with right
             // alignment, eg.
@@ -3142,48 +3366,8 @@ impl Listing {
                 ctr
             };
 
-            let has_sibling_str: &str = account_settings!(
-                context[self.accounts[aidx].hash]
-                    .listing
-                    .sidebar_mailbox_tree_has_sibling
-            )
-            .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or(" ");
-            let no_sibling_str: &str = account_settings!(
-                context[self.accounts[aidx].hash]
-                    .listing
-                    .sidebar_mailbox_tree_no_sibling
-            )
-            .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or(" ");
-
-            let has_sibling_leaf_str: &str = account_settings!(
-                context[self.accounts[aidx].hash]
-                    .listing
-                    .sidebar_mailbox_tree_has_sibling_leaf
-            )
-            .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or(" ");
-
-            let no_sibling_leaf_str: &str = account_settings!(
-                context[self.accounts[aidx].hash]
-                    .listing
-                    .sidebar_mailbox_tree_no_sibling_leaf
-            )
-            .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or(" ");
-
             let (x, _) = self.menu.grid_mut().write_string(
-                &if *account_settings!(
-                    context[self.accounts[aidx].hash]
-                        .listing
-                        .relative_menu_indices
-                ) && must_highlight_account
-                {
+                &if relative_menu_indices && must_highlight_account {
                     format!(
                         "{:>width$}",
                         (l.inc - cursor.menu).abs(),
@@ -3250,19 +3434,21 @@ impl Listing {
                     None,
                 )
                 .0
-                + x;
+                + x
+                + 1;
             area = self.menu.area().skip_rows(account_y);
 
             // Unread message count
-            let count_string = match (l.count, l.collapsed_count) {
-                (None, None) => " ...".to_string(),
-                (Some(0), None) => String::new(),
-                (Some(0), Some(0)) | (None, Some(0)) => " v".to_string(),
-                (Some(0), Some(coll)) => format!(" ({}) v", coll),
-                (Some(c), Some(0)) => format!(" {} v", c),
-                (Some(c), Some(coll)) => format!(" {} ({}) v", c, coll),
-                (Some(c), None) => format!(" {}", c),
-                (None, Some(coll)) => format!(" ({}) v", coll),
+            let count_string: Cow<'static, str> = match (l.count, l.collapsed_count) {
+                (None, None) if context.settings.terminal.ascii_drawing => "...".into(),
+                (None, None) => "…".into(),
+                (Some(0), None) => "".into(),
+                (Some(0), Some(0)) | (None, Some(0)) => "v".into(),
+                (Some(0), Some(coll)) => format!("({}) v", coll).into(),
+                (Some(c), Some(0)) => format!("{} v", c).into(),
+                (Some(c), Some(coll)) => format!("{} ({}) v", c, coll).into(),
+                (Some(c), None) => format!("{}", c).into(),
+                (None, Some(coll)) => format!("({}) v", coll).into(),
             };
 
             let skip_cols = {
@@ -3275,7 +3461,7 @@ impl Listing {
                 }
             };
             let (x, _) = self.menu.grid_mut().write_string(
-                &count_string,
+                count_string.as_ref(),
                 unread_count_att.fg,
                 unread_count_att.bg,
                 unread_count_att.attrs
@@ -3455,7 +3641,7 @@ impl Listing {
                 let coordinates = self.component.coordinates();
                 std::mem::replace(
                     &mut self.component,
-                    Plain(PlainListing::new(self.id, coordinates)),
+                    Plain(PlainListing::new(self.id, coordinates, context)),
                 )
             }
             IndexStyle::Threaded => {
@@ -3475,7 +3661,7 @@ impl Listing {
                 let coordinates = self.component.coordinates();
                 std::mem::replace(
                     &mut self.component,
-                    Compact(CompactListing::new(self.id, coordinates)),
+                    Compact(CompactListing::new(self.id, coordinates, context)),
                 )
             }
             IndexStyle::Conversations => {

meli/src/mail/listing/compact.rs

@@ -143,9 +143,9 @@ pub struct CompactListing {
     rows: RowsState<(ThreadHash, EnvelopeHash)>,
 
     #[allow(clippy::type_complexity)]
-    search_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    search_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     #[allow(clippy::type_complexity)]
-    select_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    select_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     filter_term: String,
     filtered_selection: Vec<ThreadHash>,
     filtered_order: HashMap<ThreadHash, usize>,
@@ -169,14 +169,17 @@ impl MailListingTrait for CompactListing {
         &mut self.rows.row_updates
     }
 
-    fn selection(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
+    fn selection(&self) -> &HashMap<EnvelopeHash, bool> {
+        &self.rows.selection
+    }
+
+    fn selection_mut(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
         &mut self.rows.selection
     }
 
     fn get_focused_items(&self, _context: &Context) -> SmallVec<[EnvelopeHash; 8]> {
         let is_selection_empty = !self
-            .rows
-            .selection
+            .selection()
             .values()
             .cloned()
             .any(std::convert::identity);
@@ -184,8 +187,7 @@ impl MailListingTrait for CompactListing {
         let sel_iter = if !is_selection_empty {
             cursor_iter = None;
             Some(
-                self.rows
-                    .selection
+                self.selection()
                     .iter()
                     .filter(|(_, v)| **v)
                     .map(|(k, _)| *k),
@@ -227,7 +229,7 @@ impl MailListingTrait for CompactListing {
 
         // Get mailbox as a reference.
         //
-        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1) {
+        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1, true) {
             Ok(()) => {}
             Err(_) => {
                 self.length = 0;
@@ -334,6 +336,16 @@ impl MailListingTrait for CompactListing {
                 .highlight_self
         )
         .is_true();
+        let highlight_self_colwidth: usize = mailbox_settings!(
+            context[self.cursor_pos.0][&self.cursor_pos.1]
+                .listing
+                .highlight_self_flag
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(super::DEFAULT_HIGHLIGHT_SELF_FLAG)
+        .grapheme_width();
+        let mut itoa_buffer = itoa::Buffer::new();
         'items_for_loop: for thread in items {
             let thread_node = &threads.thread_nodes()[&threads.thread_ref(thread).root()];
             let root_env_hash = if let Some(h) = thread_node.message().or_else(|| {
@@ -441,9 +453,13 @@ impl MailListingTrait for CompactListing {
                 highlight_self,
                 thread,
             );
-            row_widths
-                .0
-                .push(digits_of_num!(self.length).try_into().unwrap_or(255));
+            row_widths.0.push(
+                itoa_buffer
+                    .format(self.length)
+                    .len()
+                    .try_into()
+                    .unwrap_or(255),
+            );
             /* date */
             row_widths.1.push(
                 entry_strings
@@ -461,9 +477,8 @@ impl MailListingTrait for CompactListing {
                     .unwrap_or(255),
             );
             row_widths.3.push(
-                entry_strings
-                    .flag
-                    .grapheme_width()
+                (entry_strings.flag.grapheme_width()
+                    + usize::from(entry_strings.highlight_self) * highlight_self_colwidth)
                     .try_into()
                     .unwrap_or(255),
             );
@@ -475,7 +490,8 @@ impl MailListingTrait for CompactListing {
             min_width.1 = min_width.1.max(entry_strings.date.grapheme_width()); /* date */
             min_width.2 = min_width.2.max(entry_strings.from.grapheme_width()); /* from */
             min_width.3 = min_width.3.max(
-                entry_strings.flag.grapheme_width() + usize::from(entry_strings.highlight_self),
+                entry_strings.flag.grapheme_width()
+                    + usize::from(entry_strings.highlight_self) * highlight_self_colwidth,
             );
             min_width.4 = min_width.4.max(
                 entry_strings.subject.grapheme_width() + 1 + entry_strings.tags.grapheme_width(),
@@ -494,7 +510,7 @@ impl MailListingTrait for CompactListing {
             self.length += 1;
         }
 
-        min_width.0 = digits_of_num!(self.length.saturating_sub(1));
+        min_width.0 = itoa_buffer.format(self.length.saturating_sub(1)).len();
 
         self.data_columns.elasticities[0].set_rigid();
         self.data_columns.elasticities[1].set_rigid();
@@ -748,16 +764,19 @@ impl ListingTrait for CompactListing {
         context.dirty_areas.push_back(area);
     }
 
-    fn filter(
-        &mut self,
-        filter_term: String,
-        results: SmallVec<[EnvelopeHash; 512]>,
-        context: &Context,
-    ) {
+    fn filter(&mut self, filter_term: String, results: Vec<EnvelopeHash>, context: &Context) {
+        if filter_term.is_empty() {
+            return;
+        }
+
         self.length = 0;
         self.filtered_selection.clear();
         self.filtered_order.clear();
         self.filter_term = filter_term;
+        self.rows.row_updates.clear();
+        for v in self.selection_mut().values_mut() {
+            *v = false;
+        }
 
         let account = &context.accounts[&self.cursor_pos.0];
         let threads = account.collection.get_threads(self.cursor_pos.1);
@@ -804,6 +823,10 @@ impl ListingTrait for CompactListing {
         !matches!(self.focus, Focus::None)
     }
 
+    fn modifier_active(&self) -> bool {
+        self.modifier_active
+    }
+
     fn set_modifier_active(&mut self, new_val: bool) {
         self.modifier_active = new_val;
     }
@@ -877,7 +900,12 @@ impl std::fmt::Display for CompactListing {
 }
 
 impl CompactListing {
-    pub fn new(parent: ComponentId, coordinates: (AccountHash, MailboxHash)) -> Box<Self> {
+    pub fn new(
+        parent: ComponentId,
+        coordinates: (AccountHash, MailboxHash),
+        context: &Context,
+    ) -> Box<Self> {
+        let color_cache = ColorCache::new(context, IndexStyle::Compact);
         Box::new(Self {
             cursor_pos: (AccountHash::default(), MailboxHash::default(), 0),
             new_cursor_pos: (coordinates.0, coordinates.1, 0),
@@ -891,12 +919,12 @@ impl CompactListing {
             filtered_selection: Vec::new(),
             filtered_order: HashMap::default(),
             focus: Focus::None,
-            data_columns: DataColumns::default(),
+            data_columns: DataColumns::new(color_cache.theme_default),
             rows_drawn: SegmentTree::default(),
             rows: RowsState::default(),
             dirty: true,
             force_draw: true,
-            color_cache: ColorCache::default(),
+            color_cache,
             movement: None,
             modifier_active: false,
             modifier_command: None,
@@ -986,8 +1014,7 @@ impl CompactListing {
             },
             flag: FlagString::new(
                 flags,
-                self.rows
-                    .selection
+                self.selection()
                     .get(&root_envelope.hash())
                     .cloned()
                     .unwrap_or(false),
@@ -997,7 +1024,7 @@ impl CompactListing {
                 context,
                 (self.cursor_pos.0, self.cursor_pos.1),
             ),
-            from: FromString(Address::display_name_slice(from)),
+            from: FromString(Address::display_name_slice(from, None)),
             tags: TagString(tags_string, colors),
             unseen: thread.unseen() > 0,
             highlight_self,
@@ -1140,6 +1167,7 @@ impl CompactListing {
         );
 
         let columns = &mut self.data_columns.columns;
+        let mut itoa_buffer = itoa::Buffer::new();
         for (idx, ((_thread_hash, root_env_hash), strings)) in self
             .rows
             .entries
@@ -1163,7 +1191,7 @@ impl CompactListing {
             let (x, _) = {
                 let area = columns[0].area().nth_row(idx);
                 columns[0].grid_mut().write_string(
-                    &idx.to_string(),
+                    itoa_buffer.format(idx),
                     row_attr.fg,
                     row_attr.bg,
                     row_attr.attrs,
@@ -1221,7 +1249,6 @@ impl CompactListing {
                     .set_attrs(row_attr.attrs)
                     .set_ch(' ');
             }
-            #[cfg(feature = "regexp")]
             {
                 for text_formatter in crate::conf::text_format_regexps(context, "listing.from") {
                     let t = columns[2].grid_mut().insert_tag(text_formatter.tag);
@@ -1280,7 +1307,6 @@ impl CompactListing {
                     None,
                     None,
                 ));
-                #[cfg(feature = "regexp")]
                 {
                     for text_formatter in
                         crate::conf::text_format_regexps(context, "listing.subject")
@@ -1343,7 +1369,7 @@ impl CompactListing {
     fn select(
         &mut self,
         search_term: &str,
-        results: Result<SmallVec<[EnvelopeHash; 512]>>,
+        results: Result<Vec<EnvelopeHash>>,
         context: &mut Context,
     ) {
         let account = &context.accounts[&self.cursor_pos.0];
@@ -1361,8 +1387,7 @@ impl CompactListing {
                     let thread =
                         threads.find_group(threads.thread_nodes[&env_thread_node_hash].group);
                     if self.rows.all_threads.contains(&thread) {
-                        self.rows
-                            .selection
+                        self.selection_mut()
                             .entry(env_hash)
                             .and_modify(|entry| *entry = true);
                     }
@@ -1387,7 +1412,7 @@ impl CompactListing {
     }
 
     fn draw_relative_numbers(
-        &mut self,
+        &self,
         grid: &mut CellBuffer,
         area: Area,
         top_idx: usize,
@@ -1794,17 +1819,22 @@ impl Component for CompactListing {
                     if !self.unfocused()
                         && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_entry"]) =>
                 {
-                    if self.modifier_active && self.modifier_command.is_none() {
-                        self.modifier_command = Some(Modifier::default());
-                    } else if let Some(thread_hash) =
-                        self.get_thread_under_cursor(self.cursor_pos.2)
-                    {
+                    if let Some(thread_hash) = self.get_thread_under_cursor(self.new_cursor_pos.2) {
                         self.rows
                             .update_selection_with_thread(thread_hash, |e| *e = !*e);
                         self.set_dirty(true);
                     }
                     return true;
                 }
+                UIEvent::Input(ref key)
+                    if !self.unfocused()
+                        && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_motion"]) =>
+                {
+                    if self.modifier_active && self.modifier_command.is_none() {
+                        self.modifier_command = Some(Modifier::default());
+                    }
+                    return true;
+                }
                 UIEvent::Action(ref action) => {
                     match action {
                         Action::Sort(field, order) if !self.unfocused() => {
@@ -1932,7 +1962,11 @@ impl Component for CompactListing {
                         let handle = context.accounts[&self.cursor_pos.0]
                             .main_loop_handler
                             .job_executor
-                            .spawn_specialized("search".into(), job);
+                            .spawn(
+                                "search".into(),
+                                job,
+                                context.accounts[&self.cursor_pos.0].is_async(),
+                            );
                         self.search_job = Some((filter_term.to_string(), handle));
                     }
                     Err(err) => {
@@ -1957,7 +1991,11 @@ impl Component for CompactListing {
                         let mut handle = context.accounts[&self.cursor_pos.0]
                             .main_loop_handler
                             .job_executor
-                            .spawn_specialized("select_by_search".into(), job);
+                            .spawn(
+                                "select-by-search".into(),
+                                job,
+                                context.accounts[&self.cursor_pos.0].is_async(),
+                            );
                         if let Ok(Some(search_result)) = try_recv_timeout!(&mut handle.chan) {
                             self.select(search_term, search_result, context);
                         } else {

meli/src/mail/listing/conversations.rs

@@ -118,7 +118,7 @@ pub struct ConversationsListing {
     error: std::result::Result<(), String>,
 
     #[allow(clippy::type_complexity)]
-    search_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    search_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     filter_term: String,
     filtered_selection: Vec<ThreadHash>,
     filtered_order: HashMap<ThreadHash, usize>,
@@ -142,7 +142,11 @@ impl MailListingTrait for ConversationsListing {
         &mut self.rows.row_updates
     }
 
-    fn selection(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
+    fn selection(&self) -> &HashMap<EnvelopeHash, bool> {
+        &self.rows.selection
+    }
+
+    fn selection_mut(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
         &mut self.rows.selection
     }
 
@@ -198,7 +202,7 @@ impl MailListingTrait for ConversationsListing {
 
         // Get mailbox as a reference.
         //
-        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1) {
+        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1, true) {
             Ok(()) => {}
             Err(_) => {
                 let message: String =
@@ -517,12 +521,7 @@ impl ListingTrait for ConversationsListing {
         context.dirty_areas.push_back(area);
     }
 
-    fn filter(
-        &mut self,
-        filter_term: String,
-        results: SmallVec<[EnvelopeHash; 512]>,
-        context: &Context,
-    ) {
+    fn filter(&mut self, filter_term: String, results: Vec<EnvelopeHash>, context: &Context) {
         if filter_term.is_empty() {
             return;
         }
@@ -578,6 +577,10 @@ impl ListingTrait for ConversationsListing {
         !matches!(self.focus, Focus::None)
     }
 
+    fn modifier_active(&self) -> bool {
+        self.modifier_active
+    }
+
     fn set_modifier_active(&mut self, new_val: bool) {
         self.modifier_active = new_val;
     }
@@ -770,7 +773,7 @@ impl ConversationsListing {
                 context,
                 (self.cursor_pos.0, self.cursor_pos.1),
             ),
-            from: FromString(Address::display_name_slice(from)),
+            from: FromString(Address::display_name_slice(from, None)),
             tags: TagString(tags_string, colors),
             unseen: thread.unseen() > 0,
             highlight_self: false,
@@ -1363,14 +1366,21 @@ impl Component for ConversationsListing {
                     if !self.unfocused()
                         && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_entry"]) =>
                 {
-                    if self.modifier_active && self.modifier_command.is_none() {
-                        self.modifier_command = Some(Modifier::default());
-                    } else if let Some(thread) = self.get_thread_under_cursor(self.cursor_pos.2) {
+                    if let Some(thread) = self.get_thread_under_cursor(self.new_cursor_pos.2) {
                         self.rows.update_selection_with_thread(thread, |e| *e = !*e);
                         self.set_dirty(true);
                     }
                     return true;
                 }
+                UIEvent::Input(ref key)
+                    if !self.unfocused()
+                        && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_motion"]) =>
+                {
+                    if self.modifier_active && self.modifier_command.is_none() {
+                        self.modifier_command = Some(Modifier::default());
+                    }
+                    return true;
+                }
                 UIEvent::EnvelopeRename(ref old_hash, ref new_hash) => {
                     let account = &context.accounts[&self.cursor_pos.0];
                     let threads = account.collection.get_threads(self.cursor_pos.1);
@@ -1480,7 +1490,11 @@ impl Component for ConversationsListing {
                             let handle = context.accounts[&self.cursor_pos.0]
                                 .main_loop_handler
                                 .job_executor
-                                .spawn_specialized("search".into(), job);
+                                .spawn(
+                                    "search".into(),
+                                    job,
+                                    context.accounts[&self.cursor_pos.0].is_async(),
+                                );
                             self.search_job = Some((filter_term.to_string(), handle));
                         }
                         Err(err) => {
@@ -1497,7 +1511,7 @@ impl Component for ConversationsListing {
                 }
                 _ => {}
             },
-            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char(''))
+            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1b'))
                 if !self.unfocused() && !&self.filter_term.is_empty() =>
             {
                 self.set_coordinates((self.new_cursor_pos.0, self.new_cursor_pos.1));

meli/src/mail/listing/offline.rs

@@ -39,7 +39,11 @@ impl MailListingTrait for OfflineListing {
         &mut self._row_updates
     }
 
-    fn selection(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
+    fn selection(&self) -> &HashMap<EnvelopeHash, bool> {
+        &self._selection
+    }
+
+    fn selection_mut(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
         &mut self._selection
     }
 
@@ -94,6 +98,10 @@ impl ListingTrait for OfflineListing {
         false
     }
 
+    fn modifier_active(&self) -> bool {
+        false
+    }
+
     fn set_modifier_active(&mut self, _: bool) {}
 
     fn set_modifier_command(&mut self, _: Option<Modifier>) {}

meli/src/mail/listing/plain.rs

@@ -140,9 +140,9 @@ pub struct PlainListing {
     data_columns: DataColumns<5>,
 
     #[allow(clippy::type_complexity)]
-    search_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    search_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     #[allow(clippy::type_complexity)]
-    select_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    select_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     filter_term: String,
     filtered_selection: Vec<EnvelopeHash>,
     filtered_order: HashMap<EnvelopeHash, usize>,
@@ -166,7 +166,11 @@ impl MailListingTrait for PlainListing {
         &mut self.rows.row_updates
     }
 
-    fn selection(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
+    fn selection(&self) -> &HashMap<EnvelopeHash, bool> {
+        &self.rows.selection
+    }
+
+    fn selection_mut(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
         &mut self.rows.selection
     }
 
@@ -211,7 +215,7 @@ impl MailListingTrait for PlainListing {
 
         // Get mailbox as a reference.
         //
-        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1) {
+        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1, true) {
             Ok(()) => {}
             Err(_) => {
                 self.length = 0;
@@ -498,12 +502,7 @@ impl ListingTrait for PlainListing {
         context.dirty_areas.push_back(area);
     }
 
-    fn filter(
-        &mut self,
-        filter_term: String,
-        results: SmallVec<[EnvelopeHash; 512]>,
-        context: &Context,
-    ) {
+    fn filter(&mut self, filter_term: String, results: Vec<EnvelopeHash>, context: &Context) {
         if filter_term.is_empty() {
             return;
         }
@@ -551,6 +550,10 @@ impl ListingTrait for PlainListing {
         !matches!(self.focus, Focus::None)
     }
 
+    fn modifier_active(&self) -> bool {
+        self.modifier_active
+    }
+
     fn set_modifier_active(&mut self, new_val: bool) {
         self.modifier_active = new_val;
     }
@@ -623,7 +626,12 @@ impl std::fmt::Display for PlainListing {
 }
 
 impl PlainListing {
-    pub fn new(parent: ComponentId, coordinates: (AccountHash, MailboxHash)) -> Box<Self> {
+    pub fn new(
+        parent: ComponentId,
+        coordinates: (AccountHash, MailboxHash),
+        context: &Context,
+    ) -> Box<Self> {
+        let color_cache = ColorCache::new(context, IndexStyle::Plain);
         Box::new(Self {
             cursor_pos: (AccountHash::default(), MailboxHash::default(), 0),
             new_cursor_pos: (coordinates.0, coordinates.1, 0),
@@ -637,11 +645,11 @@ impl PlainListing {
             select_job: None,
             filtered_selection: Vec::new(),
             filtered_order: HashMap::default(),
-            data_columns: DataColumns::default(),
+            data_columns: DataColumns::new(color_cache.theme_default),
             dirty: true,
             force_draw: true,
             focus: Focus::None,
-            color_cache: ColorCache::default(),
+            color_cache,
             movement: None,
             modifier_active: false,
             modifier_command: None,
@@ -702,7 +710,7 @@ impl PlainListing {
                 context,
                 (self.cursor_pos.0, self.cursor_pos.1),
             ),
-            from: FromString(Address::display_name_slice(e.from())),
+            from: FromString(Address::display_name_slice(e.from(), None)),
             tags: TagString(tags, colors),
             unseen: !e.is_seen(),
             highlight_self: false,
@@ -740,6 +748,16 @@ impl PlainListing {
             .settings
             .account
             .main_identity_address();
+        let highlight_self_colwidth: usize = mailbox_settings!(
+            context[self.cursor_pos.0][&self.cursor_pos.1]
+                .listing
+                .highlight_self_flag
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(super::DEFAULT_HIGHLIGHT_SELF_FLAG)
+        .grapheme_width();
+        let mut itoa_buffer = itoa::Buffer::new();
         for i in iter {
             if !context.accounts[&self.cursor_pos.0].contains_key(i)
                 || !threads.envelope_to_thread.contains_key(&i)
@@ -780,9 +798,13 @@ impl PlainListing {
             let mut entry_strings = self.make_entry_string(&envelope, context);
             entry_strings.highlight_self = should_highlight_self
                 && (envelope.recipient_any(&my_address) || envelope.sender_any(&my_address));
-            row_widths
-                .0
-                .push(digits_of_num!(self.length).try_into().unwrap_or(255));
+            row_widths.0.push(
+                itoa_buffer
+                    .format(self.length)
+                    .len()
+                    .try_into()
+                    .unwrap_or(255),
+            );
             row_widths.1.push(
                 entry_strings
                     .date
@@ -798,9 +820,8 @@ impl PlainListing {
                     .unwrap_or(255),
             );
             row_widths.3.push(
-                entry_strings
-                    .flag
-                    .grapheme_width()
+                (entry_strings.flag.grapheme_width()
+                    + usize::from(entry_strings.highlight_self) * highlight_self_colwidth)
                     .try_into()
                     .unwrap_or(255),
             ); /* flags */
@@ -811,7 +832,10 @@ impl PlainListing {
             );
             min_width.1 = min_width.1.max(entry_strings.date.grapheme_width()); /* date */
             min_width.2 = min_width.2.max(entry_strings.from.grapheme_width()); /* from */
-            min_width.3 = min_width.3.max(entry_strings.flag.grapheme_width()); /* flags */
+            min_width.3 = min_width.3.max(
+                entry_strings.flag.grapheme_width()
+                    + usize::from(entry_strings.highlight_self) * highlight_self_colwidth,
+            ); /* flags */
             min_width.4 = min_width.4.max(
                 entry_strings.subject.grapheme_width() + 1 + entry_strings.tags.grapheme_width(),
             ); /* tags + subject */
@@ -868,6 +892,7 @@ impl PlainListing {
         };
 
         let columns = &mut self.data_columns.columns;
+        let mut itoa_buffer = itoa::Buffer::new();
         for ((idx, i), (_, strings)) in iter.enumerate().zip(self.rows.entries.iter()) {
             if !context.accounts[&self.cursor_pos.0].contains_key(i) {
                 //let mailbox = &account[&self.cursor_pos.1];
@@ -888,7 +913,7 @@ impl PlainListing {
                 let mut area_col_0 = columns[0].area().nth_row(idx);
                 if !*account_settings!(context[self.cursor_pos.0].listing.relative_list_indices) {
                     area_col_0 = area_col_0.skip_cols(columns[0].grid_mut().write_string(
-                        &idx.to_string(),
+                        itoa_buffer.format(idx),
                         row_attr.fg,
                         row_attr.bg,
                         row_attr.attrs,
@@ -931,7 +956,6 @@ impl PlainListing {
                     None,
                     None,
                 );
-                #[cfg(feature = "regexp")]
                 {
                     for text_formatter in crate::conf::text_format_regexps(context, "listing.from")
                     {
@@ -1004,7 +1028,6 @@ impl PlainListing {
                     None,
                     None,
                 ));
-                #[cfg(feature = "regexp")]
                 {
                     for text_formatter in
                         crate::conf::text_format_regexps(context, "listing.subject")
@@ -1099,10 +1122,11 @@ impl PlainListing {
             columns[n].grid_mut().clear_area(area, row_attr);
         }
 
+        let mut itoa_buffer = itoa::Buffer::new();
         let (x, _) = {
             let area = columns[0].area().nth_row(idx);
             columns[0].grid_mut().write_string(
-                &idx.to_string(),
+                itoa_buffer.format(idx),
                 row_attr.fg,
                 row_attr.bg,
                 row_attr.attrs,
@@ -1212,7 +1236,6 @@ impl PlainListing {
                 None,
                 None,
             ));
-            #[cfg(feature = "regexp")]
             {
                 for text_formatter in crate::conf::text_format_regexps(context, "listing.subject") {
                     let t = columns[4].grid_mut().insert_tag(text_formatter.tag);
@@ -1258,7 +1281,7 @@ impl PlainListing {
     fn select(
         &mut self,
         search_term: &str,
-        results: Result<SmallVec<[EnvelopeHash; 512]>>,
+        results: Result<Vec<EnvelopeHash>>,
         context: &mut Context,
     ) {
         let account = &context.accounts[&self.cursor_pos.0];
@@ -1301,7 +1324,7 @@ impl PlainListing {
         }
     }
 
-    fn draw_relative_numbers(&mut self, grid: &mut CellBuffer, area: Area, top_idx: usize) {
+    fn draw_relative_numbers(&self, grid: &mut CellBuffer, area: Area, top_idx: usize) {
         let width = self.data_columns.columns[0].area().width();
         let area = area.take_cols(width);
         for i in 0..area.height() {
@@ -1706,14 +1729,21 @@ impl Component for PlainListing {
                     if !self.unfocused()
                         && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_entry"]) =>
                 {
-                    if self.modifier_active && self.modifier_command.is_none() {
-                        self.modifier_command = Some(Modifier::default());
-                    } else if let Some(env_hash) = self.get_env_under_cursor(self.cursor_pos.2) {
+                    if let Some(env_hash) = self.get_env_under_cursor(self.new_cursor_pos.2) {
                         self.rows.update_selection_with_env(env_hash, |e| *e = !*e);
                         self.set_dirty(true);
                     }
                     return true;
                 }
+                UIEvent::Input(ref key)
+                    if !self.unfocused()
+                        && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_motion"]) =>
+                {
+                    if self.modifier_active && self.modifier_command.is_none() {
+                        self.modifier_command = Some(Modifier::default());
+                    }
+                    return true;
+                }
                 UIEvent::Action(ref action) => match action {
                     Action::SubSort(field, order) if !self.unfocused() => {
                         self.subsort = (*field, *order);
@@ -1816,7 +1846,11 @@ impl Component for PlainListing {
                         let handle = context.accounts[&self.cursor_pos.0]
                             .main_loop_handler
                             .job_executor
-                            .spawn_specialized("search".into(), job);
+                            .spawn(
+                                "search".into(),
+                                job,
+                                context.accounts[&self.cursor_pos.0].is_async(),
+                            );
                         self.search_job = Some((filter_term.to_string(), handle));
                     }
                     Err(err) => {
@@ -1841,7 +1875,11 @@ impl Component for PlainListing {
                         let mut handle = context.accounts[&self.cursor_pos.0]
                             .main_loop_handler
                             .job_executor
-                            .spawn_specialized("select_by_search".into(), job);
+                            .spawn(
+                                "select-by-search".into(),
+                                job,
+                                context.accounts[&self.cursor_pos.0].is_async(),
+                            );
                         if let Ok(Some(search_result)) = try_recv_timeout!(&mut handle.chan) {
                             self.select(search_term, search_result, context);
                         } else {

meli/src/mail/listing/thread.rs

@@ -139,12 +139,12 @@ pub struct ThreadListing {
     color_cache: ColorCache,
 
     #[allow(clippy::type_complexity)]
-    search_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    search_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     #[allow(clippy::type_complexity)]
-    _select_job: Option<(String, JoinHandle<Result<SmallVec<[EnvelopeHash; 512]>>>)>,
+    select_job: Option<(String, JoinHandle<Result<Vec<EnvelopeHash>>>)>,
     filter_term: String,
-    filtered_selection: Vec<EnvelopeHash>,
-    _filtered_order: HashMap<EnvelopeHash, usize>,
+    filtered_selection: Vec<ThreadHash>,
+    filtered_order: HashMap<ThreadHash, usize>,
     data_columns: DataColumns<5>,
     rows_drawn: SegmentTree,
     rows: RowsState<(ThreadHash, EnvelopeHash)>,
@@ -168,14 +168,17 @@ impl MailListingTrait for ThreadListing {
         &mut self.rows.row_updates
     }
 
-    fn selection(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
+    fn selection(&self) -> &HashMap<EnvelopeHash, bool> {
+        &self.rows.selection
+    }
+
+    fn selection_mut(&mut self) -> &mut HashMap<EnvelopeHash, bool> {
         &mut self.rows.selection
     }
 
     fn get_focused_items(&self, _context: &Context) -> SmallVec<[EnvelopeHash; 8]> {
         let is_selection_empty: bool = !self
-            .rows
-            .selection
+            .selection()
             .values()
             .cloned()
             .any(std::convert::identity);
@@ -185,13 +188,7 @@ impl MailListingTrait for ThreadListing {
                 .into_iter()
                 .collect::<_>();
         }
-        SmallVec::from_iter(
-            self.rows
-                .selection
-                .iter()
-                .filter(|(_, &v)| v)
-                .map(|(k, _)| *k),
-        )
+        SmallVec::from_iter(self.selection().iter().filter(|(_, &v)| v).map(|(k, _)| *k))
     }
 
     /// Fill the `self.content` `CellBuffer` with the contents of the account
@@ -212,7 +209,7 @@ impl MailListingTrait for ThreadListing {
 
         // Get mailbox as a reference.
         //
-        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1) {
+        match context.accounts[&self.cursor_pos.0].load(self.cursor_pos.1, true) {
             Ok(_) => {}
             Err(_) => {
                 self.length = 0;
@@ -313,6 +310,15 @@ impl MailListingTrait for ThreadListing {
             .settings
             .account
             .main_identity_address();
+        let highlight_self_colwidth: usize = mailbox_settings!(
+            context[self.cursor_pos.0][&self.cursor_pos.1]
+                .listing
+                .highlight_self_flag
+        )
+        .as_ref()
+        .map(|s| s.as_str())
+        .unwrap_or(super::DEFAULT_HIGHLIGHT_SELF_FLAG)
+        .grapheme_width();
         while let Some((indentation, thread_node_hash, has_sibling)) = iter.next() {
             let thread_node = &thread_nodes[&thread_node_hash];
 
@@ -369,9 +375,8 @@ impl MailListingTrait for ThreadListing {
                         .unwrap_or(255),
                 ); /* from */
                 row_widths.3.push(
-                    entry_strings
-                        .flag
-                        .grapheme_width()
+                    (entry_strings.flag.grapheme_width()
+                        + usize::from(entry_strings.highlight_self) * highlight_self_colwidth)
                         .try_into()
                         .unwrap_or(255),
                 ); /* flags */
@@ -384,7 +389,10 @@ impl MailListingTrait for ThreadListing {
                 );
                 min_width.1 = min_width.1.max(entry_strings.date.grapheme_width()); /* date */
                 min_width.2 = min_width.2.max(entry_strings.from.grapheme_width()); /* from */
-                min_width.3 = min_width.3.max(entry_strings.flag.grapheme_width()); /* flags */
+                min_width.3 = min_width.3.max(
+                    entry_strings.flag.grapheme_width()
+                        + usize::from(entry_strings.highlight_self) * highlight_self_colwidth,
+                ); /* flags */
                 min_width.4 = min_width.4.max(
                     entry_strings.subject.grapheme_width()
                         + 1
@@ -506,6 +514,10 @@ impl ListingTrait for ThreadListing {
         self.focus = Focus::None;
         self.rows.clear();
         self.initialized = false;
+        self.filtered_selection.clear();
+        self.filtered_order.clear();
+        self.filter_term.clear();
+        self.data_columns.clear();
     }
 
     fn draw_list(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
@@ -634,7 +646,7 @@ impl ListingTrait for ThreadListing {
             even: idx % 2 == 0,
             unseen: !envelope.is_seen(),
             highlighted: self.cursor_pos.2 == idx,
-            selected: self.rows.selection[&env_hash],
+            selected: self.selection()[&env_hash],
         );
 
         let x = self.data_columns.widths[0]
@@ -659,17 +671,55 @@ impl ListingTrait for ThreadListing {
         }
     }
 
-    fn filter(
-        &mut self,
-        filter_term: String,
-        _results: SmallVec<[EnvelopeHash; 512]>,
-        context: &Context,
-    ) {
+    fn filter(&mut self, filter_term: String, results: Vec<EnvelopeHash>, context: &Context) {
         if filter_term.is_empty() {
             return;
         }
 
-        let _account = &context.accounts[&self.cursor_pos.0];
+        self.length = 0;
+        self.filtered_selection.clear();
+        self.filtered_order.clear();
+        self.filter_term = filter_term;
+        self.rows.row_updates.clear();
+        for v in self.selection_mut().values_mut() {
+            *v = false;
+        }
+
+        let account = &context.accounts[&self.cursor_pos.0];
+        let threads = account.collection.get_threads(self.cursor_pos.1);
+        for env_hash in results {
+            if !account.collection.contains_key(&env_hash) {
+                continue;
+            }
+            let env_thread_node_hash = account.collection.get_env(env_hash).thread();
+            if !threads.thread_nodes.contains_key(&env_thread_node_hash) {
+                continue;
+            }
+            let thread = threads.find_group(threads.thread_nodes[&env_thread_node_hash].group);
+            if self.filtered_order.contains_key(&thread) {
+                continue;
+            }
+            if self.rows.all_threads.contains(&thread) {
+                self.filtered_selection.push(thread);
+                self.filtered_order
+                    .insert(thread, self.filtered_selection.len() - 1);
+            }
+        }
+        if !self.filtered_selection.is_empty() {
+            threads.group_inner_sort_by(
+                &mut self.filtered_selection,
+                self.sort,
+                &context.accounts[&self.cursor_pos.0].collection.envelopes,
+            );
+            self.new_cursor_pos.2 = self.cursor_pos.2.min(self.filtered_selection.len() - 1);
+        } else {
+            _ = self.data_columns.columns[0].resize_with_context(0, 0, context);
+        }
+        self.redraw_threads_list(
+            context,
+            Box::new(self.filtered_selection.clone().into_iter())
+                as Box<dyn Iterator<Item = ThreadHash>>,
+        );
     }
 
     fn view_area(&self) -> Option<Area> {
@@ -680,6 +730,10 @@ impl ListingTrait for ThreadListing {
         !matches!(self.focus, Focus::None)
     }
 
+    fn modifier_active(&self) -> bool {
+        self.modifier_active
+    }
+
     fn set_modifier_active(&mut self, new_val: bool) {
         self.modifier_active = new_val;
     }
@@ -757,22 +811,23 @@ impl ThreadListing {
         coordinates: (AccountHash, MailboxHash),
         context: &Context,
     ) -> Box<Self> {
+        let color_cache = ColorCache::new(context, IndexStyle::Threaded);
         Box::new(Self {
             cursor_pos: (coordinates.0, MailboxHash::default(), 0),
             new_cursor_pos: (coordinates.0, coordinates.1, 0),
             length: 0,
             sort: (Default::default(), Default::default()),
             subsort: (Default::default(), Default::default()),
-            color_cache: ColorCache::new(context, IndexStyle::Threaded),
-            data_columns: DataColumns::default(),
+            data_columns: DataColumns::new(color_cache.theme_default),
+            color_cache,
             rows_drawn: SegmentTree::default(),
             rows: RowsState::default(),
             seen_cache: IndexMap::default(),
             filter_term: String::new(),
             search_job: None,
-            _select_job: None,
+            select_job: None,
             filtered_selection: Vec::new(),
-            _filtered_order: HashMap::default(),
+            filtered_order: HashMap::default(),
             dirty: true,
             force_draw: true,
             focus: Focus::None,
@@ -887,14 +942,14 @@ impl ThreadListing {
             subject: SubjectString(subject),
             flag: FlagString::new(
                 e.flags(),
-                self.rows.selection.get(&e.hash()).cloned().unwrap_or(false),
+                self.selection().get(&e.hash()).cloned().unwrap_or(false),
                 /* snoozed */ false,
                 !e.is_seen(),
                 e.has_attachments(),
                 context,
                 (self.cursor_pos.0, self.cursor_pos.1),
             ),
-            from: FromString(Address::display_name_slice(e.from())),
+            from: FromString(Address::display_name_slice(e.from(), None)),
             tags: TagString(tags, colors),
             unseen: !e.is_seen(),
             highlight_self: false,
@@ -920,7 +975,7 @@ impl ThreadListing {
             self.data_columns.columns[4].area().width(),
         );
         let columns = &mut self.data_columns.columns;
-
+        let mut itoa_buffer = itoa::Buffer::new();
         for (idx, ((_thread_hash, env_hash), strings)) in self
             .rows
             .entries
@@ -944,7 +999,7 @@ impl ThreadListing {
                 let mut area_col_0 = columns[0].area().nth_row(idx);
                 if !*account_settings!(context[self.cursor_pos.0].listing.relative_list_indices) {
                     area_col_0 = area_col_0.skip_cols(columns[0].grid_mut().write_string(
-                        &idx.to_string(),
+                        itoa_buffer.format(idx),
                         row_attr.fg,
                         row_attr.bg,
                         row_attr.attrs,
@@ -987,7 +1042,6 @@ impl ThreadListing {
                     None,
                     None,
                 );
-                #[cfg(feature = "regexp")]
                 {
                     for text_formatter in crate::conf::text_format_regexps(context, "listing.from")
                     {
@@ -1060,7 +1114,6 @@ impl ThreadListing {
                     None,
                     None,
                 ));
-                #[cfg(feature = "regexp")]
                 {
                     for text_formatter in
                         crate::conf::text_format_regexps(context, "listing.subject")
@@ -1120,7 +1173,7 @@ impl ThreadListing {
             even: idx % 2 == 0,
             unseen: !envelope.is_seen(),
             highlighted: false,
-            selected: self.rows.selection[&env_hash]
+            selected: self.selection()[&env_hash]
         );
         self.seen_cache.insert(env_hash, envelope.is_seen());
 
@@ -1163,7 +1216,52 @@ impl ThreadListing {
         *self.rows.entries.get_mut(idx).unwrap() = ((thread_hash, env_hash), entry_strings);
     }
 
-    fn draw_relative_numbers(&mut self, grid: &mut CellBuffer, area: Area, top_idx: usize) {
+    fn select(
+        &mut self,
+        search_term: &str,
+        results: Result<Vec<EnvelopeHash>>,
+        context: &mut Context,
+    ) {
+        let account = &context.accounts[&self.cursor_pos.0];
+        match results {
+            Ok(results) => {
+                let threads = account.collection.get_threads(self.cursor_pos.1);
+                for env_hash in results {
+                    if !account.collection.contains_key(&env_hash) {
+                        continue;
+                    }
+                    let env_thread_node_hash = account.collection.get_env(env_hash).thread();
+                    if !threads.thread_nodes.contains_key(&env_thread_node_hash) {
+                        continue;
+                    }
+                    let thread =
+                        threads.find_group(threads.thread_nodes[&env_thread_node_hash].group);
+                    if self.rows.all_threads.contains(&thread) {
+                        self.selection_mut()
+                            .entry(env_hash)
+                            .and_modify(|entry| *entry = true);
+                    }
+                }
+            }
+            Err(err) => {
+                self.cursor_pos.2 = 0;
+                self.new_cursor_pos.2 = 0;
+                let message = format!(
+                    "Encountered an error while searching for `{}`: {}.",
+                    search_term, &err
+                );
+                log::error!("{}", message);
+                context.replies.push_back(UIEvent::Notification {
+                    title: Some("Could not perform search".into()),
+                    source: None,
+                    body: message.into(),
+                    kind: Some(crate::types::NotificationType::Error(err.kind)),
+                });
+            }
+        }
+    }
+
+    fn draw_relative_numbers(&self, grid: &mut CellBuffer, area: Area, top_idx: usize) {
         let width = self.data_columns.columns[0].area().width();
         let area = area.take_cols(width);
         for i in 0..area.height() {
@@ -1176,7 +1274,7 @@ impl ThreadListing {
                     even: (top_idx + i) % 2 == 0,
                     unseen: !self.seen_cache[&env_hash],
                     highlighted: self.cursor_pos.2 == (top_idx + i),
-                    selected: self.rows.selection[&env_hash]
+                    selected: self.selection()[&env_hash]
                 )
             } else {
                 row_attr!(self.color_cache, even: (top_idx + i) % 2 == 0, unseen: false, highlighted: true, selected: false)
@@ -1470,7 +1568,7 @@ impl Component for ThreadListing {
                         even: row % 2 == 0,
                         unseen: !envelope.is_seen(),
                         highlighted: false,
-                        selected: self.rows.selection[&env_hash]
+                        selected: self.selection()[&env_hash]
                     );
                     self.rows.row_attr_cache.insert(row, row_attr);
                     self.force_draw |= row >= top_idx && row < top_idx + rows;
@@ -1579,7 +1677,7 @@ impl Component for ThreadListing {
                     return false;
                 }
                 self.rows.rename_env(*old_hash, *new_hash);
-                self.seen_cache.remove(old_hash);
+                self.seen_cache.shift_remove(old_hash);
                 self.seen_cache
                     .insert(*new_hash, account.collection.get_env(*new_hash).is_seen());
                 if let Some(&row) = self.rows.env_order.get(new_hash) {
@@ -1591,7 +1689,7 @@ impl Component for ThreadListing {
             UIEvent::EnvelopeRemove(ref env_hash, _) => {
                 if self.rows.contains_env(*env_hash) {
                     self.refresh_mailbox(context, false);
-                    self.seen_cache.remove(env_hash);
+                    self.seen_cache.shift_remove(env_hash);
                     self.set_dirty(true);
                 }
             }
@@ -1614,18 +1712,31 @@ impl Component for ThreadListing {
             UIEvent::Resize => {
                 self.set_dirty(true);
             }
+            UIEvent::Input(Key::Esc) if !self.unfocused() && !self.filter_term.is_empty() => {
+                self.set_coordinates((self.new_cursor_pos.0, self.new_cursor_pos.1));
+                self.refresh_mailbox(context, false);
+                self.set_dirty(true);
+                return true;
+            }
             UIEvent::Input(ref key)
                 if !self.unfocused()
                     && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_entry"]) =>
             {
-                if self.modifier_active && self.modifier_command.is_none() {
-                    self.modifier_command = Some(Modifier::default());
-                } else if let Some(env_hash) = self.get_env_under_cursor(self.new_cursor_pos.2) {
+                if let Some(env_hash) = self.get_env_under_cursor(self.new_cursor_pos.2) {
                     self.rows.update_selection_with_env(env_hash, |e| *e = !*e);
                     self.set_dirty(true);
                 }
                 return true;
             }
+            UIEvent::Input(ref key)
+                if !self.unfocused()
+                    && shortcut!(key == shortcuts[Shortcuts::LISTING]["select_motion"]) =>
+            {
+                if self.modifier_active && self.modifier_command.is_none() {
+                    self.modifier_command = Some(Modifier::default());
+                }
+                return true;
+            }
             UIEvent::Action(ref action) => match action {
                 Action::SubSort(field, order) => {
                     self.subsort = (*field, *order);
@@ -1649,7 +1760,11 @@ impl Component for ThreadListing {
                             let handle = context.accounts[&self.new_cursor_pos.0]
                                 .main_loop_handler
                                 .job_executor
-                                .spawn_specialized("search".into(), job);
+                                .spawn(
+                                    "search".into(),
+                                    job,
+                                    context.accounts[&self.new_cursor_pos.0].is_async(),
+                                );
                             self.search_job = Some((filter_term.to_string(), handle));
                         }
                         Err(err) => {
@@ -1664,6 +1779,39 @@ impl Component for ThreadListing {
                     self.set_dirty(true);
                     return true;
                 }
+                Action::Listing(Select(ref search_term)) if !self.unfocused() => {
+                    match context.accounts[&self.cursor_pos.0].search(
+                        search_term,
+                        self.sort,
+                        self.cursor_pos.1,
+                    ) {
+                        Ok(job) => {
+                            let mut handle = context.accounts[&self.cursor_pos.0]
+                                .main_loop_handler
+                                .job_executor
+                                .spawn(
+                                    "select-by-search".into(),
+                                    job,
+                                    context.accounts[&self.cursor_pos.0].is_async(),
+                                );
+                            if let Ok(Some(search_result)) = try_recv_timeout!(&mut handle.chan) {
+                                self.select(search_term, search_result, context);
+                            } else {
+                                self.select_job = Some((search_term.to_string(), handle));
+                            }
+                        }
+                        Err(err) => {
+                            context.replies.push_back(UIEvent::Notification {
+                                title: Some("Could not perform search".into()),
+                                source: None,
+                                body: err.to_string().into(),
+                                kind: Some(crate::types::NotificationType::Error(err.kind)),
+                            });
+                        }
+                    };
+                    self.set_dirty(true);
+                    return true;
+                }
                 _ => {}
             },
             UIEvent::StatusEvent(StatusEvent::JobFinished(ref job_id))
@@ -1689,6 +1837,21 @@ impl Component for ThreadListing {
                 }
                 self.set_dirty(true);
             }
+            UIEvent::StatusEvent(StatusEvent::JobFinished(ref job_id))
+                if self
+                    .select_job
+                    .as_ref()
+                    .map(|(_, j)| j == job_id)
+                    .unwrap_or(false) =>
+            {
+                let (search_term, mut handle) = self.select_job.take().unwrap();
+                match handle.chan.try_recv() {
+                    Err(_) => { /* search was canceled */ }
+                    Ok(None) => { /* something happened, perhaps a worker thread panicked */ }
+                    Ok(Some(results)) => self.select(&search_term, results, context),
+                }
+                self.set_dirty(true);
+            }
             _ => {}
         }
         false

meli/src/mail/pgp.rs

@@ -23,7 +23,6 @@ use std::{
     collections::{hash_map::DefaultHasher, BTreeMap},
     future::Future,
     hash::{Hash, Hasher},
-    pin::Pin,
     sync::{Arc, Mutex},
 };
 
@@ -34,10 +33,11 @@ use melib::{
     },
     error::*,
     gpgme::*,
-    log,
     parser::BytesExt,
 };
 
+use super::AttachmentBoxFuture;
+
 pub async fn decrypt(raw: Vec<u8>) -> Result<(melib_pgp::DecryptionMetadata, Vec<u8>)> {
     let mut ctx = Context::new()?;
     let cipher = ctx.new_data_mem(&raw)?;
@@ -81,18 +81,128 @@ async fn verify_inner(a: Attachment, cache: Arc<Mutex<BTreeMap<u64, Result<()>>>
 }
 
 pub fn sign_filter(
-    sign_keys: Vec<Key>,
-) -> Result<
-    impl FnOnce(AttachmentBuilder) -> Pin<Box<dyn Future<Output = Result<AttachmentBuilder>> + Send>>
-        + Send,
-> {
-    Ok(
-        move |a: AttachmentBuilder| -> Pin<Box<dyn Future<Output = Result<AttachmentBuilder>>+Send>> {
-            Box::pin(async move {
+    default_key: Option<String>,
+    mut sign_keys: Vec<Key>,
+) -> Result<impl FnOnce(AttachmentBuilder) -> AttachmentBoxFuture + Send> {
+    Ok(move |a: AttachmentBuilder| -> AttachmentBoxFuture {
+        Box::pin(async move {
+            if let Some(default_key) = default_key {
+                let mut ctx = Context::new()?;
+                ctx.set_auto_key_locate(LocateKey::LOCAL)?;
+                let keys = ctx.keylist(false, Some(default_key.clone()))?.await?;
+                if keys.is_empty() {
+                    return Err(Error::new(format!(
+                        "Could not locate sign key with ID `{}`",
+                        default_key
+                    )));
+                }
+                sign_keys.extend(keys);
+            }
+            if sign_keys.is_empty() {
+                return Err(Error::new(
+                    "No key was selected for signing; please select one.",
+                ));
+            }
+            let a: Attachment = a.into();
+            let mut ctx = Context::new()?;
+            let data = ctx.new_data_mem(&melib_pgp::convert_attachment_to_rfc_spec(
+                a.into_raw().as_bytes(),
+            ))?;
+            let sig_attachment = Attachment::new(
+                ContentType::PGPSignature,
+                Default::default(),
+                ctx.sign(sign_keys, data)?.await?,
+            );
+            let a: AttachmentBuilder = a.into();
+            let parts = vec![a, sig_attachment.into()];
+            let boundary = ContentType::make_boundary(&parts);
+            Ok(Attachment::new(
+                ContentType::Multipart {
+                    boundary: boundary.into_bytes(),
+                    kind: MultipartType::Signed,
+                    parts: parts.into_iter().map(|a| a.into()).collect::<Vec<_>>(),
+                    parameters: vec![],
+                },
+                Default::default(),
+                vec![],
+            )
+            .into())
+        })
+    })
+}
+
+pub fn encrypt_filter(
+    encrypt_for_self: Option<melib::Address>,
+    default_sign_key: Option<String>,
+    mut sign_keys: Option<Vec<Key>>,
+    default_encrypt_key: Option<String>,
+    mut encrypt_keys: Vec<Key>,
+) -> Result<impl FnOnce(AttachmentBuilder) -> AttachmentBoxFuture + Send> {
+    Ok(move |a: AttachmentBuilder| -> AttachmentBoxFuture {
+        Box::pin(async move {
+            if let Some(default_key) = default_sign_key {
+                let mut ctx = Context::new()?;
+                ctx.set_auto_key_locate(LocateKey::LOCAL)?;
+                let keys = ctx.keylist(true, Some(default_key.clone()))?.await?;
+                if keys.is_empty() {
+                    return Err(Error::new(format!(
+                        "Could not locate sign key with ID `{}`",
+                        default_key
+                    )));
+                }
+                if let Some(ref mut sign_keys) = sign_keys {
+                    sign_keys.extend(keys);
+                } else {
+                    sign_keys = Some(keys);
+                }
+            }
+            if let Some(ref sign_keys) = sign_keys {
+                if sign_keys.is_empty() {
+                    return Err(Error::new(
+                        "No key was selected for signing; please select one.",
+                    ));
+                }
+            }
+            if let Some(default_key) = default_encrypt_key {
+                let mut ctx = Context::new()?;
+                ctx.set_auto_key_locate(LocateKey::LOCAL)?;
+                let keys = ctx.keylist(false, Some(default_key.clone()))?.await?;
+                if keys.is_empty() {
+                    return Err(Error::new(format!(
+                        "Could not locate encryption key with ID `{}`",
+                        default_key
+                    )));
+                }
+                encrypt_keys.extend(keys);
+            }
+            if encrypt_keys.is_empty() {
+                return Err(Error::new(
+                    "No key was selected for encryption; please select one.",
+                ));
+            }
+            if let Some(encrypt_for_self) = encrypt_for_self {
+                let mut ctx = Context::new()?;
+                ctx.set_auto_key_locate(LocateKey::LOCAL)?;
+                let keys = ctx
+                    .keylist(false, Some(encrypt_for_self.to_string()))?
+                    .await?;
+                if keys.is_empty() {
+                    return Err(Error::new(format!(
+                        "Could not locate personal encryption key for address `{}`",
+                        encrypt_for_self
+                    )));
+                }
+                for key in keys {
+                    if !encrypt_keys.contains(&key) {
+                        encrypt_keys.push(key);
+                    }
+                }
+            }
+            let a: Attachment = if let Some(sign_keys) = sign_keys {
                 let a: Attachment = a.into();
                 let mut ctx = Context::new()?;
                 let data = ctx.new_data_mem(&melib_pgp::convert_attachment_to_rfc_spec(
-                                a.into_raw().as_bytes(),
+                    a.into_raw().as_bytes(),
                 ))?;
                 let sig_attachment = Attachment::new(
                     ContentType::PGPSignature,
@@ -102,7 +212,7 @@ pub fn sign_filter(
                 let a: AttachmentBuilder = a.into();
                 let parts = vec![a, sig_attachment.into()];
                 let boundary = ContentType::make_boundary(&parts);
-                Ok(Attachment::new(
+                Attachment::new(
                     ContentType::Multipart {
                         boundary: boundary.into_bytes(),
                         kind: MultipartType::Signed,
@@ -112,56 +222,42 @@ pub fn sign_filter(
                     Default::default(),
                     vec![],
                 )
-                .into())
-            })
-        },
-    )
-}
+            } else {
+                a.into()
+            };
+            let mut ctx = Context::new()?;
+            let data = ctx.new_data_mem(a.into_raw().as_bytes())?;
 
-pub fn encrypt_filter(
-    sign_keys: Option<Vec<Key>>,
-    encrypt_keys: Vec<Key>,
-) -> Result<
-    impl FnOnce(AttachmentBuilder) -> Pin<Box<dyn Future<Output = Result<AttachmentBuilder>> + Send>>
-        + Send,
-> {
-    Ok(
-        move |a: AttachmentBuilder| -> Pin<Box<dyn Future<Output = Result<AttachmentBuilder>>+Send>> {
-            Box::pin(async move {
-                let a: Attachment = a.into();
-                log::trace!("main attachment is {:?}", &a);
-                let mut ctx = Context::new()?;
-                let data = ctx.new_data_mem(
-                    a.into_raw().as_bytes()
-                )?;
-
-                let sig_attachment = {
-                    let mut a = Attachment::new(
-                            ContentType::OctetStream { name: None, parameters: vec![] },
-                            Default::default(),
-                            ctx.encrypt(sign_keys, encrypt_keys, data)?.await?,
-                        );
-                        a.content_disposition = ContentDisposition::from(br#"attachment; filename="msg.asc""#);
-                        a
-                };
-                let mut a: AttachmentBuilder = AttachmentBuilder::new(b"Version: 1\n");
-
-                a.set_content_type_from_bytes(b"application/pgp-encrypted");
-                a.set_content_disposition(ContentDisposition::from(b"attachment"));
-                let parts = vec![a, sig_attachment.into()];
-                let boundary = ContentType::make_boundary(&parts);
-                Ok(Attachment::new(
-                    ContentType::Multipart {
-                        boundary: boundary.into_bytes(),
-                        kind: MultipartType::Encrypted,
-                        parts: parts.into_iter().map(|a| a.into()).collect::<Vec<_>>(),
+            let enc_attachment = {
+                let mut a = Attachment::new(
+                    ContentType::OctetStream {
+                        name: None,
                         parameters: vec![],
                     },
                     Default::default(),
-                    vec![],
-                )
-                .into())
-            })
-        },
-    )
+                    ctx.encrypt(encrypt_keys, data)?.await?,
+                );
+                a.content_disposition =
+                    ContentDisposition::from(br#"attachment; filename="msg.asc""#);
+                a
+            };
+            let mut a: AttachmentBuilder = AttachmentBuilder::new(b"Version: 1\n");
+
+            a.set_content_type_from_bytes(b"application/pgp-encrypted");
+            a.set_content_disposition(ContentDisposition::from(b"attachment"));
+            let parts = vec![a, enc_attachment.into()];
+            let boundary = ContentType::make_boundary(&parts);
+            Ok(Attachment::new(
+                ContentType::Multipart {
+                    boundary: boundary.into_bytes(),
+                    kind: MultipartType::Encrypted,
+                    parts: parts.into_iter().map(|a| a.into()).collect::<Vec<_>>(),
+                    parameters: vec![],
+                },
+                Default::default(),
+                vec![],
+            )
+            .into())
+        })
+    })
 }

meli/src/mail/status.rs

@@ -44,15 +44,7 @@ impl std::fmt::Display for AccountStatus {
 
 impl AccountStatus {
     pub fn new(account_pos: usize, theme_default: ThemeAttribute) -> Self {
-        let default_cell = {
-            let mut ret = Cell::with_char(' ');
-            ret.set_fg(theme_default.fg)
-                .set_bg(theme_default.bg)
-                .set_attrs(theme_default.attrs);
-            ret
-        };
-        let mut content = Screen::<Virtual>::new();
-        content.grid_mut().default_cell = default_cell;
+        let mut content = Screen::<Virtual>::new(theme_default);
         content.grid_mut().set_growable(true);
         _ = content.resize(80, 20);
 

meli/src/mail/view.rs

@@ -22,7 +22,6 @@
 use std::{
     collections::HashSet,
     convert::TryFrom,
-    fmt::Write as _,
     io::Write,
     process::{Command, Stdio},
 };
@@ -129,10 +128,11 @@ impl MailView {
                     .and_then(|op| op.as_bytes())
                 {
                     Ok(fut) => {
-                        let mut handle = account
-                            .main_loop_handler
-                            .job_executor
-                            .spawn_specialized("fetch_envelopes".into(), fut);
+                        let mut handle = account.main_loop_handler.job_executor.spawn(
+                            "fetch-envelope".into(),
+                            fut,
+                            account.is_async(),
+                        );
                         let job_id = handle.job_id;
                         pending_action = if let MailViewState::Init {
                             ref mut pending_action,
@@ -153,6 +153,7 @@ impl MailView {
                             }
                         } else {
                             self.state = MailViewState::LoadingBody {
+                                main_loop_handler: self.main_loop_handler.clone(),
                                 handle,
                                 pending_action: pending_action.take(),
                             };
@@ -197,25 +198,27 @@ impl MailView {
                 ref env,
                 ref env_view,
                 ..
-            } => (
-                bytes,
-                EnvelopeView::attachment_displays_to_text(&env_view.display, false),
-                env,
-            ),
+            } => (bytes, env_view.body_text(), env),
             MailViewState::Error { .. } => {
                 return;
             }
         };
         let composer = match action {
-            PendingReplyAction::Reply => {
-                Box::new(Composer::reply_to_select(coordinates, reply_body, context))
-            }
-            PendingReplyAction::ReplyToAuthor => {
-                Box::new(Composer::reply_to_author(coordinates, reply_body, context))
-            }
-            PendingReplyAction::ReplyToAll => {
-                Box::new(Composer::reply_to_all(coordinates, reply_body, context))
-            }
+            PendingReplyAction::Reply => Box::new(Composer::reply_to_select(
+                coordinates,
+                reply_body.to_string(),
+                context,
+            )),
+            PendingReplyAction::ReplyToAuthor => Box::new(Composer::reply_to_author(
+                coordinates,
+                reply_body.to_string(),
+                context,
+            )),
+            PendingReplyAction::ReplyToAll => Box::new(Composer::reply_to_all(
+                coordinates,
+                reply_body.to_string(),
+                context,
+            )),
             PendingReplyAction::ForwardAttachment => {
                 Box::new(Composer::forward(coordinates, bytes, env, true, context))
             }
@@ -411,7 +414,7 @@ impl Component for MailView {
                     let account = &mut context.accounts[&coordinates.0];
                     {
                         for card in results.iter() {
-                            account.address_book.add_card(card.clone());
+                            account.contacts.add_card(card.clone());
                         }
                     }
                     self.contact_selector = None;
@@ -436,10 +439,9 @@ impl Component for MailView {
                 if self.active_jobs.contains(job_id) =>
             {
                 match self.state {
-                    MailViewState::LoadingBody {
-                        ref mut handle,
-                        pending_action: _,
-                    } if handle.job_id == *job_id => {
+                    MailViewState::LoadingBody { ref mut handle, .. }
+                        if handle.job_id == *job_id =>
+                    {
                         match handle.chan.try_recv() {
                             Err(_) => { /* Job was canceled */ }
                             Ok(None) => { /* something happened, perhaps a worker
@@ -554,20 +556,11 @@ impl Component for MailView {
                     let _ = sender.send(operation?.as_bytes()?.await);
                     Ok(())
                 };
-                let handle = if context.accounts[&account_hash]
-                    .backend_capabilities
-                    .is_async
-                {
-                    context
-                        .main_loop_handler
-                        .job_executor
-                        .spawn_specialized("fetch_envelope".into(), bytes_job)
-                } else {
-                    context
-                        .main_loop_handler
-                        .job_executor
-                        .spawn_blocking("fetch_envelope".into(), bytes_job)
-                };
+                let handle = context.main_loop_handler.job_executor.spawn(
+                    "fetch-envelope".into(),
+                    bytes_job,
+                    context.accounts[&account_hash].is_async(),
+                );
                 context.accounts[&account_hash].insert_job(
                     handle.job_id,
                     JobRequest::Generic {
@@ -590,15 +583,14 @@ impl Component for MailView {
                                         }
                                         Err(err) => {
                                             let err_string = format!(
-                                                "Failed to open envelope {}: {}",
+                                                "Failed to open envelope {:?}: {}",
                                                 context.accounts[&account_hash]
                                                     .collection
                                                     .envelopes
                                                     .read()
                                                     .unwrap()
                                                     .get(&env_hash)
-                                                    .map(|env| env.message_id_display())
-                                                    .unwrap_or_else(|| "Not found".into()),
+                                                    .map(|env| env.message_id()),
                                                 err
                                             );
                                             log::error!("{err_string}");
@@ -631,7 +623,7 @@ impl Component for MailView {
                 self.start_contact_selector(context);
                 return true;
             }
-            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Alt(''))
+            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1b'))
                 if self.contact_selector.is_some() || self.forward_dialog.is_some() =>
             {
                 if let Some(s) = self.contact_selector.take() {

meli/src/mail/view/envelope.rs

@@ -19,11 +19,16 @@
  * along with meli. If not, see <http://www.gnu.org/licenses/>.
  */
 
-use std::process::{Command, Stdio};
+use std::{
+    collections::VecDeque,
+    process::{Command, Stdio},
+};
 
 use melib::utils::{shellexpand::ShellExpandTrait, xdg::query_default_app};
 
 use super::*;
+#[cfg(feature = "gpgme")]
+use crate::jobs::IsAsync;
 use crate::ThreadEvent;
 
 /// Envelope view, with sticky headers, a pager for the body, and
@@ -243,7 +248,7 @@ impl EnvelopeView {
                             inner: Box::new(a.clone()),
                             display: {
                                 let mut v = vec![];
-                                EnvelopeView::attachment_to_display_helper(
+                                Self::attachment_to_display_helper(
                                     &parts[0],
                                     main_loop_handler,
                                     active_jobs,
@@ -259,9 +264,11 @@ impl EnvelopeView {
                     {
                         if view_settings.auto_verify_signatures.is_true() {
                             let verify_fut = crate::mail::pgp::verify(a.clone());
-                            let handle = main_loop_handler
-                                .job_executor
-                                .spawn_specialized("gpg::verify_sig".into(), verify_fut);
+                            let handle = main_loop_handler.job_executor.spawn(
+                                "gpg::verify".into(),
+                                verify_fut,
+                                IsAsync::Blocking,
+                            );
                             active_jobs.insert(handle.job_id);
                             main_loop_handler.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(
                                 StatusEvent::NewJob(handle.job_id),
@@ -319,9 +326,11 @@ impl EnvelopeView {
                             {
                                 if view_settings.auto_decrypt.is_true() {
                                     let decrypt_fut = crate::mail::pgp::decrypt(a.raw().to_vec());
-                                    let handle = main_loop_handler
-                                        .job_executor
-                                        .spawn_specialized("gpg::decrypt".into(), decrypt_fut);
+                                    let handle = main_loop_handler.job_executor.spawn(
+                                        "gpg::decrypt".into(),
+                                        decrypt_fut,
+                                        IsAsync::Blocking,
+                                    );
                                     active_jobs.insert(handle.job_id);
                                     main_loop_handler.send(ThreadEvent::UIEvent(
                                         UIEvent::StatusEvent(StatusEvent::NewJob(handle.job_id)),
@@ -370,125 +379,6 @@ impl EnvelopeView {
         self.display = display;
         self.attachment_tree = attachment_tree;
         self.attachment_paths = attachment_paths;
-        self.regenerate_body_text();
-    }
-
-    pub fn regenerate_body_text(&mut self) {
-        self.body_text = Self::attachment_displays_to_text(&self.display, true);
-    }
-
-    pub fn attachment_displays_to_text(
-        displays: &[AttachmentDisplay],
-        show_comments: bool,
-    ) -> String {
-        let mut acc = String::new();
-        for d in displays {
-            use AttachmentDisplay::*;
-            match d {
-                Alternative {
-                    inner: _,
-                    shown_display,
-                    display,
-                } => {
-                    acc.push_str(&Self::attachment_displays_to_text(
-                        &display[*shown_display..(*shown_display + 1)],
-                        show_comments,
-                    ));
-                }
-                InlineText {
-                    inner: _,
-                    text,
-                    comment: Some(comment),
-                } if show_comments => {
-                    acc.push_str(comment);
-                    if !acc.ends_with("\n\n") {
-                        acc.push_str("\n\n");
-                    }
-                    acc.push_str(text);
-                }
-                InlineText {
-                    inner: _,
-                    text,
-                    comment: _,
-                } => acc.push_str(text),
-                InlineOther { inner } => {
-                    if !acc.ends_with("\n\n") {
-                        acc.push_str("\n\n");
-                    }
-                    acc.push_str(&inner.to_string());
-                    if !acc.ends_with("\n\n") {
-                        acc.push_str("\n\n");
-                    }
-                }
-                Attachment { inner: _ } => {}
-                SignedPending {
-                    inner: _,
-                    display,
-                    handle: _,
-                    job_id: _,
-                } => {
-                    if show_comments {
-                        acc.push_str("Waiting for signature verification.\n\n");
-                    }
-                    acc.push_str(&Self::attachment_displays_to_text(display, show_comments));
-                }
-                SignedUnverified { inner: _, display } => {
-                    if show_comments {
-                        acc.push_str("Unverified signature.\n\n");
-                    }
-                    acc.push_str(&Self::attachment_displays_to_text(display, show_comments))
-                }
-                SignedFailed {
-                    inner: _,
-                    display,
-                    error,
-                } => {
-                    if show_comments {
-                        let _ = writeln!(acc, "Failed to verify signature: {}.\n", error);
-                    }
-                    acc.push_str(&Self::attachment_displays_to_text(display, show_comments));
-                }
-                SignedVerified {
-                    inner: _,
-                    display,
-                    description,
-                } => {
-                    if show_comments {
-                        if description.is_empty() {
-                            acc.push_str("Verified signature.\n\n");
-                        } else {
-                            acc.push_str(description);
-                            acc.push_str("\n\n");
-                        }
-                    }
-                    acc.push_str(&Self::attachment_displays_to_text(display, show_comments));
-                }
-                EncryptedPending { .. } => acc.push_str("Waiting for decryption result."),
-                EncryptedFailed { inner: _, error } => {
-                    let _ = write!(acc, "Decryption failed: {}.", &error);
-                }
-                EncryptedSuccess {
-                    inner: _,
-                    plaintext: _,
-                    plaintext_display,
-                    description,
-                } => {
-                    if show_comments {
-                        if description.is_empty() {
-                            acc.push_str("Successfully decrypted.\n\n");
-                        } else {
-                            acc.push_str(description);
-                            acc.push_str("\n\n");
-                        }
-                    }
-                    acc.push_str(&Self::attachment_displays_to_text(
-                        plaintext_display,
-                        show_comments,
-                    ));
-                }
-            }
-        }
-        acc
     }
 
     fn attachment_displays_to_tree(
@@ -711,6 +601,10 @@ impl EnvelopeView {
             ))));
         None
     }
+
+    pub fn body_text(&self) -> &str {
+        &self.body_text
+    }
 }
 
 impl Component for EnvelopeView {
@@ -745,7 +639,7 @@ impl Component for EnvelopeView {
                             if sticky || skip_header_ctr == 0 {
                                 if y <= area.height() {
                                     grid.clear_area(
-                                        area.skip_rows(y),
+                                        area.skip_rows(y).take_rows(1),
                                         hdr_area_theme,
                                     );
                                     let (_x, _y) =
@@ -758,7 +652,7 @@ impl Component for EnvelopeView {
                                             None,
                                             Some(0)
                                         );
-                                    let (__x, __y) =
+                                    let (__x, mut __y) =
                                         grid.write_string(
                                             &$string,
                                             hdr_theme.fg,
@@ -768,6 +662,15 @@ impl Component for EnvelopeView {
                                             Some(_x + 1),
                                             Some(2)
                                         );
+                                    if __y > 0 {
+                                        if __y > 3 && !self.view_settings.expand_headers {
+                                            __y = 3;
+                                        }
+                                        grid.clear_area(
+                                            area.skip_rows(y + _y + 1).take_rows(__y).take_cols(2),
+                                            hdr_area_theme,
+                                        );
+                                    }
                                     y += _y +__y + 1;
                                 }
                             } else {
@@ -831,21 +734,19 @@ impl Component for EnvelopeView {
                     (HeaderName::SUBJECT, envelope.subject()),
                     (
                         HeaderName::MESSAGE_ID,
-                        format!("<{}>", envelope.message_id_raw())
+                        envelope.message_id().display_brackets().to_string()
                     )
                 );
                 if self.view_settings.expand_headers {
-                    if let Some(val) = envelope.in_reply_to_display() {
+                    if let Some(val) = envelope.in_reply_to() {
                         print_header!(
-                            (HeaderName::IN_REPLY_TO, val),
+                            (
+                                HeaderName::IN_REPLY_TO,
+                                melib::MessageID::display_slice(val.refs(), Some(" "))
+                            ),
                             (
                                 HeaderName::REFERENCES,
-                                envelope
-                                    .references()
-                                    .iter()
-                                    .map(std::string::ToString::to_string)
-                                    .collect::<Vec<String>>()
-                                    .join(", ")
+                                melib::MessageID::display_slice(envelope.references(), Some(" "))
                             )
                         );
                     }
@@ -987,19 +888,12 @@ impl Component for EnvelopeView {
                                 }
                             }
                         }
-                        for c in grid.row_iter(area, (x + 1)..area.width(), y) {
-                            grid[c]
-                                .set_ch(' ')
-                                .set_fg(hdr_area_theme.fg)
-                                .set_bg(hdr_area_theme.bg);
-                        }
                         y += 1;
                     }
                 }
 
                 self.force_draw_headers = false;
-
-                grid.clear_area(area.nth_row(y), hdr_area_theme);
+                grid.clear_area(area.skip_rows(y), self.view_settings.theme_default);
                 context.dirty_areas.push_back(area.take_rows(y + 3));
                 if !self.view_settings.sticky_headers {
                     let height_p = self.pager.size().1;
@@ -1021,7 +915,7 @@ impl Component for EnvelopeView {
             }
         };
 
-        if self.filters.is_empty() || self.body_text.is_empty() {
+        if self.filters.is_empty() {
             let body = self.mail.body();
             if body.is_html() {
                 let attachment = if let Some(sub) = match body.content_type {
@@ -1036,7 +930,7 @@ impl Component for EnvelopeView {
                 } else {
                     &body
                 };
-                if let Ok(filter) = ViewFilter::new_html(attachment, context) {
+                if let Ok(filter) = ViewFilter::new_html(attachment, &self.view_settings, context) {
                     self.filters.push(filter);
                 }
             } else if self.view_settings.auto_choose_multipart_alternative
@@ -1058,24 +952,26 @@ impl Component for EnvelopeView {
                         .iter()
                         .find(|a| a.is_html())
                         .unwrap_or(&body),
+                    &self.view_settings,
                     context,
                 ) {
                     self.filters.push(filter);
-                } else if let Ok(filter) = ViewFilter::new_attachment(&body, context) {
+                } else if let Ok(filter) =
+                    ViewFilter::new_attachment(&body, &self.view_settings, context)
+                {
                     self.filters.push(filter);
                 }
-            } else if let Ok(filter) = ViewFilter::new_attachment(&body, context) {
+            } else if let Ok(filter) =
+                ViewFilter::new_attachment(&body, &self.view_settings, context)
+            {
                 self.filters.push(filter);
             }
-            self.body_text = String::from_utf8_lossy(
-                &body.decode(Option::<Charset>::from(&self.force_charset).into()),
-            )
-            .to_string();
         }
         if !self.initialised {
             self.initialised = true;
             let mut text = if !self.filters.is_empty() {
                 let mut text = String::new();
+                self.body_text.clear();
                 if let Some(last) = self.filters.last() {
                     let mut stack = vec![last];
                     while let Some(ViewFilter {
@@ -1093,21 +989,30 @@ impl Component for EnvelopeView {
                                     if filter_invocation.is_empty() {
                                         None
                                     } else {
-                                        Some(format!("Text filtered by `{filter_invocation}`\n\n"))
+                                        Some(format!("Text filtered by `{filter_invocation}`"))
                                     }
                                 })
                                 .unwrap_or_default(),
                         );
+                        if !text.is_empty() {
+                            text.push('\n');
+                        }
+                        if !self.body_text.is_empty() {
+                            self.body_text.push('\n');
+                        }
                         match body_text {
-                            ViewFilterContent::Filtered { inner } => text.push_str(
-                                &self.options.convert(&mut self.links, &self.body, inner),
-                            ),
+                            ViewFilterContent::Filtered { inner } => {
+                                let payload =
+                                    self.options.convert(&mut self.links, &self.body, inner);
+                                text.push_str(&payload);
+                                self.body_text.push_str(&payload);
+                            }
                             ViewFilterContent::Error { inner } => text.push_str(&inner.to_string()),
                             ViewFilterContent::Running { .. } => {
                                 text.push_str("Filter job running in background.")
                             }
                             ViewFilterContent::InlineAttachments { parts } => {
-                                stack.extend(parts.iter());
+                                stack.extend(parts.iter().rev());
                             }
                         }
                     }
@@ -1121,6 +1026,9 @@ impl Component for EnvelopeView {
                 text.push_str("\n\n");
             }
             text.push_str(&self.attachment_tree);
+            while text.ends_with('\n') {
+                text.pop();
+            }
             let cursor_pos = self.pager.cursor_pos();
             self.view_settings.body_theme = crate::conf::value(context, "mail.view.body");
             self.pager = Pager::from_string(
@@ -1298,7 +1206,6 @@ impl Component for EnvelopeView {
                     }
                     if caught {
                         self.links.clear();
-                        self.regenerate_body_text();
                         self.initialised = false;
                         self.set_dirty(true);
                     }
@@ -1306,31 +1213,31 @@ impl Component for EnvelopeView {
                     self.active_jobs.remove(job_id);
                 }
                 UIEvent::StatusEvent(StatusEvent::JobFinished(ref job_id))
-                    if self.filters.iter_mut().any(|filter| {
+                    if self.filters.iter().any(|f| f.contains_job_id(*job_id)) =>
+                {
+                    let mut stack = self.filters.iter_mut().collect::<VecDeque<&mut _>>();
+                    while let Some(filter) = stack.pop_front() {
                         if let Some(cb) = filter.event_handler {
                             if cb(
                                 filter,
                                 &mut UIEvent::StatusEvent(StatusEvent::JobFinished(*job_id)),
                                 context,
                             ) {
-                                return true;
+                                break;
                             }
-                        };
-                        false
-                    }) =>
-                {
-                    log::trace!(
-                        "after calling job event handles, filters are: {:?}",
-                        &self.filters
-                    );
+                        }
+                        if let ViewFilterContent::InlineAttachments { ref mut parts, .. } =
+                            filter.body_text
+                        {
+                            stack.extend(parts.iter_mut());
+                        }
+                    }
                     self.links.clear();
-                    self.regenerate_body_text();
                     self.initialised = false;
                     self.set_dirty(true);
                 }
                 _ => {}
             }
-            log::trace!("envelope.rs got job finished: {:?}", event);
         }
         match (&mut self.force_charset, &event) {
             (ForceCharset::Dialog(selector), UIEvent::FinishedUIDialog(id, results))
@@ -1353,6 +1260,13 @@ impl Component for EnvelopeView {
                 self.set_dirty(true);
                 return true;
             }
+            (ForceCharset::Dialog(selector), UIEvent::ComponentUnrealize(id))
+                if *id == selector.id() =>
+            {
+                self.force_charset = ForceCharset::None;
+                self.set_dirty(true);
+                return true;
+            }
             (ForceCharset::Dialog(selector), _) => {
                 if selector.process_event(event, context) {
                     return true;
@@ -1414,7 +1328,9 @@ impl Component for EnvelopeView {
             UIEvent::Resize | UIEvent::VisibilityChange(true) => {
                 self.set_dirty(true);
             }
-            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Alt('')) if !self.cmd_buf.is_empty() => {
+            UIEvent::Input(Key::Esc) | UIEvent::Input(Key::Char('\x1B'))
+                if !self.cmd_buf.is_empty() =>
+            {
                 self.cmd_buf.clear();
                 context
                     .replies
@@ -1495,7 +1411,7 @@ impl Component for EnvelopeView {
                 let mut path = std::path::Path::new(path).to_path_buf().expand();
 
                 if path.is_dir() {
-                    path.push(format!("{}.eml", self.mail.message_id_raw()));
+                    path.push(format!("{}.eml", self.mail.message_id()));
                 }
                 if path.is_relative() {
                     path = context.current_dir().join(&path);
@@ -1566,7 +1482,7 @@ impl Component for EnvelopeView {
                 } else if a_i == 0 {
                     // Save entire message as eml
                     if path.is_dir() {
-                        path.push(format!("{}.eml", self.mail.message_id_raw()));
+                        path.push(format!("{}.eml", self.mail.message_id()));
                     }
                     if path.is_relative() {
                         path = context.current_dir().join(&path);
@@ -1605,6 +1521,68 @@ impl Component for EnvelopeView {
                 }
                 return true;
             }
+            UIEvent::Action(View(ViewAction::PipeAttachment(a_i, ref bin, ref args))) => {
+                use std::borrow::Cow;
+
+                let bytes =
+                    if let Some(u) = self.open_attachment(a_i, context) {
+                        Cow::Owned(u.decode(Default::default()))
+                    } else if a_i == 0 {
+                        Cow::Borrowed(&self.mail.bytes)
+                    } else {
+                        context.replies.push_back(UIEvent::StatusEvent(
+                            StatusEvent::DisplayMessage(format!("Attachment `{}` not found.", a_i)),
+                        ));
+                        return true;
+                    };
+                // Kill input thread so that spawned command can be sole receiver of stdin
+                {
+                    context.input_kill();
+                }
+                let pipe_command = format!("{} {}", bin, args.as_slice().join(" "));
+                log::trace!("Executing: {}", &pipe_command);
+                match Command::new(bin)
+                    .args(args)
+                    .stdin(Stdio::piped())
+                    .stdout(Stdio::inherit())
+                    .stderr(Stdio::inherit())
+                    .spawn()
+                    .map_err(Error::from)
+                    .and_then(|mut child| {
+                        let Some(mut stdin) = child.stdin.take() else {
+                            let _ = child.wait();
+                            return Err(Error::new(format!(
+                                "Could not open standard input of {bin}"
+                            ))
+                            .set_kind(ErrorKind::External));
+                        };
+                        stdin.write_all(&bytes).chain_err_summary(|| {
+                            format!("Could not write to standard input of {bin}")
+                        })?;
+
+                        Ok(child)
+                    }) {
+                    Ok(mut child) => {
+                        let _ = child.wait();
+                    }
+                    Err(err) => {
+                        context.replies.push_back(UIEvent::Notification {
+                            title: Some(
+                                format!("Failed to execute {}: {}", pipe_command, err).into(),
+                            ),
+                            source: None,
+                            body: err.to_string().into(),
+                            kind: Some(NotificationType::Error(melib::error::ErrorKind::External)),
+                        });
+                        context.replies.push_back(UIEvent::Fork(ForkType::Finished));
+                        context.restore_input();
+                        self.set_dirty(true);
+                        return true;
+                    }
+                }
+                context.replies.push_back(UIEvent::Fork(ForkType::Finished));
+                return true;
+            }
             UIEvent::Input(ref key)
                 if shortcut!(key == shortcuts[Shortcuts::ENVELOPE_VIEW]["open_attachment"])
                     && !self.cmd_buf.is_empty() =>
@@ -1639,7 +1617,9 @@ impl Component for EnvelopeView {
                         | ContentType::Text { .. }
                         | ContentType::PGPSignature
                         | ContentType::CMSSignature => {
-                            if let Ok(filter) = ViewFilter::new_attachment(attachment, context) {
+                            if let Ok(filter) =
+                                ViewFilter::new_attachment(attachment, &self.view_settings, context)
+                            {
                                 self.filters.push(filter);
                             }
                             self.initialised = false;
@@ -1867,7 +1847,7 @@ impl Component for EnvelopeView {
         //    our_map.remove("return_to_normal_view");
         //}
         if !self.options.contains(ViewOptions::URL) {
-            our_map.remove("go_to_url");
+            our_map.shift_remove("go_to_url");
         }
         map.insert(Shortcuts::ENVELOPE_VIEW, our_map);
 

meli/src/mail/view/filters.rs

@@ -42,7 +42,8 @@ use smallvec::SmallVec;
 use crate::{
     components::*,
     desktop_exec_to_command,
-    jobs::{JobId, JoinHandle},
+    jobs::{IsAsync, JobId, JoinHandle},
+    mail::view::ViewSettings,
     terminal::{Area, CellBuffer},
     try_recv_timeout, Context, ErrorKind, File, StatusEvent, UIEvent,
 };
@@ -55,6 +56,7 @@ pub enum ViewFilterContent {
         job_id: JobId,
         on_success_notice_cb: OnSuccessNoticeCb,
         job_handle: JoinHandle<FilterResult>,
+        view_settings: ViewSettings,
     },
     Error {
         inner: Error,
@@ -75,6 +77,7 @@ impl std::fmt::Debug for ViewFilterContent {
                 ref job_id,
                 on_success_notice_cb: _,
                 job_handle: _,
+                view_settings: _,
             } => fmt
                 .debug_struct(stringify!(ViewFilterContent::Running))
                 .field("job_id", &job_id)
@@ -90,7 +93,8 @@ impl std::fmt::Debug for ViewFilterContent {
                 .finish(),
             InlineAttachments { ref parts } => fmt
                 .debug_struct(stringify!(ViewFilterContent::InlineAttachments))
-                .field("parts", &parts.len())
+                .field("parts_no", &parts.len())
+                .field("parts", &parts)
                 .finish(),
         }
     }
@@ -126,7 +130,11 @@ impl std::fmt::Display for ViewFilter {
 }
 
 impl ViewFilter {
-    pub fn new_html(body: &Attachment, context: &Context) -> Result<Self> {
+    pub fn new_html(
+        body: &Attachment,
+        view_settings: &ViewSettings,
+        context: &Context,
+    ) -> Result<Self> {
         fn run(cmd: &str, args: &[&str], bytes: &[u8]) -> Result<String> {
             let mut html_filter = Command::new(cmd)
                 .args(args)
@@ -269,17 +277,18 @@ impl ViewFilter {
         };
         let filter_invocation2 = filter_invocation.to_string();
         let open_html_shortcut = settings.shortcuts.envelope_view.open_html.clone();
-        let on_success_notice_cb = move || {
+        let on_success_notice_cb = Arc::new(move || {
             format!(
-                "Text piped through `{}` Press `{}` to open in web browser.\n\n",
+                "Text piped through `{}` Press `{}` to open in web browser.",
                 filter_invocation2, open_html_shortcut
             )
             .into()
-        };
-        let mut job_handle = context
-            .main_loop_handler
-            .job_executor
-            .spawn_blocking(filter_invocation.to_string().into(), job);
+        });
+        let mut job_handle = context.main_loop_handler.job_executor.spawn(
+            filter_invocation.to_string().into(),
+            job,
+            IsAsync::Blocking,
+        );
         let mut retval = Self {
             filter_invocation: filter_invocation.to_string(),
             content_type: att.content_type.clone(),
@@ -292,11 +301,18 @@ impl ViewFilter {
             id: ComponentId::default(),
         };
         if let Ok(Some(job_result)) = try_recv_timeout!(&mut job_handle.chan) {
+            retval.body_text = ViewFilterContent::Running {
+                job_id: job_handle.job_id,
+                on_success_notice_cb: on_success_notice_cb.clone(),
+                job_handle,
+                view_settings: view_settings.clone(),
+            };
             retval.event_handler = Some(Self::html_process_event);
             Self::process_job_result(
                 &mut retval,
                 Ok(Some(job_result)),
-                Arc::new(on_success_notice_cb),
+                on_success_notice_cb,
+                view_settings,
                 context,
             );
             return Ok(retval);
@@ -304,14 +320,19 @@ impl ViewFilter {
         Ok(Self {
             body_text: ViewFilterContent::Running {
                 job_id: job_handle.job_id,
-                on_success_notice_cb: Arc::new(on_success_notice_cb),
+                on_success_notice_cb,
                 job_handle,
+                view_settings: view_settings.clone(),
             },
             ..retval
         })
     }
 
-    pub fn new_attachment(att: &Attachment, context: &Context) -> Result<Self> {
+    pub fn new_attachment(
+        att: &Attachment,
+        view_settings: &ViewSettings,
+        context: &Context,
+    ) -> Result<Self> {
         if matches!(
             att.content_type,
             ContentType::Other { .. } | ContentType::OctetStream { .. }
@@ -331,25 +352,24 @@ impl ViewFilter {
             if let Some(Ok(v)) = parts
                 .iter()
                 .find(|p| p.is_text() && !p.body().trim().is_empty())
-                .map(|p| Self::new_attachment(p, context))
+                .map(|p| Self::new_attachment(p, view_settings, context))
             {
                 return Ok(v);
             }
         } else if let ContentType::Multipart {
-            kind: MultipartType::Related,
+            kind: MultipartType::Related | MultipartType::Mixed,
             ref parts,
             ..
         } = att.content_type
         {
-            let notice = Some(format!("multipart/related with {} parts.\n\n", parts.len()).into());
             return Ok(Self {
                 filter_invocation: String::new(),
                 content_type: att.content_type.clone(),
-                notice,
+                notice: None,
                 body_text: ViewFilterContent::InlineAttachments {
                     parts: parts
                         .iter()
-                        .filter_map(|p| Self::new_attachment(p, context).ok())
+                        .filter_map(|p| Self::new_attachment(p, view_settings, context).ok())
                         .collect::<Vec<Self>>(),
                 },
                 unfiltered: att.decode(Default::default()),
@@ -358,7 +378,7 @@ impl ViewFilter {
             });
         }
         if att.is_html() {
-            return Self::new_html(att, context);
+            return Self::new_html(att, view_settings, context);
         }
         if matches!(
             att.content_type,
@@ -381,22 +401,43 @@ impl ViewFilter {
         } else if let ContentType::Multipart {
             kind: MultipartType::Signed,
             ref parts,
-            ..
+            ref boundary,
+            ref parameters,
         } = att.content_type
         {
+            if !view_settings.auto_verify_signatures.is_true() {
+                let att = Attachment {
+                    content_type: ContentType::Multipart {
+                        kind: MultipartType::Mixed,
+                        parts: parts.clone(),
+                        parameters: parameters.clone(),
+                        boundary: boundary.clone(),
+                    },
+                    ..att.clone()
+                };
+                return Ok(Self {
+                    notice: Some("Unverified signature.".into()),
+                    ..Self::new_attachment(&att, view_settings, context)?
+                });
+            }
             #[cfg(not(feature = "gpgme"))]
             {
-                _ = parts;
+                let content = att.raw();
+                let bytes = content.trim().to_vec();
                 return Ok(Self {
                     filter_invocation: String::new(),
                     content_type: att.content_type.clone(),
-                    notice: None,
-                    body_text: ViewFilterContent::Error {
-                        inner: Error::new(
-                            "Cannot decrypt: meli must be compiled with libgpgme support.",
-                        ),
+                    notice: Some(
+                        "Cannot verify signature: meli must be compiled with libgpgme support."
+                            .into(),
+                    ),
+                    body_text: ViewFilterContent::InlineAttachments {
+                        parts: parts
+                            .iter()
+                            .filter_map(|p| Self::new_attachment(p, view_settings, context).ok())
+                            .collect::<Vec<Self>>(),
                     },
-                    unfiltered: vec![],
+                    unfiltered: bytes,
                     event_handler: None,
                     id: ComponentId::default(),
                 });
@@ -404,39 +445,57 @@ impl ViewFilter {
             #[cfg(feature = "gpgme")]
             {
                 for a in parts {
-                    if a.content_type == "application/octet-stream" {
-                        let content = a.raw();
+                    if a.content_type == "application/pgp-signature" {
+                        let content = att.raw();
                         let bytes = content.trim().to_vec();
-                        let decrypt_fut = async {
-                            let (_metadata, bytes) = crate::mail::pgp::decrypt(
-                                melib::email::pgp::convert_attachment_to_rfc_spec(&bytes),
-                            )
-                            .await
-                            .map_err(|err| (err, bytes))?;
-                            Ok((AttachmentBuilder::new(&bytes).build(), bytes))
+                        let verify_fut = {
+                            let a = Attachment {
+                                content_type: ContentType::Multipart {
+                                    kind: MultipartType::Mixed,
+                                    parts: parts.clone(),
+                                    parameters: parameters.clone(),
+                                    boundary: boundary.clone(),
+                                },
+                                ..att.clone()
+                            };
+                            let att = att.clone();
+                            async move {
+                                crate::mail::pgp::verify(att)
+                                    .await
+                                    .map_err(|err| (err, bytes.clone()))
+                                    .map(|_| (a, bytes))
+                            }
                         };
-                        let mut job_handle = context
-                            .main_loop_handler
-                            .job_executor
-                            .spawn_specialized("gpg::decrypt".into(), decrypt_fut);
-                        let on_success_notice_cb = || "Decrypted content.\n\n".into();
+                        let mut job_handle = context.main_loop_handler.job_executor.spawn(
+                            "gpg::verify".into(),
+                            verify_fut,
+                            IsAsync::Blocking,
+                        );
+                        let on_success_notice_cb = Arc::new(|| "Verified signature.".into());
                         let mut retval = Self {
-                            filter_invocation: "gpg::decrypt".into(),
+                            filter_invocation: "gpg::verify".into(),
                             content_type: att.content_type.clone(),
                             notice: None,
                             body_text: ViewFilterContent::Filtered {
                                 inner: String::new(),
                             },
-                            unfiltered: a.raw().to_vec(),
+                            unfiltered: att.raw().to_vec(),
                             event_handler: Some(Self::job_process_event),
                             id: ComponentId::default(),
                         };
                         if let Ok(Some(job_result)) = try_recv_timeout!(&mut job_handle.chan) {
+                            retval.body_text = ViewFilterContent::Running {
+                                job_id: job_handle.job_id,
+                                on_success_notice_cb: on_success_notice_cb.clone(),
+                                job_handle,
+                                view_settings: view_settings.clone(),
+                            };
                             retval.event_handler = None;
                             Self::process_job_result(
                                 &mut retval,
                                 Ok(Some(job_result)),
-                                Arc::new(on_success_notice_cb),
+                                on_success_notice_cb,
+                                view_settings,
                                 context,
                             );
                             return Ok(retval);
@@ -444,8 +503,9 @@ impl ViewFilter {
                         return Ok(Self {
                             body_text: ViewFilterContent::Running {
                                 job_id: job_handle.job_id,
-                                on_success_notice_cb: Arc::new(on_success_notice_cb),
+                                on_success_notice_cb,
                                 job_handle,
+                                view_settings: view_settings.clone(),
                             },
                             ..retval
                         });
@@ -460,14 +520,14 @@ impl ViewFilter {
         {
             #[cfg(not(feature = "gpgme"))]
             {
-                let msg = "Cannot verify signature: meli must be compiled with libgpgme support.";
+                let msg = "Cannot decrypt: meli must be compiled with libgpgme support.";
                 if let Some(Ok(mut res)) =
-                    parts
-                        .iter()
-                        .find_map(|part| match Self::new_attachment(part, context) {
+                    parts.iter().find_map(|part| {
+                        match Self::new_attachment(part, view_settings, context) {
                             v @ Ok(_) => Some(v),
                             Err(_) => None,
-                        })
+                        }
+                    })
                 {
                     match res.notice {
                         Some(ref mut notice) => {
@@ -499,11 +559,12 @@ impl ViewFilter {
                             .map_err(|err| (err, bytes))?;
                             Ok((AttachmentBuilder::new(&bytes).build(), bytes))
                         };
-                        let mut job_handle = context
-                            .main_loop_handler
-                            .job_executor
-                            .spawn_specialized("gpg::decrypt".into(), decrypt_fut);
-                        let on_success_notice_cb = || "Decrypted content.\n\n".into();
+                        let mut job_handle = context.main_loop_handler.job_executor.spawn(
+                            "gpg::decrypt".into(),
+                            decrypt_fut,
+                            IsAsync::Blocking,
+                        );
+                        let on_success_notice_cb = Arc::new(|| "Decrypted content.".into());
                         let mut retval = Self {
                             filter_invocation: "gpg::decrypt".into(),
                             content_type: att.content_type.clone(),
@@ -516,11 +577,18 @@ impl ViewFilter {
                             id: ComponentId::default(),
                         };
                         if let Ok(Some(job_result)) = try_recv_timeout!(&mut job_handle.chan) {
+                            retval.body_text = ViewFilterContent::Running {
+                                job_id: job_handle.job_id,
+                                on_success_notice_cb: on_success_notice_cb.clone(),
+                                job_handle,
+                                view_settings: view_settings.clone(),
+                            };
                             retval.event_handler = None;
                             Self::process_job_result(
                                 &mut retval,
                                 Ok(Some(job_result)),
-                                Arc::new(on_success_notice_cb),
+                                on_success_notice_cb,
+                                view_settings,
                                 context,
                             );
                             return Ok(retval);
@@ -528,30 +596,15 @@ impl ViewFilter {
                         return Ok(Self {
                             body_text: ViewFilterContent::Running {
                                 job_id: job_handle.job_id,
-                                on_success_notice_cb: Arc::new(on_success_notice_cb),
+                                on_success_notice_cb,
                                 job_handle,
+                                view_settings: view_settings.clone(),
                             },
                             ..retval
                         });
                     }
                 }
             }
-        } else if let ContentType::Multipart {
-            kind: MultipartType::Mixed,
-            ref parts,
-            ..
-        } = att.content_type
-        {
-            if let Some(Ok(res)) =
-                parts
-                    .iter()
-                    .find_map(|part| match Self::new_attachment(part, context) {
-                        v @ Ok(_) => Some(v),
-                        Err(_) => None,
-                    })
-            {
-                return Ok(res);
-            }
         }
         #[cfg(feature = "gpgme")]
         if let ContentType::Text {
@@ -573,11 +626,12 @@ impl ViewFilter {
                     .map_err(|err| (err, bytes))?;
                     Ok((AttachmentBuilder::new(&bytes).build(), bytes))
                 };
-                let mut job_handle = context
-                    .main_loop_handler
-                    .job_executor
-                    .spawn_specialized("gpg::decrypt".into(), decrypt_fut);
-                let on_success_notice_cb = || "Decrypted content.\n\n".into();
+                let mut job_handle = context.main_loop_handler.job_executor.spawn(
+                    "gpg::decrypt".into(),
+                    decrypt_fut,
+                    IsAsync::Blocking,
+                );
+                let on_success_notice_cb = Arc::new(|| "Decrypted content.".into());
                 let mut retval = Self {
                     filter_invocation: "gpg::decrypt".into(),
                     content_type: att.content_type.clone(),
@@ -590,11 +644,18 @@ impl ViewFilter {
                     id: ComponentId::default(),
                 };
                 if let Ok(Some(job_result)) = try_recv_timeout!(&mut job_handle.chan) {
+                    retval.body_text = ViewFilterContent::Running {
+                        job_id: job_handle.job_id,
+                        on_success_notice_cb: on_success_notice_cb.clone(),
+                        job_handle,
+                        view_settings: view_settings.clone(),
+                    };
                     retval.event_handler = None;
                     Self::process_job_result(
                         &mut retval,
                         Ok(Some(job_result)),
-                        Arc::new(on_success_notice_cb),
+                        on_success_notice_cb,
+                        view_settings,
                         context,
                     );
                     return Ok(retval);
@@ -602,22 +663,18 @@ impl ViewFilter {
                 return Ok(Self {
                     body_text: ViewFilterContent::Running {
                         job_id: job_handle.job_id,
-                        on_success_notice_cb: Arc::new(on_success_notice_cb),
+                        on_success_notice_cb,
                         job_handle,
+                        view_settings: view_settings.clone(),
                     },
                     ..retval
                 });
             }
         }
-        let notice = if att.content_type.is_text_plain() {
-            None
-        } else {
-            Some("Viewing attachment.\n\n".into())
-        };
         Ok(Self {
             filter_invocation: String::new(),
             content_type: att.content_type.clone(),
-            notice,
+            notice: None,
             body_text: ViewFilterContent::Filtered {
                 inner: att.text(Text::Plain),
             },
@@ -627,7 +684,7 @@ impl ViewFilter {
         })
     }
 
-    fn html_process_event(_self: &mut Self, event: &mut UIEvent, context: &mut Context) -> bool {
+    fn html_process_event(self_: &mut Self, event: &mut UIEvent, context: &mut Context) -> bool {
         if matches!(event, UIEvent::Input(key) if *key == context.settings.shortcuts.envelope_view.open_html)
         {
             let command = context
@@ -645,7 +702,7 @@ impl ViewFilter {
                 command
             };
             if let Some(command) = command {
-                let res = File::create_temp_file(&_self.unfiltered, None, None, Some("html"), true)
+                let res = File::create_temp_file(&self_.unfiltered, None, None, Some("html"), true)
                     .and_then(|p| {
                         let exec_cmd = desktop_exec_to_command(
                             &command,
@@ -704,83 +761,98 @@ impl ViewFilter {
         false
     }
 
-    fn job_process_event(_self: &mut Self, event: &mut UIEvent, context: &mut Context) -> bool {
+    fn job_process_event(self_: &mut Self, event: &mut UIEvent, context: &mut Context) -> bool {
         log::trace!(
-            "job_process_event: _self = {:?}, event = {:?}",
-            _self,
+            "job_process_event: self_ = {:?}, event = {:?}",
+            self_,
             event
         );
-        if matches!(event, UIEvent::StatusEvent(StatusEvent::JobFinished(ref job_id)) if _self.contains_job_id(*job_id))
+        if matches!(event, UIEvent::StatusEvent(StatusEvent::JobFinished(ref job_id)) if self_.contains_job_id(*job_id))
         {
-            if let ViewFilterContent::Running {
-                job_id: _,
-                mut job_handle,
-                on_success_notice_cb,
-            } = std::mem::replace(
-                &mut _self.body_text,
-                ViewFilterContent::Filtered {
-                    inner: String::new(),
-                },
-            ) {
-                log::trace!("job_process_event: inside if let ");
-                let job_result = job_handle.chan.try_recv();
-                Self::process_job_result(_self, job_result, on_success_notice_cb, context);
+            if matches!(self_.body_text, ViewFilterContent::Running { .. }) {
+                if let ViewFilterContent::Running {
+                    job_id: _,
+                    mut job_handle,
+                    on_success_notice_cb,
+                    view_settings,
+                } = std::mem::replace(
+                    &mut self_.body_text,
+                    ViewFilterContent::Filtered {
+                        inner: String::new(),
+                    },
+                ) {
+                    log::trace!("job_process_event: inside if let ");
+                    let job_result = job_handle.chan.try_recv();
+                    Self::process_job_result(
+                        self_,
+                        job_result,
+                        on_success_notice_cb,
+                        &view_settings,
+                        context,
+                    );
+                }
+                return true;
+            }
+            if let ViewFilterContent::InlineAttachments { ref mut parts, .. } = self_.body_text {
+                return parts
+                    .iter_mut()
+                    .any(|p| Self::job_process_event(p, event, context));
             }
-            return true;
         }
         false
     }
 
     fn process_job_result(
-        _self: &mut Self,
+        self_: &mut Self,
         result: std::result::Result<Option<FilterResult>, ::futures::channel::oneshot::Canceled>,
         on_success_notice_cb: OnSuccessNoticeCb,
+        view_settings: &ViewSettings,
         context: &Context,
     ) {
         match result {
             Err(err) => {
-                _self.event_handler = None;
+                self_.event_handler = None;
                 /* Job was cancelled */
-                _self.body_text = ViewFilterContent::Error {
+                self_.body_text = ViewFilterContent::Error {
                     inner: Error::new("Job was cancelled.").set_source(Some(Arc::new(err))),
                 };
-                _self.notice = Some(format!("{} cancelled", _self.filter_invocation).into());
+                self_.notice = Some(format!("{} cancelled", self_.filter_invocation).into());
             }
             Ok(None) => {
-                _self.event_handler = None;
+                self_.event_handler = None;
                 // something happened, perhaps a worker thread panicked
-                _self.body_text = ViewFilterContent::Error {
+                self_.body_text = ViewFilterContent::Error {
                     inner: Error::new(
                         "Unknown error. Maybe some process panicked in the background?",
                     ),
                 };
-                _self.notice = Some(format!("{} failed", _self.filter_invocation).into());
+                self_.notice = Some(format!("{} failed", self_.filter_invocation).into());
             }
             Ok(Some(Ok((att, bytes)))) => {
-                _self.event_handler = None;
+                self_.event_handler = None;
                 log::trace!("job_process_event: OK ");
-                match Self::new_attachment(&att, context) {
+                match Self::new_attachment(&att, view_settings, context) {
                     Ok(mut new_self) => {
-                        if _self.content_type.is_text_html() {
+                        if self_.content_type.is_text_html() {
                             new_self.event_handler = Some(Self::html_process_event);
                         }
                         new_self.unfiltered = bytes;
                         new_self.notice = Some(on_success_notice_cb());
-                        *_self = new_self;
+                        *self_ = new_self;
                     }
                     Err(err) => {
-                        _self.body_text = ViewFilterContent::Error { inner: err };
-                        _self.notice = Some(
-                            format!("decoding result of {} failed", _self.filter_invocation).into(),
+                        self_.body_text = ViewFilterContent::Error { inner: err };
+                        self_.notice = Some(
+                            format!("decoding result of {} failed", self_.filter_invocation).into(),
                         );
                     }
                 }
             }
             Ok(Some(Err((error, bytes)))) => {
-                _self.event_handler = None;
-                _self.body_text = ViewFilterContent::Error { inner: error };
-                _self.unfiltered = bytes;
-                _self.notice = Some(format!("{} failed", _self.filter_invocation).into());
+                self_.event_handler = None;
+                self_.body_text = ViewFilterContent::Error { inner: error };
+                self_.unfiltered = bytes;
+                self_.notice = Some(format!("{} failed", self_.filter_invocation).into());
             }
         }
     }
@@ -792,6 +864,9 @@ impl Component for ViewFilter {
         if let Some(ref mut f) = self.event_handler {
             return f(self, event, context);
         }
+        if let ViewFilterContent::InlineAttachments { ref mut parts, .. } = self.body_text {
+            return parts.iter_mut().any(|p| p.process_event(event, context));
+        }
         false
     }
 

meli/src/mail/view/html.rs

@@ -1,238 +0,0 @@
-/*
- * meli
- *
- * Copyright 2017-2018 Manos Pitsidianakis
- *
- * This file is part of meli.
- *
- * meli is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * meli is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with meli. If not, see <http://www.gnu.org/licenses/>.
- */
-
-use std::{
-    io::Write,
-    process::{Command, Stdio},
-};
-
-use melib::utils::xdg::query_default_app;
-
-use super::*;
-
-pub struct HtmlView {
-    pager: Pager,
-    bytes: Vec<u8>,
-    coordinates: Option<(AccountHash, MailboxHash, EnvelopeHash)>,
-    id: ComponentId,
-}
-
-impl std::fmt::Debug for HtmlView {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        fmt.debug_struct(melib::identify!(HtmlView))
-            .field("pager", &self.pager)
-            .field("bytes", &self.bytes.len())
-            .field("coordinates", &self.coordinates)
-            .field("id", &self.id)
-            .finish()
-    }
-}
-
-impl HtmlView {
-    pub fn new(body: &Attachment, context: &mut Context) -> Self {
-        let id = ComponentId::default();
-        let bytes: Vec<u8> = body.decode(Default::default());
-
-        let settings = &context.settings;
-        let mut display_text = if let Some(filter_invocation) = settings.pager.html_filter.as_ref()
-        {
-            let command_obj = Command::new("sh")
-                .args(["-c", filter_invocation])
-                .stdin(Stdio::piped())
-                .stdout(Stdio::piped())
-                .spawn();
-            match command_obj {
-                Err(err) => {
-                    context.replies.push_back(UIEvent::Notification {
-                        title: Some(
-                            format!("Failed to start html filter process: {}", filter_invocation,)
-                                .into(),
-                        ),
-                        source: None,
-                        body: err.to_string().into(),
-                        kind: Some(NotificationType::Error(melib::ErrorKind::External)),
-                    });
-                    String::from_utf8_lossy(&bytes).to_string()
-                }
-                Ok(mut html_filter) => {
-                    html_filter
-                        .stdin
-                        .as_mut()
-                        .unwrap()
-                        .write_all(&bytes)
-                        .expect("Failed to write to html filter stdin");
-                    let mut display_text = format!(
-                        "Text piped through `{}`. Press `v` to open in web browser. \n\n",
-                        filter_invocation
-                    );
-                    display_text.push_str(&String::from_utf8_lossy(
-                        &html_filter.wait_with_output().unwrap().stdout,
-                    ));
-                    display_text
-                }
-            }
-        } else if let Ok(mut html_filter) = Command::new("w3m")
-            .args(["-I", "utf-8", "-T", "text/html"])
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .spawn()
-        {
-            html_filter
-                .stdin
-                .as_mut()
-                .unwrap()
-                .write_all(&bytes)
-                .expect("Failed to write to html filter stdin");
-            let mut display_text =
-                String::from("Text piped through `w3m`. Press `v` to open in web browser. \n\n");
-            display_text.push_str(&String::from_utf8_lossy(
-                &html_filter.wait_with_output().unwrap().stdout,
-            ));
-
-            display_text
-        } else {
-            context.replies.push_back(UIEvent::Notification {
-                title: Some("Failed to find any application to use as html filter".into()),
-                source: None,
-                body: "".into(),
-                kind: Some(NotificationType::Error(melib::error::ErrorKind::None)),
-            });
-            String::from_utf8_lossy(&bytes).to_string()
-        };
-        if body.count_attachments() > 1 {
-            display_text =
-                body.attachments()
-                    .iter()
-                    .enumerate()
-                    .fold(display_text, |mut s, (idx, a)| {
-                        let _ = writeln!(s, "[{}] {}\n\n", idx, a);
-                        s
-                    });
-        }
-        let colors = crate::conf::value(context, "mail.view.body");
-        let pager = Pager::from_string(display_text, None, None, None, colors);
-        HtmlView {
-            pager,
-            bytes,
-            id,
-            coordinates: None,
-        }
-    }
-
-    pub fn set_coordinates(&mut self, new_value: Option<(AccountHash, MailboxHash, EnvelopeHash)>) {
-        self.coordinates = new_value;
-    }
-}
-
-impl std::fmt::Display for HtmlView {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "view")
-    }
-}
-
-impl Component for HtmlView {
-    fn draw(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
-        self.pager.draw(grid, area, context);
-    }
-
-    fn process_event(&mut self, event: &mut UIEvent, context: &mut Context) -> bool {
-        if self.pager.process_event(event, context) {
-            return true;
-        }
-
-        if let UIEvent::Input(Key::Char('v')) = event {
-            let command = if let Some(coordinates) = self.coordinates {
-                mailbox_settings!(context[coordinates.0][&coordinates.1].pager.html_open)
-                    .as_ref()
-                    .map(|s| s.to_string())
-                    .or_else(|| query_default_app("text/html").ok())
-            } else {
-                query_default_app("text/html").ok()
-            };
-            let command = if cfg!(target_os = "macos") {
-                command.or_else(|| Some("open".into()))
-            } else if cfg!(target_os = "linux") {
-                command.or_else(|| Some("xdg-open".into()))
-            } else {
-                command
-            };
-            if let Some(command) = command {
-                context
-                    .replies
-                    .push_back(UIEvent::StatusEvent(StatusEvent::UpdateSubStatus(
-                        command.to_string(),
-                    )));
-                match File::create_temp_file(&self.bytes, None, None, Some("html"), true).and_then(
-                    |p| {
-                        let exec_cmd = super::desktop_exec_to_command(
-                            &command,
-                            p.path().display().to_string(),
-                            false,
-                        );
-
-                        Ok((
-                            p,
-                            Command::new("sh")
-                                .args(["-c", &exec_cmd])
-                                .stdin(Stdio::piped())
-                                .stdout(Stdio::piped())
-                                .spawn()?,
-                        ))
-                    },
-                ) {
-                    Ok((p, child)) => {
-                        context.temp_files.push(p);
-                        context.children.push(child);
-                    }
-                    Err(err) => {
-                        context.replies.push_back(UIEvent::StatusEvent(
-                            StatusEvent::DisplayMessage(format!("Failed to start {err}",)),
-                        ));
-                    }
-                }
-            } else {
-                context
-                    .replies
-                    .push_back(UIEvent::StatusEvent(StatusEvent::DisplayMessage(
-                        "Couldn't find a default application for html files.".to_string(),
-                    )));
-            }
-            return true;
-        }
-        false
-    }
-
-    fn shortcuts(&self, context: &Context) -> ShortcutMaps {
-        self.pager.shortcuts(context)
-    }
-
-    fn is_dirty(&self) -> bool {
-        self.pager.is_dirty()
-    }
-
-    fn set_dirty(&mut self, value: bool) {
-        self.pager.set_dirty(value);
-    }
-
-    fn id(&self) -> ComponentId {
-        self.id
-    }
-}

meli/src/mail/view/state.rs

@@ -22,7 +22,9 @@
 use melib::{text::Truncate, Envelope, Error, Mail, Result};
 
 use super::{EnvelopeView, MailView, ViewSettings};
-use crate::{jobs::JoinHandle, mailbox_settings, Component, Context, ShortcutMaps, UIEvent};
+use crate::{
+    jobs::JoinHandle, mailbox_settings, Component, Context, ShortcutMaps, ThreadEvent, UIEvent,
+};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum PendingReplyAction {
@@ -39,6 +41,7 @@ pub enum MailViewState {
         pending_action: Option<PendingReplyAction>,
     },
     LoadingBody {
+        main_loop_handler: crate::MainLoopHandler,
         handle: JoinHandle<Result<Vec<u8>>>,
         pending_action: Option<PendingReplyAction>,
     },
@@ -53,6 +56,23 @@ pub enum MailViewState {
     },
 }
 
+impl Drop for MailViewState {
+    fn drop(&mut self) {
+        let Self::LoadingBody {
+            handle,
+            main_loop_handler,
+            ..
+        } = self
+        else {
+            return;
+        };
+        let Some(ev) = handle.cancel() else {
+            return;
+        };
+        main_loop_handler.send(ThreadEvent::UIEvent(UIEvent::StatusEvent(ev)));
+    }
+}
+
 impl std::fmt::Display for MailViewState {
     fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
@@ -76,17 +96,12 @@ impl MailViewState {
             return;
         };
         let account = &mut context.accounts[&coordinates.0];
-        if account
+        // Ensure all envelope headers are populated, because the email backend might
+        // have not populated them all.
+        _ = account
             .collection
-            .get_env(coordinates.2)
-            .other_headers()
-            .is_empty()
-        {
-            let _ = account
-                .collection
-                .get_env_mut(coordinates.2)
-                .populate_headers(&bytes);
-        }
+            .get_env_mut(coordinates.2)
+            .populate_headers(&bytes);
         let env = Box::new(account.collection.get_env(coordinates.2).clone());
         let env_view = Box::new(EnvelopeView::new(
             Mail {

meli/src/mail/view/thread.rs

@@ -27,7 +27,7 @@ use melib::{
 };
 
 use super::*;
-use crate::components::PageMovement;
+use crate::{components::PageMovement, conf::data_types::ThreadLayout};
 
 #[derive(Debug)]
 struct ThreadEntry {
@@ -65,7 +65,8 @@ pub struct ThreadView {
     visible_entries: Vec<Vec<usize>>,
     //indentation_colors: [ThemeAttribute; 6],
     use_color: bool,
-    horizontal: Option<bool>,
+    last_width: usize,
+    thread_layout: ThreadLayout,
     movement: Option<PageMovement>,
     dirty: bool,
     content: Screen<Virtual>,
@@ -86,6 +87,7 @@ impl ThreadView {
         focus: Option<ThreadViewFocus>,
         context: &mut Context,
     ) -> Self {
+        let theme_default = crate::conf::value(context, "theme_default");
         let mut view = Self {
             reversed: false,
             coordinates,
@@ -105,12 +107,15 @@ impl ThreadView {
             //    crate::conf::value(context, "mail.view.thread.indentation.f"),
             //],
             use_color: context.settings.terminal.use_color(),
-            horizontal: None,
+            last_width: 0,
+            thread_layout: *mailbox_settings!(
+                context[coordinates.0][&coordinates.1].listing.thread_layout
+            ),
             expanded_pos: 0,
             new_expanded_pos: 0,
             visible_entries: vec![],
             movement: None,
-            content: Screen::<Virtual>::default(),
+            content: Screen::<Virtual>::new(theme_default),
         };
         view.initiate(expanded_hash, go_to_first_unread, context);
         view.new_cursor_pos = view.new_expanded_pos;
@@ -319,24 +324,20 @@ impl ThreadView {
         let height = self.entries.len();
         let mut width = 0;
 
-        let mut highlight_reply_subjects: Vec<Option<usize>> =
-            Vec::with_capacity(self.entries.len());
         for e in &mut self.entries {
             let envelope: EnvelopeRef = context.accounts[&self.coordinates.0]
                 .collection
                 .get_env(e.msg_hash);
             let thread_node = &threads.thread_nodes()[&e.index.1];
-            let from = Address::display_name_slice(envelope.from());
+            let from = Address::display_name_slice(envelope.from(), None);
             let date = timestamp_to_string(envelope.date(), Some("%Y-%m-%d %H:%M\0"), true);
             e.heading = if thread_node.show_subject() {
                 let subject = envelope.subject();
-                highlight_reply_subjects.push(Some(subject.grapheme_width()));
                 format!(
                     "{date} {subject:`>indent$} {from}",
                     indent = 2 * e.index.0 + subject.grapheme_width(),
                 )
             } else {
-                highlight_reply_subjects.push(None);
                 format!(
                     "{date} {from:`>indent$}",
                     indent = 2 * e.index.0 + from.grapheme_width()
@@ -348,7 +349,7 @@ impl ThreadView {
             return;
         }
         let theme_default = crate::conf::value(context, "theme_default");
-        let highlight_theme = crate::conf::value(context, "highlight");
+        let highlight_theme = crate::conf::value(context, "theme_default");
         if self.reversed {
             for (y, e) in self.entries.iter().rev().enumerate() {
                 {
@@ -375,10 +376,6 @@ impl ThreadView {
                         None,
                     );
                 }
-                if highlight_reply_subjects[y].is_some() {
-                    let area = self.content.area().skip_rows(y).take_rows(1);
-                    self.content.grid_mut().change_theme(area, highlight_theme);
-                }
             }
         } else {
             for (y, e) in self.entries.iter().enumerate() {
@@ -406,10 +403,6 @@ impl ThreadView {
                         None,
                     );
                 }
-                if highlight_reply_subjects[y].is_some() {
-                    let area = self.content.area().skip_rows(y).take(width - 2, y);
-                    self.content.grid_mut().change_theme(area, highlight_theme);
-                }
             }
         }
         self.visible_entries = vec![(0..self.entries.len()).collect()];
@@ -423,24 +416,19 @@ impl ThreadView {
         idx: usize,
         context: &Context,
     ) {
-        let visibles: Vec<&usize> = self.visible_entries.iter().flat_map(|v| v.iter()).collect();
-        if idx == *visibles[self.cursor_pos] {
-            let theme_default = crate::conf::value(context, "theme_default");
-            let bg_color = crate::conf::value(context, "highlight").bg;
-            let attrs = if self.use_color {
-                theme_default.attrs
-            } else {
-                Attr::REVERSE
-            };
+        if self
+            .visible_entries
+            .iter()
+            .flat_map(|v| v.iter())
+            .nth(self.cursor_pos)
+            == Some(&idx)
+        {
+            let mut highlight = crate::conf::value(context, "highlight");
+            if self.use_color {
+                highlight.attrs |= Attr::REVERSE;
+            }
 
-            grid.change_theme(
-                dest_area,
-                ThemeAttribute {
-                    fg: theme_default.fg,
-                    bg: bg_color,
-                    attrs,
-                },
-            );
+            grid.change_theme(dest_area, highlight);
             return;
         }
 
@@ -577,11 +565,25 @@ impl ThreadView {
         context.dirty_areas.push_back(area);
     }
 
+    /// Calculate if a `ThreadLayout` value of `Auto` would be vertical.
+    fn calculate_auto_thread_layout_is_vertical(&self) -> bool {
+        if self.last_width == 0 {
+            return true;
+        }
+        // Sorry, I'm just hardcoding this for now.
+        self.content.area().width().min(self.last_width / 2) > 62
+    }
+
     fn draw_vert(&mut self, grid: &mut CellBuffer, area: Area, context: &mut Context) {
         if self.entries.is_empty() {
             return;
         }
         let mid = self.content.area().width().min(area.width() / 2);
+        if matches!(self.thread_layout, ThreadLayout::Auto)
+            && !self.calculate_auto_thread_layout_is_vertical()
+        {
+            return self.draw_horz(grid, area, context);
+        }
 
         let theme_default = crate::conf::value(context, "theme_default");
         // First draw the thread subject on the first row
@@ -793,6 +795,7 @@ impl Component for ThreadView {
         if !self.is_dirty() {
             return;
         }
+        self.last_width = area.width();
 
         // If user has selected another mail to view, change to it
         if self.new_expanded_pos != self.expanded_pos {
@@ -803,7 +806,7 @@ impl Component for ThreadView {
             self.entries[self.new_expanded_pos]
                 .mailview
                 .draw(grid, area, context);
-        } else if Some(true) == self.horizontal {
+        } else if matches!(self.thread_layout, ThreadLayout::Horizontal) {
             self.draw_horz(grid, area, context);
         } else {
             self.draw_vert(grid, area, context);
@@ -848,12 +851,29 @@ impl Component for ThreadView {
             UIEvent::Input(ref key)
                 if shortcut!(key == shortcuts[Shortcuts::THREAD_VIEW]["toggle_layout"]) =>
             {
-                if let Some(ref mut v) = self.horizontal {
-                    *v = !*v;
-                } else {
-                    self.horizontal = Some(true);
+                if self.entries.len() > 1 {
+                    match self.thread_layout {
+                        ThreadLayout::Auto if self.calculate_auto_thread_layout_is_vertical() => {
+                            self.thread_layout = ThreadLayout::Horizontal;
+                        }
+                        ThreadLayout::Auto => {
+                            self.thread_layout = ThreadLayout::Vertical;
+                        }
+                        ThreadLayout::Horizontal => {
+                            self.thread_layout = ThreadLayout::Auto;
+                        }
+                        ThreadLayout::Vertical => {
+                            self.thread_layout = ThreadLayout::Horizontal;
+                        }
+                    }
+                    context
+                        .replies
+                        .push_back(UIEvent::StatusEvent(StatusEvent::UpdateSubStatus(format!(
+                            "thread_layout set to {}",
+                            toml::Value::try_from(self.thread_layout).expect("Cannot fail")
+                        ))));
+                    self.set_dirty(true);
                 }
-                self.set_dirty(true);
                 true
             }
             UIEvent::Input(ref key)

meli/src/mail/view/utils.rs

@@ -24,7 +24,11 @@ use std::{fs::File, io::Write, os::unix::fs::PermissionsExt, path::Path};
 use melib::{Result, ShellExpandTrait};
 
 pub fn save_attachment(path: &Path, bytes: &[u8]) -> Result<()> {
-    let mut f = File::create(path.expand())?;
+    let mut f = File::options()
+        .read(true)
+        .write(true)
+        .create_new(true)
+        .open(path.expand())?;
     let mut permissions = f.metadata()?.permissions();
     permissions.set_mode(0o600); // Read/write for owner only.
     f.set_permissions(permissions)?;

meli/src/mailcap.rs

@@ -21,21 +21,28 @@
 
 //! # mailcap file - Find mailcap entries to execute attachments.
 //!
-//! Implements [RFC 1524 A User Agent Configuration Mechanism For Multimedia
+//! Implements [RFC1524 A User Agent Configuration Mechanism For Multimedia
 //! Mail Format Information](https://www.rfc-editor.org/rfc/inline-errata/rfc1524.html)
+
 use std::{
     io::{Read, Write},
     path::PathBuf,
     process::{Command, Stdio},
 };
 
-use melib::{email::Attachment, log, text::GlobMatch, Error, Result};
+use melib::{email::Attachment, log, utils::fnmatch::Fnmatch, Error, Result};
 
 use crate::{
     state::Context,
     types::{File, ForkType, UIEvent},
 };
 
+macro_rules! split_command {
+    ($cmd:expr) => {{
+        $cmd.split_whitespace().collect::<Vec<&str>>()
+    }};
+}
+
 pub struct MailcapEntry {
     command: String,
     /* Pass to pager */
@@ -98,7 +105,7 @@ impl MailcapEntry {
                 let key = parts_iter.next().unwrap();
                 let cmd = parts_iter.next().unwrap();
                 //let flags = parts_iter.next().unwrap();
-                if key.starts_with(&content_type) || key.matches_glob(&content_type) {
+                if key.starts_with(&content_type) || key.fnmatches(&content_type) {
                     let mut copiousoutput = false;
                     #[allow(clippy::while_let_on_iterator)]
                     while let Some(flag) = parts_iter.next() {
@@ -120,7 +127,7 @@ impl MailcapEntry {
                 let key = parts_iter.next().unwrap();
                 let cmd = parts_iter.next().unwrap();
                 //let flags = parts_iter.next().unwrap();
-                if key.starts_with(&content_type) || key.matches_glob(&content_type) {
+                if key.starts_with(&content_type) || key.fnmatches(&content_type) {
                     let mut copiousoutput = false;
                     #[allow(clippy::while_let_on_iterator)]
                     while let Some(flag) = parts_iter.next() {
@@ -160,14 +167,14 @@ impl MailcapEntry {
                     .map(|arg| match *arg {
                         "%s" => {
                             needs_stdin = false;
-                            let _f = File::create_temp_file(
+                            let file = File::create_temp_file(
                                 &a.decode(Default::default()),
                                 None,
                                 None,
                                 None,
-                                true,
+                                false,
                             )?;
-                            let p = _f.path().display().to_string();
+                            let p = file.path().display().to_string();
                             Ok(p)
                         }
                         "%t" => Ok(a.content_type().to_string()),