diagprint 0.7.1

#!/usr/bin/env bash

mode="${1:-full}"
msrv="1.85.0"

packages=(
    diagprint
    diagprint-derive
    diagprint-lsp
    diagprint-async
    diagprint-otel
    diagprint-test
)

root_features=(
    artifact-store
    derive
    compression
    cybercore
    html
    terminal-docs
    anyhow
    tracing
    miette
    codespan-reporting
    ariadne
    annotate-snippets
)

print_rule() {
    printf '%*s\n' 72 '' | tr ' ' '='
}

run_gate() {
    local name="$1"
    shift

    echo
    print_rule
    echo " GATE: $name"
    print_rule
    echo

    "$@"
    local status=$?

    if [[ $status -ne 0 ]]; then
        echo
        echo "FAILED: $name"
        echo "Exit status: $status"
        exit "$status"
    fi

    echo
    echo "PASS: $name"
}

require_command() {
    local command_name="$1"

    if ! command -v "$command_name" >/dev/null 2>&1; then
        echo "error: required command not found: $command_name" >&2
        exit 127
    fi
}

require_repo_root() {
    if [[ ! -f Cargo.toml ]]; then
        echo "error: run this script from the diagprint repository root" >&2
        exit 1
    fi

    if [[ ! -f crates/diagprint-derive/Cargo.toml ]]; then
        echo "error: this does not appear to be the diagprint workspace" >&2
        exit 1
    fi
}

require_clean_tree() {
    local status_output

    status_output="$(git status --porcelain)"

    if [[ -n "$status_output" ]]; then
        echo
        print_rule
        echo " RELEASE TREE IS NOT CLEAN"
        print_rule
        echo
        printf '%s\n' "$status_output"
        echo
        echo "Release dry-runs must be executed from a clean committed tree."
        exit 1
    fi

    echo
    echo "PASS: working tree is clean"
}

check_msrv_toolchain() {
    if ! rustup toolchain list | grep -Eq "^${msrv}([[:space:]-]|$)"; then
        echo
        echo "error: Rust $msrv toolchain is not installed" >&2
        echo
        echo "Install it with:"
        echo
        echo "  rustup toolchain install $msrv"
        exit 1
    fi
}

check_core_package_hygiene() {
    local package_list
    local status

    package_list="$(
        cargo package \
            --allow-dirty \
            --list \
            -p diagprint
    )"
    status=$?

    if [[ $status -ne 0 ]]; then
        echo
        echo "FAILED: unable to inspect diagprint package contents"
        exit "$status"
    fi

    if grep -Eq '^\.diagprint(/|$)' <<<"$package_list"; then
        echo
        echo "FAILED: .diagprint generated state is present in the package"
        exit 1
    fi

    if grep -Eq '^reports(/|$)' <<<"$package_list"; then
        echo
        echo "FAILED: generated reports are present in the package"
        exit 1
    fi

    echo
    echo "PASS: .diagprint is excluded"
    echo "PASS: reports are excluded"
}

run_quick_gates() {
    run_gate \
        "Unstaged whitespace" \
        git diff --check

    run_gate \
        "Staged whitespace" \
        git diff --cached --check

    run_gate \
        "Formatting" \
        cargo fmt --all -- --check

    run_gate \
        "Workspace check" \
        cargo check \
            --workspace \
            --all-targets \
            --all-features

    run_gate \
        "Workspace Clippy" \
        cargo clippy \
            --workspace \
            --all-targets \
            --all-features \
            -- \
            -D warnings

    run_gate \
        "diagprint-derive UI contract" \
        cargo test \
            -p diagprint-derive \
            --test ui
}

