Cargo binstall support

.github/workflows/release.yml

@@ -18,10 +18,12 @@ jobs:
             arch: x86_64
             target: x86_64-unknown-linux-gnu
             ext: ""
+            cargo_binstall_archive: true
           - os: linux
             arch: aarch64
             target: aarch64-unknown-linux-gnu
             ext: ""
+            cargo_binstall_archive: true
 #          - os: windows
 #            arch: x86_64
 #            target: x86_64-pc-windows-msvc
@@ -42,6 +44,7 @@ jobs:
             arch: x86_64
             target: x86_64-unknown-freebsd
             ext: ""
+            cargo_binstall_archive: false
 #          - os: freebsd
 #            arch: aarch64
 #            target: aarch64-unknown-freebsd
@@ -104,11 +107,24 @@ jobs:
         run: cross +stable build --release --target ${{ matrix.target }}
       - name: Prepare artifact
         run: |
-          mkdir -p artifacts/${{ matrix.os }}-${{ matrix.arch }}
-          cp target/${{ matrix.target }}/release/${{ env.REPO_NAME }}${{ matrix.ext }} \
-            artifacts/${{ matrix.os }}-${{ matrix.arch }}/${{ env.REPO_NAME }}-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.ext }}
-          sha256sum artifacts/${{ matrix.os }}-${{ matrix.arch }}/${{ env.REPO_NAME }}-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.ext }} > \
-            artifacts/${{ matrix.os }}-${{ matrix.arch }}/${{ env.REPO_NAME }}-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.ext }}.sha256
+          set -euo pipefail
+          version="${GITHUB_REF_NAME#v}"
+          artifact_dir="artifacts/${{ matrix.os }}-${{ matrix.arch }}"
+          binary_path="target/${{ matrix.target }}/release/${{ env.REPO_NAME }}${{ matrix.ext }}"
+          binary_name="${{ env.REPO_NAME }}-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.ext }}"
+
+          mkdir -p "${artifact_dir}"
+          cp "${binary_path}" "${artifact_dir}/${binary_name}"
+          sha256sum "${artifact_dir}/${binary_name}" > \
+            "${artifact_dir}/${binary_name}.sha256"
+
+          if [ "${{ matrix.cargo_binstall_archive }}" = "true" ]; then
+            archive_name="${{ env.REPO_NAME }}-${version}-${{ matrix.target }}.tar.gz"
+            tar -C "target/${{ matrix.target }}/release" -czf \
+              "${artifact_dir}/${archive_name}" "${{ env.REPO_NAME }}${{ matrix.ext }}"
+            sha256sum "${artifact_dir}/${archive_name}" > \
+              "${artifact_dir}/${archive_name}.sha256"
+          fi
       - name: Upload release artifact
         uses: actions/upload-artifact@v4
         with:

Cargo.toml

@@ -4,10 +4,18 @@ version = "0.3.1"
 edition = "2024"
 rust-version = "1.89"
 license = "ISC"
+repository = "https://github.com/leynos/mdtablefix"
 description = """
 `mdtablefix` unb0rks and reflows Markdown tables so that each column has a uniform width. When \
 the `--wrap` option is used, it also wraps paragraphs and list items to 80 columns."""
 
+[package.metadata.binstall]
+
+[package.metadata.binstall.overrides.'cfg(all(target_os = "linux", any(target_arch = "x86_64", target_arch = "aarch64"), target_env = "gnu"))']
+pkg-url = "{ repo }/releases/download/v{ version }/{ name }-{ version }-{ target }.tar.gz"
+bin-dir = "{ bin }{ binary-ext }"
+pkg-fmt = "tgz"
+
 [dependencies]
 anyhow = "1"
 clap = { version = "4", features = ["derive"] }

README.md

@@ -17,6 +17,13 @@ Install via Cargo:
 cargo install mdtablefix
 ```
 
+On Linux `x86_64-unknown-linux-gnu` and `aarch64-unknown-linux-gnu`, install
+the prebuilt release archive via `cargo-binstall`:
+
+```bash
+cargo binstall mdtablefix
+```
+
 Or clone the repository and build from source:
 
 ```bash

docs/release-process.md

@@ -1,7 +1,8 @@
 # Release Process
 
 This project publishes prebuilt binaries for multiple operating systems and
-architectures.
+architectures. It also publishes `cargo-binstall` archives for the supported
+Linux release targets.
 
 The project targets the stable Rust `1.89.0` toolchain, as specified in
 `rust-toolchain.toml`.
@@ -14,10 +15,7 @@ The GitHub Actions workflow `.github/workflows/release.yml` builds and uploads
 binaries for:
 
 - Linux (x86_64 and aarch64)
-- FreeBSD (x86_64 and aarch64)
-- macOS (x86_64 and aarch64)
-- Windows (x86_64 and aarch64)
-- OpenBSD (x86_64 and aarch64)
+- FreeBSD (x86_64)
 
 Releases start from tags named `v<major>.<minor>.<patch>`. The workflow checks
 that the tag's version, without the leading `v`, matches the `Cargo.toml`
