eonfmt 0.2.0

A binary for formatting .eon config files.
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

//! Eon formatter.
//!
//! Formats Eon files according to the Eon syntax.
//! See <https://github.com/emilk/eon> for more.

use std::{fs, path::Path, process};

use clap::{Arg, Command};
use ignore::WalkBuilder;

fn main() {
    let matches = Command::new("Eon formatter")
        .about("Format Eon files")
        .arg(
            Arg::new("files")
                .help("Files or directories to format")
                .num_args(1..)
                .required(true)
                .index(1),
        )
        .arg(
            Arg::new("check")
                .long("check")
                .help("Check if files are formatted without modifying them")
                .action(clap::ArgAction::SetTrue),
        )
        .arg(
            Arg::new("extension")
                .long("ext")
                .short('e')
                .help("File extension to process")
                .default_value("eon")
                .value_name("EXT"),
        )
        .get_matches();

    let paths: Vec<&str> = matches
        .get_many::<String>("files")
        .expect("Missing file paths")
        .map(|s| s.as_str())
        .collect();
    let check_mode = matches.get_flag("check");
    let extension = matches
        .get_one::<String>("extension")
        .expect("Missing extension")
        .as_str();

    let mut exit_code = 0;

    let mut file_paths = Vec::new();

    for path_str in paths {
        let path = Path::new(path_str);

        if path.is_file() {
            file_paths.push(path.to_path_buf());
        } else if path.is_dir() {
            let walker = WalkBuilder::new(path)
                .git_ignore(true)
                .git_exclude(true)
                .git_global(true)
                .hidden(false)
                .build();

            for entry in walker {
                match entry {
                    Ok(entry) => {
                        let entry_path = entry.path();
                        if entry_path.is_file() && has_extension(entry_path, extension) {
                            file_paths.push(path.to_path_buf());
                        }
                    }
                    Err(err) => {
                        eprintln!("Error walking directory: {err}");
                        exit_code = 1;
                    }
                }
            }
        } else {
            eprintln!("Path does not exist: {}", path.display());
            exit_code = 1;
        }
    }

    let mut num_files_changed = 0;

    for path in &file_paths {
        match process_file(path, check_mode) {
            Ok(false) => {}
            Ok(true) => {
                num_files_changed += 1;
                if check_mode {
                    eprintln!("Would format: {}", path.display());
                    exit_code = 1;
                } else {
                    eprintln!("Formatted: {}", path.display());
                }
            }
            Err(e) => {
                eprintln!("Error processing file {}: {}", path.display(), e);
                exit_code = 1;
            }
        }
    }

    let num_files_found = file_paths.len();

    if check_mode {
        if num_files_changed > 0 {
            eprintln!("{num_files_changed}/{num_files_found} file(s) would be reformatted");
            exit_code = 1;
        } else {
            eprintln!("All {num_files_found} file(s) are correctly formatted");
        }
    } else {
        eprintln!(
            "Formatted {} file(s), {} file(s) left unchanged",
            num_files_changed,
            num_files_found - num_files_changed
        );
    }

    #[allow(clippy::exit, clippy::allow_attributes)]
    process::exit(exit_code);
}

fn has_extension(entry_path: &Path, extension: &str) -> bool {
    if let Some(ext) = entry_path.extension() {
        ext == extension
    } else {
        false
    }
}

fn process_file(path: &Path, check_mode: bool) -> Result<bool, Box<dyn std::error::Error>> {
    let content = fs::read_to_string(path)?;
    let options = eon_syntax::FormatOptions::default();
    let formatted = eon_syntax::reformat(&content, &options)?;

    let needs_formatting = content != formatted;

    if needs_formatting && !check_mode {
        fs::write(path, formatted)?;
    }

    Ok(needs_formatting)
}