run_full_gates() {
    run_quick_gates

    run_gate \
        "Workspace tests" \
        cargo test \
            --workspace \
            --all-targets \
            --all-features

    run_gate \
        "Workspace doctests" \
        cargo test \
            --workspace \
            --doc \
            --all-features

    run_gate \
        "Strict rustdoc" \
        env RUSTDOCFLAGS="-D warnings" \
        cargo doc \
            --workspace \
            --no-deps \
            --all-features

    echo
    print_rule
    echo " ROOT FEATURE MATRIX"
    print_rule

    local feature

    for feature in "${root_features[@]}"; do
        run_gate \
            "Feature: $feature" \
            cargo check \
                -p diagprint \
                --no-default-features \
                --features "$feature" \
                --all-targets
    done

    run_gate \
        "Tracing integration in isolation" \
        cargo test \
            -p diagprint \
            --no-default-features \
            --features tracing \
            --test tracing_integration

    echo
    print_rule
    echo " PACKAGE CONTENTS"
    print_rule

    local package

    for package in "${packages[@]}"; do
        run_gate \
            "Package contents: $package" \
            cargo package \
                --allow-dirty \
                --list \
                -p "$package"
    done

    echo
    print_rule
    echo " GENERATED STATE EXCLUSION"
    print_rule

    check_core_package_hygiene

    check_msrv_toolchain

    run_gate \
        "MSRV workspace check" \
        cargo +"$msrv" check \
            --workspace \
            --all-targets \
            --all-features

    run_gate \
        "MSRV workspace tests" \
        cargo +"$msrv" test \
            --workspace \
            --all-targets \
            --all-features

    run_gate \
        "MSRV doctests" \
        cargo +"$msrv" test \
            --workspace \
            --doc \
            --all-features

    run_gate \
        "MSRV strict rustdoc" \
        env RUSTDOCFLAGS="-D warnings" \
        cargo +"$msrv" doc \
            --workspace \
            --no-deps \
            --all-features
}

run_derive_release() {
    run_full_gates

    echo
    print_rule
    echo " DIAGPRINT-DERIVE RELEASE GATE"
    print_rule

    require_clean_tree

    run_gate \
        "diagprint-derive package verification" \
        cargo package \
            -p diagprint-derive

    run_gate \
        "diagprint-derive publish dry run" \
        cargo publish \
            --dry-run \
            -p diagprint-derive
}

run_core_release() {
    run_full_gates

    echo
    print_rule
    echo " DIAGPRINT CORE RELEASE GATE"
    print_rule

    require_clean_tree

    run_gate \
        "diagprint package verification" \
        cargo package \
            -p diagprint

    run_gate \
        "diagprint publish dry run" \
        cargo publish \
            --dry-run \
            -p diagprint
}

run_satellite_release() {
    run_full_gates

    echo
    print_rule
    echo " COMPANION CRATE RELEASE GATE"
    print_rule

    require_clean_tree

    local satellites=(
        diagprint-lsp
        diagprint-async
        diagprint-otel
        diagprint-test
    )

    local package

    for package in "${satellites[@]}"; do
        run_gate \
            "$package package verification" \
            cargo package \
                -p "$package"

        run_gate \
            "$package publish dry run" \
            cargo publish \
                --dry-run \
                -p "$package"
    done
}

require_command cargo
require_command git
require_command rustup
require_repo_root

echo
print_rule
echo " DIAGPRINT RELEASE GATES"
print_rule
echo
echo "Mode       : $mode"
echo "Repository : $(pwd)"
echo "Revision   : $(git rev-parse --short HEAD)"
echo "Branch     : $(git branch --show-current)"
echo "MSRV       : $msrv"

case "$mode" in
    quick)
        run_quick_gates
        ;;

    full)
        run_full_gates
        ;;

    derive)
        run_derive_release
        ;;

    core)
        run_core_release
        ;;

    satellites)
        run_satellite_release
        ;;

    *)
        echo
        echo "Usage:"
        echo "  ./scripts/release-gates quick"
        echo "  ./scripts/release-gates full"
        echo "  ./scripts/release-gates derive"
        echo "  ./scripts/release-gates core"
        echo "  ./scripts/release-gates satellites"
        echo
        exit 2
        ;;
esac

echo
print_rule
echo " ALL REQUESTED DIAGPRINT GATES GREEN"
print_rule
echo