mntn 4.0.4

A Rust-based command-line tool for dotfiles management with profiles.
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

use crate::commands::core::Command;
use crate::commands::doctor::utils::enabled_json_files;
use crate::profiles::ActiveProfile;
use crate::utils::display::{green, red, yellow};
use std::fs;
use std::path::Path;

pub(crate) struct FixTask {
    profile: ActiveProfile,
    dry_run: bool,
}

impl FixTask {
    pub(crate) fn new(profile: ActiveProfile, dry_run: bool) -> Self {
        Self { profile, dry_run }
    }
}

/// Outcome of processing a single JSON file.
enum FixOutcome {
    /// File was already pretty-printed; nothing to do.
    Unchanged,
    /// File was (or would be) reformatted.
    Reformatted,
    /// File could not be repaired (unreadable, true syntax error, or write failure).
    Unfixable(String),
}

impl Command for FixTask {
    fn name(&self) -> &str {
        "Doctor fix"
    }

    fn execute(&mut self) -> color_eyre::eyre::Result<()> {
        if self.dry_run {
            println!("Reformatting JSON configs (dry run)...");
        } else {
            println!("Reformatting JSON configs...");
        }
        println!("   Profile: {}", self.profile);

        let files = enabled_json_files(&self.profile)?;
        if files.is_empty() {
            println!("{}", green("No JSON config files to format"));
            return Ok(());
        }

        let mut reformatted = 0usize;
        let mut unchanged = 0usize;
        let mut unfixable = 0usize;

        for (path, name) in files {
            match self.fix_file(&path) {
                FixOutcome::Unchanged => {
                    unchanged += 1;
                }
                FixOutcome::Reformatted => {
                    reformatted += 1;
                    let verb = if self.dry_run {
                        "Would reformat"
                    } else {
                        "Reformatted"
                    };
                    println!(
                        "{}",
                        green(&format!(" {} {} ({})", verb, name, path.display()))
                    );
                }
                FixOutcome::Unfixable(reason) => {
                    unfixable += 1;
                    println!("{}", red(&format!(" x {}: {}", name, reason)));
                    println!(
                        "{}",
                        yellow(&format!(
                            " Fix: repair the syntax manually in {}",
                            path.display()
                        ))
                    );
                }
            }
        }

        println!();
        println!(
            "{} reformatted, {} already clean, {} unfixable",
            reformatted, unchanged, unfixable
        );

        if unfixable > 0 {
            return Err(color_eyre::eyre::eyre!(
                "{} file(s) have syntax errors serde_json cannot repair",
                unfixable
            ));
        }

        Ok(())
    }
}

impl FixTask {
    fn fix_file(&self, path: &Path) -> FixOutcome {
        if !path.exists() {
            return FixOutcome::Unchanged;
        }

        let content = match fs::read_to_string(path) {
            Ok(c) => c,
            Err(e) => return FixOutcome::Unfixable(format!("could not read file: {}", e)),
        };

        let value: serde_json::Value = match serde_json::from_str(&content) {
            Ok(v) => v,
            Err(e) => return FixOutcome::Unfixable(format!("invalid JSON: {}", e)),
        };

        let mut pretty = match serde_json::to_string_pretty(&value) {
            Ok(p) => p,
            Err(e) => return FixOutcome::Unfixable(format!("could not serialize: {}", e)),
        };
        pretty.push('\n');

        if pretty == content {
            return FixOutcome::Unchanged;
        }

        if self.dry_run {
            return FixOutcome::Reformatted;
        }

        if let Err(e) = write_atomic(path, &pretty) {
            return FixOutcome::Unfixable(format!("could not write file: {}", e));
        }

        FixOutcome::Reformatted
    }
}

/// Write `content` to `path` atomically by writing a sibling temp file and
/// renaming it into place, so a crash mid-write cannot truncate the original.
fn write_atomic(path: &Path, content: &str) -> std::io::Result<()> {
    let tmp_path = path.with_extension("json.mntn-tmp");
    fs::write(&tmp_path, content)?;
    fs::rename(&tmp_path, path)
}