ecd 0.1.1

Fast CLI to detect text file encodings (UTF-8, GBK, Shift_JIS, and 35+ more)
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

use std::io::{self, Write};
use std::path::Path;

use crate::detect::{Detection, SkipReason};

#[derive(Debug, Clone)]
pub struct FileResult {
    pub path: std::path::PathBuf,
    pub detection: Detection,
}

pub struct OutputConfig<'a> {
    pub single_file_mode: bool,
    pub ignore_encoding: Option<&'a str>,
    pub quiet: bool,
    pub verbose: bool,
}

pub struct Stats {
    pub checked: usize,
    pub printed: usize,
    pub skipped: usize,
    pub ignored: usize,
}

pub fn print_results(
    results: &[FileResult],
    config: &OutputConfig<'_>,
    stderr: &mut dyn Write,
) -> io::Result<Stats> {
    let mut stats = Stats {
        checked: results.len(),
        printed: 0,
        skipped: 0,
        ignored: 0,
    };

    if config.single_file_mode {
        if let Some(result) = results.first() {
            match &result.detection {
                Detection::Encoded(enc) => {
                    if should_ignore(config.ignore_encoding, enc) {
                        stats.ignored += 1;
                    } else if !config.quiet {
                        println!("{enc}");
                        stats.printed += 1;
                    }
                }
                Detection::Skip(reason) => {
                    stats.skipped += 1;
                    if config.verbose {
                        writeln!(
                            stderr,
                            "skip {}: {}",
                            result.path.display(),
                            skip_reason_message(reason)
                        )?;
                    }
                }
            }
        }
        return Ok(stats);
    }

    for result in results {
        match &result.detection {
            Detection::Encoded(enc) => {
                if should_ignore(config.ignore_encoding, enc) {
                    stats.ignored += 1;
                    continue;
                }
                if !config.quiet {
                    println!("[{}] {}", display_encoding(enc), display_path(&result.path));
                    stats.printed += 1;
                }
            }
            Detection::Skip(_) => {
                stats.skipped += 1;
                if !config.quiet {
                    println!("[SKIP] {}", display_path(&result.path));
                }
                if config.verbose
                    && let Detection::Skip(reason) = &result.detection
                {
                    writeln!(
                        stderr,
                        "skip {}: {}",
                        result.path.display(),
                        skip_reason_message(reason)
                    )?;
                }
            }
        }
    }

    Ok(stats)
}

pub fn print_stats(stats: &Stats, stderr: &mut dyn Write) -> io::Result<()> {
    writeln!(
        stderr,
        "checked: {}, printed: {}, skipped: {}, ignored: {}",
        stats.checked, stats.printed, stats.skipped, stats.ignored
    )
}

fn should_ignore(ignore: Option<&str>, encoding: &str) -> bool {
    ignore.is_some_and(|i| i.eq_ignore_ascii_case(encoding))
}

fn display_encoding(enc: &str) -> String {
    enc.to_ascii_uppercase()
}

fn display_path(path: &Path) -> String {
    path.to_string_lossy().into_owned()
}

fn skip_reason_message(reason: &SkipReason) -> &'static str {
    match reason {
        SkipReason::Empty => "empty file",
        SkipReason::Binary => "binary content",
        SkipReason::Unknown => "encoding unknown",
        SkipReason::ReadError(_) => "read error",
    }
}