File size: 6,596 Bytes
f0f4f2b |
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 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 |
use charset_normalizer_rs::entity::{CLINormalizerArgs, CLINormalizerResult, NormalizerSettings};
use charset_normalizer_rs::from_path;
use clap::Parser;
use dialoguer::Confirm;
use env_logger::Env;
use ordered_float::OrderedFloat;
use std::fs::File;
use std::io::Write;
use std::{fs, process};
fn normalizer(args: &CLINormalizerArgs) -> Result<i32, String> {
match (args.replace, args.normalize, args.force, args.threshold) {
(true, false, _, _) => return Err("Use --replace in addition to --normalize only.".into()),
(false, _, true, _) => return Err("Use --force in addition to --replace only.".into()),
(_, _, _, threshold) if !(0.0..=1.0).contains(&threshold) => {
return Err("--threshold VALUE should be between 0.0 and 1.0.".into())
}
_ => {}
}
let mut results: Vec<CLINormalizerResult> = vec![];
let settings = NormalizerSettings {
threshold: OrderedFloat(args.threshold),
..Default::default()
};
// go through the files
for path in &args.files {
let full_path = &mut fs::canonicalize(path).map_err(|err| err.to_string())?;
let matches = from_path(full_path, Some(settings.clone()))?;
match matches.get_best() {
None => {
results.push(CLINormalizerResult {
path: full_path.clone(),
language: "Unknown".to_string(),
chaos: format!("{:.1}", 1.0),
coherence: format!("{:.1}", 0.0),
is_preferred: true,
..Default::default()
});
eprintln!(
"Unable to identify originating encoding for {:?}. {}",
full_path,
if args.threshold < 1.0 {
"Maybe try increasing maximum amount of chaos."
} else {
""
}
);
}
Some(best_guess) => {
// add main result & alternative results
for m in matches.iter() {
let normalize_result = CLINormalizerResult {
path: full_path.clone(),
encoding: Some(m.encoding().to_string()),
encoding_aliases: m
.encoding_aliases()
.iter()
.map(|s| (*s).to_string())
.collect(),
alternative_encodings: m
.suitable_encodings()
.iter()
.filter(|&e| e != m.encoding())
.cloned()
.collect(),
language: format!("{}", m.most_probably_language()),
alphabets: m.unicode_ranges(),
has_sig_or_bom: m.bom(),
chaos: format!("{:.1}", m.chaos_percents()),
coherence: format!("{:.1}", m.coherence_percents()),
unicode_path: None,
is_preferred: true,
};
if m == best_guess {
results.insert(0, normalize_result);
} else if args.alternatives {
results.push(normalize_result);
} else {
break;
}
}
// normalizing if need
if args.normalize {
if best_guess.encoding().starts_with("utf") {
eprintln!(
"{:?} file does not need to be normalized, as it already came from unicode.",
full_path,
);
continue;
}
// force or confirm of replacement
if !args.replace {
let filename = full_path.file_name().unwrap().to_str().unwrap();
let filename = match filename.rsplit_once('.') {
None => format!("{}.{}", filename, best_guess.encoding()),
Some(split) => {
format!("{}.{}.{}", split.0, best_guess.encoding(), split.1)
}
};
full_path.set_file_name(filename);
} else if !args.force
&& !Confirm::new()
.with_prompt(format!(
"Are you sure to normalize {:?} by replacing it?",
full_path,
))
.interact()
.unwrap_or(false)
{
continue;
}
// save path to result
results[0].unicode_path = Some(full_path.clone());
// replace file contents
if let Err(err) = File::create(full_path).and_then(|mut file| {
file.write_all(best_guess.decoded_payload().unwrap().as_bytes())
}) {
return Err(err.to_string());
}
}
}
}
}
// print out results
if args.minimal {
for path in &args.files {
let full_path = fs::canonicalize(path).map_err(|err| err.to_string())?;
println!(
"{}",
results
.iter()
.filter(|r| r.path == full_path)
.map(|r| r.encoding.clone().unwrap_or("undefined".to_string()))
.collect::<Vec<_>>()
.join(", ")
);
}
} else {
println!(
"{}",
if results.len() > 1 {
serde_json::to_string_pretty(&results).unwrap()
} else {
serde_json::to_string_pretty(&results[0]).unwrap()
}
);
}
Ok(0)
}
pub fn main() {
let args = CLINormalizerArgs::parse();
// verbose mode
if args.verbose {
env_logger::Builder::from_env(Env::default().default_filter_or("trace")).init();
}
// run normalizer
match normalizer(&args) {
Err(e) => panic!("{e}"),
Ok(exit_code) => process::exit(exit_code),
}
}
|