ferrous-forge 1.9.4

System-wide Rust development standards enforcer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! Publish validation checking

use crate::Result;
use std::path::Path;
use std::process::Command;
use std::time::Instant;

use super::SafetyCheck;
use crate::safety::{CheckType, report::CheckResult};

/// Publish dry run check implementation
pub struct PublishCheck;

impl SafetyCheck for PublishCheck {
    async fn run(project_path: &Path) -> Result<CheckResult> {
        run(project_path).await
    }

    fn name() -> &'static str {
        "publish"
    }

    fn description() -> &'static str {
        "Validates crates.io publication readiness"
    }
}

/// Run cargo publish --dry-run
///
/// # Errors
///
/// Returns an error if the `cargo publish --dry-run` command fails to execute.
pub async fn run(project_path: &Path) -> Result<CheckResult> {
    let start = Instant::now();
    let mut result = CheckResult::new(CheckType::PublishDryRun);

    // Run cargo publish --dry-run
    let output = Command::new("cargo")
        .current_dir(project_path)
        .args(&["publish", "--dry-run"])
        .output()?;

    result.set_duration(start.elapsed());

    if !output.status.success() {
        handle_publish_failure(&mut result, &output.stderr);
    } else {
        handle_publish_success(&mut result, &output.stderr);
    }

    Ok(result)
}

/// Handle publish dry run failure
fn handle_publish_failure(result: &mut CheckResult, stderr: &[u8]) {
    result.add_error("Publish dry run failed");
    result.add_suggestion("Fix publish issues before attempting real publish");

    parse_publish_errors(result, stderr);

    result.add_suggestion("Run 'cargo publish --dry-run' to see detailed output");
    result.add_suggestion("Check Cargo.toml metadata and file inclusions");
}

/// Parse publish errors from stderr
fn parse_publish_errors(result: &mut CheckResult, stderr: &[u8]) {
    let stderr = String::from_utf8_lossy(stderr);
    let mut error_count = 0;

    for line in stderr.lines() {
        if line.starts_with("error:") && error_count < 3 {
            result.add_error(format!("Publish: {}", line.trim()));
            error_count += 1;
        } else if line.contains("warning:") && line.contains("ignoring") {
            result.add_context(line.trim().to_string());
        }
    }

    if error_count >= 3 {
        result.add_error("... and more publish errors (showing first 3)");
    }
}

/// Handle publish dry run success
fn handle_publish_success(result: &mut CheckResult, stderr: &[u8]) {
    result.add_context("Ready for crates.io publication");

    // Check for warnings in successful dry run
    let stderr = String::from_utf8_lossy(stderr);
    let warning_count = stderr
        .lines()
        .filter(|line| line.starts_with("warning:"))
        .count();

    if warning_count > 0 {
        result.add_context(format!(
            "Publish dry run completed with {} warnings",
            warning_count
        ));
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
    use super::*;

    #[test]
    fn test_publish_check_struct() {
        assert_eq!(PublishCheck::name(), "publish");
        assert!(!PublishCheck::description().is_empty());
    }
}