linthis 0.16.0

A fast, cross-platform multi-language linter and formatter
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

// Copyright 2024 zhlinh and linthis Project Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found at
//
// https://opensource.org/license/MIT
//
// The above copyright notice and this permission
// notice shall be included in all copies or
// substantial portions of the Software.

//! Format subcommand handler for running formatters with backup support.
//!
//! This module handles the `format` subcommand, supporting:
//! - Running formatters on files with automatic backup
//! - Undo (restore from backup)
//! - Listing available backups

use colored::Colorize;
use std::path::PathBuf;
use std::process::ExitCode;

use crate::cli::backup::{create_backup, handle_list_backups, handle_undo};
use crate::cli::paths::{collect_paths, PathCollectionOptions, PathCollectionResult};
use linthis::{RunMode, RunOptions};

/// Options for the format subcommand
pub struct FormatCommandOptions {
    /// Files or directories to include
    pub paths: Vec<PathBuf>,
    /// Format only staged files
    pub staged: bool,
    /// Format only modified files (staged + unstaged)
    pub modified: bool,
    /// Exclude patterns
    pub exclude: Option<Vec<String>>,
    /// Undo last format
    pub undo: bool,
    /// Backup source for undo
    pub source: String,
    /// List available backups
    pub list_backups: bool,
    /// Verbose output
    pub verbose: bool,
    /// Quiet mode
    pub quiet: bool,
}

/// Handle the format subcommand
pub fn handle_format_command(options: FormatCommandOptions) -> ExitCode {
    // Handle --list-backups
    if options.list_backups {
        return handle_list_backups("linthis format");
    }

    // Handle --undo
    if options.undo {
        return handle_undo(&options.source, "linthis format --list-backups");
    }

    // Collect files to format
    let path_options = PathCollectionOptions {
        paths: options.paths,
        staged: options.staged,
        since: None,
        modified: options.modified,
        exclude: options.exclude.unwrap_or_default(),
        no_default_excludes: false,
        no_gitignore: false,
        verbose: options.verbose,
    };

    let files = match collect_paths(&path_options) {
        PathCollectionResult::Success(files, _excludes) => files,
        PathCollectionResult::Empty(msg) => {
            if !options.quiet {
                println!("{} {}", "→".cyan(), msg);
            }
            return ExitCode::SUCCESS;
        }
        PathCollectionResult::Error(msg, code) => {
            eprintln!("{}: {}", "Error".red(), msg);
            return ExitCode::from(code as u8);
        }
    };

    if files.is_empty() {
        if !options.quiet {
            println!("{} No files to format.", "→".cyan());
        }
        return ExitCode::SUCCESS;
    }

    if !options.quiet {
        println!(
            "{} Formatting {} file{}...",
            "→".cyan(),
            files.len(),
            if files.len() == 1 { "" } else { "s" }
        );
    }

    // Create backup before formatting
    create_backup(&files, "format (linthis format)", options.quiet);

    // Run format-only mode
    let run_options = RunOptions {
        paths: files,
        mode: RunMode::FormatOnly,
        verbose: options.verbose,
        quiet: options.quiet,
        ..Default::default()
    };

    match linthis::run(&run_options) {
        Ok(result) => {
            let formatted_count = result.format_results.iter().filter(|r| r.changed).count();
            if !options.quiet {
                if formatted_count > 0 {
                    println!(
                        "{} Formatted {} file{}",
                        "✓".green().bold(),
                        formatted_count,
                        if formatted_count == 1 { "" } else { "s" }
                    );
                    println!("  Use {} to undo", "linthis format --undo".cyan());
                } else {
                    println!("{} All files already formatted", "✓".green().bold());
                }
            }
            ExitCode::SUCCESS
        }
        Err(e) => {
            eprintln!("{}: Format failed: {}", "Error".red(), e);
            ExitCode::from(1)
        }
    }
}