@@ -26,20 +24,28 @@ that the tag's version, without the leading `v`, matches the `Cargo.toml`
 Each binary is named using the pattern `mdtablefix-<os>-<arch>` with an `.exe`
 suffix on Windows.
 
+For Linux `x86_64-unknown-linux-gnu` and `aarch64-unknown-linux-gnu`, the
+workflow also produces `cargo-binstall` archives named
+`mdtablefix-<version>-<target>.tar.gz`. Each archive contains the `mdtablefix`
+binary at the archive root, matching the `Cargo.toml`
+`[package.metadata.binstall]` configuration.
+
 Binaries are uploaded as soon as they are built, so they are available from the
 workflow run while other targets build.
 
 ## Workflow details
 
 The `release.yml` workflow defines a matrix of operating system and
 architecture combinations. Each entry includes the target triple used by
-`cross` and a filename extension for Windows. During the build job, `cross`
-compiles a release binary for every matrix row.
+`cross` and whether the target also needs a `cargo-binstall` archive. During
+the build job, `cross` compiles a release binary for every matrix row.
 
 `cross` is installed from a specific git tag to avoid unexpected behaviour from
 its main branch. Each binary is placed in an `artifacts/<os>-<arch>` directory
 using the naming pattern `mdtablefix-<os>-<arch>[.exe]`. An SHA-256 checksum is
-written alongside each binary for download verification.
+written alongside each binary for download verification. The Linux
+`cargo-binstall` targets additionally produce
+`mdtablefix-<version>-<target>.tar.gz` plus a matching SHA-256 checksum.
 
 After every build completes, the artefact is uploaded so that the GitHub
 Actions interface provides it immediately. Once the matrix has finished, the

src/code_emphasis.rs

@@ -10,6 +10,8 @@
 //! transformation should run before wrapping and footnote conversion so marker
 //! adjacency is evaluated on the raw input.
 
+use std::{iter::Peekable, vec::IntoIter};
+
 use crate::{
     textproc::process_text,
     wrap::{Token, tokenize_markdown},
@@ -49,6 +51,103 @@ fn push_code(code: &str, out: &mut String) {
     out.push_str(&fence);
 }
 
+fn has_code_emphasis_adjacent(source: &str) -> bool {
+    source.contains("`*") || source.contains("`_") || source.contains("*`") || source.contains("_`")
+}
+
+fn handle_text_token<'a>(
+    raw: &'a str,
+    next: Option<&Token<'a>>,
+    out: &mut String,
+    pending: &mut &'a str,
+) {
+    if !next.is_some_and(|token| matches!(token, Token::Code { .. })) {
+        out.push_str(raw);
+        return;
+    }
+
+    let (lead, body, trail) = split_marks(raw);
+    if body.is_empty() && trail.is_empty() {
+        *pending = lead;
+        return;
+    }
+
+    out.push_str(lead);
+    out.push_str(body);
+    *pending = trail;
+}
+
+fn try_fold_matching_emphasis<'a>(
+    tokens: &mut Peekable<IntoIter<Token<'a>>>,
+    pending: &mut &'a str,
+    code: &str,
+    out: &mut String,
+) -> bool {
+    let Some(Token::Text(next)) = tokens.peek() else {
+        return false;
+    };
+    let (lead, mid, trail) = split_marks(next);
+    if *pending == lead && mid.is_empty() && trail.is_empty() {
+        out.push_str(pending);
+        push_code(code, out);
+        out.push_str(lead);
+        *pending = "";
+        tokens.next();
+        return true;
+    }
+    false
+}
+
+fn consume_code_affixes<'a>(
+    tokens: &mut Peekable<IntoIter<Token<'a>>>,
+    pending: &mut &'a str,
+) -> (&'a str, &'a str, bool) {
+    let mut prefix = std::mem::take(pending);
+    let mut suffix = "";
+    let mut modified = !prefix.is_empty();
+
+    let Some(Token::Text(next)) = tokens.peek_mut() else {
+        return (prefix, suffix, modified);
+    };
+
+    let (lead, mid, _) = split_marks(next);
+    if lead.is_empty() {
+        return (prefix, suffix, modified);
+    }
+
+    modified = true;
+    if prefix.is_empty() {
+        prefix = lead;
+    } else if mid.is_empty() {
+        suffix = lead;
+    } else {
+        prefix = "";
+    }
+    *next = &next[lead.len()..];
+    (prefix, suffix, modified)
+}
+
+fn handle_code_token<'a>(
+    tokens: &mut Peekable<IntoIter<Token<'a>>>,
+    code_token: (&'a str, &'a str),
+    out: &mut String,
+    pending: &mut &'a str,
+) {
+    let (raw, code) = code_token;
+    if !pending.is_empty() && try_fold_matching_emphasis(tokens, pending, code, out) {
+        return;
+    }
+
+    let (prefix, suffix, modified) = consume_code_affixes(tokens, pending);
+    out.push_str(prefix);
+    if modified {
+        push_code(code, out);
+    } else {
+        out.push_str(raw);
+    }
+    out.push_str(suffix);
+}
+
 /// Merge contiguous code and emphasis spans.
 ///
 /// Groups of emphasis markers and inline code with no separating spaces are
