kirei 25.12.29

Askama 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

use clap::Parser;
use std::io::{self, Read};

use crate::{
    diagnostics::{Diagnostic, Severity},
    draw::draw,
    write::Kirei,
};

#[derive(Parser)]
#[command(name = "kirei", about, version)]
#[command(arg_required_else_help = true)]
struct Args {
    /// Path of file to format
    #[arg(value_name = "PATH", help_heading = "Input")]
    input: String,

    /// Check if files are formatted
    #[arg(short = 'c', long = "check")]
    check: bool,

    /// Edit files in-place (overwrite with formatted output)
    #[arg(short = 'w', long = "write")]
    write: bool,

    /// Print the names of files that would be changed
    #[arg(short = 'l', long = "list-different")]
    list_different: bool,

    /// When reading from stdin, use this as the filepath
    #[arg(
        long = "stdin-filepath",
        value_name = "PATH",
        help_heading = "Other options"
    )]
    stdin_filepath: Option<String>,
}

pub fn run() {
    let args = Args::parse();

    let (input, filepath) = if args.input == "-" {
        let mut buffer = String::new();
        io::stdin()
            .read_to_string(&mut buffer)
            .unwrap_or_else(|e| io_error(&e, None));
        (buffer, args.stdin_filepath.as_deref())
    } else {
        let content = std::fs::read_to_string(&args.input)
            .unwrap_or_else(|e| io_error(&e, Some(&args.input)));
        (content, Some(&*args.input))
    };

    let noted = Kirei::default().write(&input);

    let has_errors = noted.diagnostics.iter().any(|d| d.level == Severity::Error);
    for diagnostic in &noted.diagnostics {
        eprint!("{}", draw(diagnostic, &input, filepath));
    }

    let mut formatted = noted.value;

    if has_errors {
        std::process::exit(1);
    }

    if !formatted.ends_with('\n') {
        formatted.push('\n');
    }

    if args.check {
        if input != formatted {
            file_would_be_updated(filepath)
        }
    } else if args.list_different {
        if input != formatted {
            eprintln!("{}", filepath.unwrap_or("missing file path"));
            std::process::exit(1);
        }
    } else if args.write
        && let Some(path) = filepath
    {
        std::fs::write(path, &formatted).unwrap_or_else(|e| io_error(&e, Some(path)));
    } else {
        print!("{formatted}");
    }
}

// Diagnostics
fn io_error(error: &std::io::Error, filepath: Option<&str>) -> ! {
    use std::io::ErrorKind as IoKind;

    let message = match (error.kind(), filepath) {
        (IoKind::NotFound, Some(path)) => format!("file `{}` does not exist", path),
        (IoKind::NotFound, None) => "file does not exist".to_string(),
        (IoKind::PermissionDenied, Some(path)) => {
            format!("permission denied when accessing `{}`", path)
        }
        (IoKind::PermissionDenied, None) => "permission denied".to_string(),
        (IoKind::AlreadyExists, Some(path)) => format!("file `{}` already exists", path),
        (IoKind::AlreadyExists, None) => "file already exists".to_string(),
        (IoKind::InvalidInput, _) => "invalid input".to_string(),
        (IoKind::InvalidData, _) => "invalid data".to_string(),
        (IoKind::TimedOut, _) => "operation timed out".to_string(),
        (IoKind::Interrupted, _) => "operation interrupted".to_string(),
        (IoKind::UnexpectedEof, Some(path)) => {
            format!("unexpected end of file in `{}`", path)
        }
        (IoKind::UnexpectedEof, None) => "unexpected end of file".to_string(),
        (IoKind::BrokenPipe, _) => "broken pipe".to_string(),
        (kind, Some(path)) => format!("IO error when accessing `{}`: {:?}", path, kind),
        (kind, None) => format!("IO error: {:?}", kind),
    };

    let diagnostic = Diagnostic::error(message);
    eprintln!("{}", draw(&diagnostic, "", filepath));
    std::process::exit(1);
}

fn file_would_be_updated(filepath: Option<&str>) -> ! {
    let diagnostic = Diagnostic::error("file would be formatted");
    eprintln!("{}", draw(&diagnostic, "", filepath));
    std::process::exit(1);
}