unfk 1.1.0

A fast, modern CLI tool for scanning and repairing file formatting issues
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

//! Output formatting and reporting

use std::path::Path;

use colored::Colorize;

use crate::analysis::Issue;
use crate::cli::Cli;

/// Reporter handles all output formatting
pub struct Reporter<'a> {
    cli: &'a Cli,
}

impl<'a> Reporter<'a> {
    pub fn new(cli: &'a Cli) -> Self {
        // Disable colors if requested
        if cli.no_color {
            colored::control::set_override(false);
        }

        Self { cli }
    }

    /// Report issues found in a file
    ///
    /// Errors (fixable issues) are shown in red, warnings (unfixable) in yellow.
    pub fn report_file_issues(&self, path: &Path, issues: &[Issue]) {
        if self.cli.quiet {
            return;
        }

        println!("{}", path.display().to_string().bold());
        for issue in issues {
            if issue.is_fixable() {
                // Errors (fixable) - shown in red
                println!(
                    "  {} {}",
                    "error:".red().bold(),
                    issue.description().red()
                );
            } else {
                // Warnings (unfixable) - shown in yellow
                println!(
                    "  {} {}",
                    "warning:".yellow().bold(),
                    issue.description().yellow()
                );
            }
        }
    }

    /// Report that a file has no issues (verbose only)
    pub fn report_file_ok(&self, path: &Path) {
        if !self.cli.verbose || self.cli.quiet {
            return;
        }

        println!("{} {}", "✓".green(), path.display());
    }

    /// Report an error processing a file
    pub fn report_error(&self, path: &Path, error: &anyhow::Error) {
        if self.cli.quiet {
            return;
        }

        eprintln!(
            "{} {}: {}",
            "error:".red().bold(),
            path.display(),
            error
        );
    }

    /// Report what would be fixed (dry-run mode)
    pub fn report_would_fix(&self, path: &Path, issues: &[Issue]) {
        if self.cli.quiet {
            return;
        }

        println!("{} {}", "Would fix:".blue(), path.display());
        if self.cli.verbose {
            for issue in issues {
                println!("  {} {}", "•".yellow(), issue.description());
            }
        }
    }

    /// Report that a file was fixed
    pub fn report_fixed(&self, path: &Path, issues: &[Issue]) {
        if self.cli.quiet {
            return;
        }

        println!("{} {}", "Fixed:".green(), path.display());
        if self.cli.verbose {
            for issue in issues {
                println!("  {} {}", "•".yellow(), issue.description());
            }
        }
    }

    /// Report scan summary with separate error and warning counts
    pub fn report_summary(
        &self,
        files_with_issues: usize,
        error_count: usize,
        warning_count: usize,
    ) {
        if self.cli.quiet {
            return;
        }

        println!();
        let total_issues = error_count + warning_count;
        if total_issues == 0 {
            println!("{}", "No issues found.".green());
        } else {
            // Build summary message with separate error/warning counts
            let mut parts = Vec::new();
            if error_count > 0 {
                parts.push(format!("{} errors", error_count).red().to_string());
            }
            if warning_count > 0 {
                parts.push(format!("{} warnings", warning_count).yellow().to_string());
            }
            println!(
                "Found {} in {} files.",
                parts.join(", "),
                files_with_issues
            );
        }
    }

    /// Report fix summary
    pub fn report_fix_summary(&self, fixed: usize, failed: usize, dry_run: bool) {
        if self.cli.quiet {
            return;
        }

        println!();
        if dry_run {
            if fixed == 0 {
                println!("{}", "No files would be modified.".green());
            } else {
                println!(
                    "{}",
                    format!("Would fix {} files.", fixed).blue()
                );
            }
        } else {
            if fixed > 0 {
                println!(
                    "{}",
                    format!("Fixed {} files.", fixed).green()
                );
            }
            if failed > 0 {
                println!(
                    "{}",
                    format!("Failed to fix {} files.", failed).red()
                );
            }
            if fixed == 0 && failed == 0 {
                println!("{}", "No files needed fixing.".green());
            }
        }
    }
}