@@ -75,78 +174,17 @@ pub fn fix_code_emphasis(lines: &[String]) -> Vec<String> {
         return vec![String::new(); lines.len()];
     }
     let source = lines.join("\n");
-    if !source.contains("`*")
-        && !source.contains("`_")
-        && !source.contains("*`")
-        && !source.contains("_`")
-    {
+    if !has_code_emphasis_adjacent(&source) {
         return lines.to_vec();
     }
     let mut tokens = tokenize_markdown(&source).into_iter().peekable();
     let mut out = String::new();
     let mut pending = "";
     while let Some(token) = tokens.next() {
         match token {
-            Token::Text(raw) => {
-                if tokens
-                    .peek()
-                    .is_some_and(|t| matches!(t, Token::Code { .. }))
-                {
-                    let (lead, body, trail) = split_marks(raw);
-                    if body.is_empty() && trail.is_empty() {
-                        pending = lead;
-                    } else {
-                        out.push_str(lead);
-                        out.push_str(body);
-                        pending = trail;
-                    }
-                } else {
-                    out.push_str(raw);
-                }
-            }
+            Token::Text(raw) => handle_text_token(raw, tokens.peek(), &mut out, &mut pending),
             Token::Code { raw, code, .. } => {
-                if !pending.is_empty()
-                    && let Some(Token::Text(next)) = tokens.peek()
-                {
-                    let (lead, mid, trail) = split_marks(next);
-                    if mid.is_empty() && trail.is_empty() && lead == pending {
-                        out.push_str(pending);
-                        push_code(code, &mut out);
-                        out.push_str(lead);
-                        pending = "";
-                        tokens.next();
-                        continue;
-                    }
-                }
-                let mut prefix = pending;
-                let mut suffix = "";
-                let mut modified = !pending.is_empty();
-                pending = "";
-                if let Some(Token::Text(next)) = tokens.peek_mut() {
-                    let (lead, mid, _) = split_marks(next);
-                    if !lead.is_empty() {
-                        modified = true;
-                        if prefix.is_empty() {
-                            prefix = lead;
-                        } else if mid.is_empty() {
-                            suffix = lead;
-                        } else {
-                            prefix = "";
-                        }
-                        *next = &next[lead.len()..];
-                    }
-                }
-                if !prefix.is_empty() {
-                    out.push_str(prefix);
-                }
-                if modified {
-                    push_code(code, &mut out);
-                } else {
-                    out.push_str(raw);
-                }
-                if !suffix.is_empty() {
-                    out.push_str(suffix);
-                }
+                handle_code_token(&mut tokens, (raw, code), &mut out, &mut pending);
             }
             Token::Fence(f) => out.push_str(f),
             Token::Newline => out.push('\n'),

src/fences.rs

@@ -120,6 +120,24 @@ fn attach_specifier_to_fence(fence_line: &str, specifier: &str, spec_indent: &st
     format!("{final_indent}```{specifier}")
 }
 
+fn orphan_specifier_target(lines: &[String], start: usize) -> Option<usize> {
+    let mut index = start;
+    while index < lines.len() && lines[index].trim().is_empty() {
+        index += 1;
+    }
+    if index >= lines.len() || FENCE_RE.captures(&lines[index]).is_none() {
+        return None;
+    }
+    Some(index)
+}
+
+fn orphan_specifier_target_without_language(lines: &[String], start: usize) -> Option<usize> {
+    let target = orphan_specifier_target(lines, start)?;
+    let cap = FENCE_RE.captures(&lines[target])?;
+    let lang = cap.get(3).map_or("", |m| m.as_str());
+    is_null_lang(lang).then_some(target)
+}
+
 /// Attach orphaned language specifiers to opening fences.
 ///
 /// After compressing fences, a language may appear on its own line directly
@@ -156,19 +174,10 @@ pub fn attach_orphan_specifiers(lines: &[String]) -> Vec<String> {
         let (spec, indent) = normalize_specifier(line);
         if ORPHAN_LANG_RE.is_match(&spec) && out.last().is_none_or(|l: &String| l.trim().is_empty())
         {
-            let mut j = i + 1;
-            while j < lines.len() && lines[j].trim().is_empty() {
-                j += 1;
-            }
-            if j < lines.len()
-                && let Some(cap) = FENCE_RE.captures(&lines[j])
-            {
-                let lang = cap.get(3).map_or("", |m| m.as_str());
-                if is_null_lang(lang) {
-                    out.push(attach_specifier_to_fence(&lines[j], &spec, &indent));
-                    i = j + 1;
-                    continue;
-                }
+            if let Some(target) = orphan_specifier_target_without_language(lines, i + 1) {
+                out.push(attach_specifier_to_fence(&lines[target], &spec, &indent));
+                i = target + 1;
+                continue;
             }
             out.push(line.clone());
             i += 1;