ecd 0.2.0

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

use std::path::PathBuf;

use clap::{Args, Parser, Subcommand};

use crate::color::ColorWhen;

pub const DEFAULT_EXCLUDES: &[&str] = &[".git", "node_modules", "target"];

pub const AFTER_HELP: &str = "\
EXAMPLES:
  ecd check -f man.txt              Detect encoding of one file
  ecd check -d ./src                Scan directory (top level only)
  ecd check -r -p \"*.java\"          Find Java files under current directory
  ecd check -r -d . -p \"*.java\"     Recursively find Java files in a path
  ecd check -d . -p \"*.rs\"          Filter by glob pattern
  ecd check -f a.txt -f b.txt       Multiple files
  ecd check -d . -i ascii -v        Skip ASCII, show stats
";

#[derive(Parser, Debug)]
#[command(
    name = "ecd",
    version,
    about = "Detect text file character encodings",
    long_about = "Detect text file character encodings.\n\n\
                  Supports 38 encodings including UTF-8, GBK, Big5, Shift_JIS, and Windows code pages.\n\
                  Scan files or directories in parallel; single-file mode prints the encoding name only.",
    after_help = AFTER_HELP
)]
pub struct Cli {
    /// When to colorize encoding labels (`[UTF-8]`, `[SKIP]`, …) in batch output
    #[arg(
        long = "color",
        value_name = "WHEN",
        default_value = "never",
        global = true
    )]
    pub color: ColorWhen,

    #[command(subcommand)]
    pub command: Option<Commands>,
}

#[derive(Subcommand, Debug)]
pub enum Commands {
    /// Detect file encoding(s)
    Check(CheckArgs),
}

#[derive(Args, Debug, Clone)]
pub struct CheckArgs {
    /// File(s) to check (repeatable)
    #[arg(short = 'f', long = "file", value_name = "PATH")]
    pub files: Vec<PathBuf>,

    /// Directory/directories to scan (repeatable); defaults to `.` when `-r` or `-p` is given alone
    #[arg(short = 'd', long = "dir", value_name = "PATH")]
    pub dirs: Vec<PathBuf>,

    /// Recursively scan into subdirectories (used with `-d`, or current directory when `-d` is omitted)
    #[arg(short = 'r', long = "recursive")]
    pub recursive: bool,

    /// Glob pattern to filter files (`*.java`; with `-r` matches at any depth)
    #[arg(short = 'p', long = "pattern", value_name = "GLOB")]
    pub pattern: Option<String>,

    /// Ignore files with this encoding (case-insensitive)
    #[arg(short = 'i', long = "ignore", value_name = "ENC")]
    pub ignore_encoding: Option<String>,

    /// Additional directory names to exclude
    #[arg(short = 'e', long = "exclude", value_name = "NAME")]
    pub excludes: Vec<String>,

    /// Disable default directory excludes (.git, node_modules, target)
    #[arg(long = "no-default-excludes")]
    pub no_default_excludes: bool,

    /// Number of parallel jobs
    #[arg(short = 'j', long = "jobs", value_name = "N")]
    pub jobs: Option<usize>,

    /// Print statistics to stderr
    #[arg(short = 'v', long = "verbose")]
    pub verbose: bool,

    /// Suppress normal output (errors only)
    #[arg(short = 'q', long = "quiet")]
    pub quiet: bool,
}

impl CheckArgs {
    pub fn effective_excludes(&self) -> Vec<String> {
        let mut excludes = Vec::new();
        if !self.no_default_excludes {
            excludes.extend(DEFAULT_EXCLUDES.iter().map(|s| (*s).to_string()));
        }
        excludes.extend(self.excludes.clone());
        excludes
    }

    /// Glob pattern for file filtering; `*` when `-p` is omitted.
    pub fn effective_pattern(&self) -> &str {
        self.pattern.as_deref().unwrap_or("*")
    }

    /// Scan roots: explicit `-d` paths, or `.` when `-r`/`-p` is used without `-d`.
    pub fn effective_dirs(&self) -> Vec<PathBuf> {
        if !self.dirs.is_empty() {
            return self.dirs.clone();
        }
        if self.files.is_empty() && (self.recursive || self.pattern.is_some()) {
            vec![PathBuf::from(".")]
        } else {
            vec![]
        }
    }

    pub fn is_single_file_mode(&self) -> bool {
        self.files.len() == 1 && self.effective_dirs().is_empty()
    }
}