use std::io::{IsTerminal, Write};
use std::path::{Path, PathBuf};
use std::process::ExitCode;
use anyhow::Result;
use clap::Parser;
use hashbrown::{HashMap, HashSet};
use rayon::prelude::*;
mod check;
mod cli;
mod directive;
mod dict;
#[cfg(test)]
mod dictpatch;
mod engine;
mod format;
mod fsutil;
mod report;
mod sysdict;
#[cfg(test)]
mod testutil;
mod token;
mod tui;
use cli::{Command, DictAction};
use engine::{Engine, SUGGEST_LIMIT, Suggest};
fn main() -> ExitCode {
let args = cli::Cli::parse();
match run(args) {
Ok(code) => code,
Err(e) => {
eprintln!("redink: {e:#}");
ExitCode::from(2)
}
}
}
fn run(args: cli::Cli) -> Result<ExitCode> {
let cli::Cli {
opts,
command,
files,
} = args;
let command = match command {
Some(c) => c,
None if std::io::stdout().is_terminal() => Command::Tui { files },
None => Command::Check {
files,
json: false,
words: false,
},
};
match command {
Command::Fix { file, at, word, to } => {
apply_fix(&file, at, &word, &to)?;
Ok(ExitCode::SUCCESS)
}
Command::Dict { action } => {
run_dict(&opts, action)?;
Ok(ExitCode::SUCCESS)
}
Command::Check { files, json, words } => {
let engine = build_engine(&opts)?;
let needs_suggestions = !words;
let scan = check_all(&files, opts.source(), &engine, needs_suggestions)?;
let miss = &scan.misspellings;
let found = !miss.is_empty();
let mut out = std::io::stdout().lock();
if json {
report::write_json(&mut out, miss)?;
} else if words {
report::write_words(&mut out, miss)?;
} else {
report::write_text(&mut out, miss)?;
}
drop(out);
scan.report_diagnostics();
if found && !json {
eprintln!("{}", report::summary(miss));
}
Ok(match (scan.failed, found) {
(true, _) => ExitCode::from(2),
(false, true) => ExitCode::from(1),
(false, false) => ExitCode::SUCCESS,
})
}
Command::Tui { files } => {
let engine = build_engine(&opts)?;
let scan = check_all(&files, opts.source(), &engine, false)?;
scan.report_diagnostics();
let unclosed = scan
.warnings
.into_iter()
.filter(|w| matches!(w.kind, directive::Kind::UnclosedOff { .. }))
.collect();
tui::run(scan.misspellings, engine, opts.source(), unclosed)?;
Ok(ExitCode::SUCCESS)
}
}
}
fn build_engine(opts: &cli::GlobalOpts) -> Result<Engine> {
let sys = sysdict::resolve(&opts.lang, opts.sysdict_dir.as_deref())?;
let dict = engine::load_dictionary(&sys.aff, &sys.dic)?;
let working_path = dict::locate(opts.dict.as_deref());
let working = dict::load(&working_path)?;
let engine = Engine::new(dict, working, working_path);
eprintln!(
"[dict: {} | working: {} ({} words)]",
sys.source,
engine.working_path().display(),
engine.working_word_count(),
);
Ok(engine)
}
struct Scan {
misspellings: Vec<check::Misspelling>,
warnings: Vec<check::Warning>,
errors: Vec<String>,
failed: bool,
}
impl Scan {
fn report_diagnostics(&self) {
for w in &self.warnings {
eprintln!("redink: warning: {w}");
}
for e in &self.errors {
eprintln!("redink: {e}");
}
}
}
fn check_all(
files: &[PathBuf],
opts: format::Options,
engine: &Engine,
needs_suggestions: bool,
) -> Result<Scan> {
let files = resolve_files(files);
let results: Vec<Result<check::Checked, String>> = files
.into_par_iter()
.map(|f| check::check_file(&f, opts, engine).map_err(|e| format!("{}: {e}", f.display())))
.collect();
let mut miss: Vec<check::Misspelling> = Vec::new();
let mut warnings: Vec<check::Warning> = Vec::new();
let mut errors: Vec<String> = Vec::new();
for result in results {
match result {
Ok(checked) => {
miss.extend(checked.misspellings);
warnings.extend(checked.warnings);
}
Err(e) => errors.push(e),
}
}
if needs_suggestions && !miss.is_empty() {
let unique_words: HashSet<String> = miss.iter().map(|m| m.word.clone()).collect();
let suggest_cache: HashMap<String, Vec<String>> = unique_words
.into_par_iter()
.map(|word| {
let sugs = engine
.suggest(&word, Suggest::Fast)
.into_iter()
.take(SUGGEST_LIMIT)
.collect();
(word, sugs)
})
.collect();
for m in &mut miss {
if let Some(sugs) = suggest_cache.get(&m.word) {
m.suggestions = Some(sugs.clone());
}
}
}
Ok(Scan {
misspellings: miss,
warnings,
failed: !errors.is_empty(),
errors,
})
}
fn resolve_files(files: &[PathBuf]) -> Vec<PathBuf> {
if files.is_empty() {
return discover_files(Path::new("."));
}
let mut out = Vec::new();
for f in files {
if f.is_dir() {
out.extend(discover_files(f));
} else {
out.push(f.clone());
}
}
out
}
fn discover_files(root: &Path) -> Vec<PathBuf> {
let mut out = Vec::new();
for result in ignore::Walk::new(root) {
let entry = match result {
Ok(e) => e,
Err(_) => continue,
};
if !entry.file_type().map(|t| t.is_file()).unwrap_or(false) {
continue;
}
let p = entry.path();
if format::Format::is_checkable(p) {
out.push(p.to_path_buf());
}
}
out.sort();
out
}
fn run_dict(opts: &cli::GlobalOpts, action: DictAction) -> Result<()> {
let working_path = dict::locate(opts.dict.as_deref());
match action {
DictAction::List => {
let d = dict::load(&working_path)?;
let mut out = std::io::stdout().lock();
let _ = writeln!(out, "# {}", working_path.display());
let _ = write!(out, "{}", d.render_body());
}
DictAction::Add { words, sensitive } => {
let mut d = dict::load(&working_path)?;
let mut added = 0usize;
let mut duplicates: Vec<String> = Vec::new();
for w in &words {
match d.add_entry(w, sensitive) {
dict::AddOutcome::Added => added += 1,
dict::AddOutcome::Duplicate => duplicates.push(w.clone()),
dict::AddOutcome::Ignored => {}
}
}
if added != 0 {
dict::save(&working_path, &d)?;
eprintln!(
"added {} entr{} to {}",
added,
if added == 1 { "y" } else { "ies" },
working_path.display()
);
}
if !duplicates.is_empty() {
eprintln!("already present: {}", duplicates.join(", "));
}
}
DictAction::Remove { words } => {
let mut d = dict::load(&working_path)?;
let mut removed = 0;
for w in &words {
if d.remove(w) {
removed += 1;
}
}
if removed != 0 {
dict::save(&working_path, &d)?;
}
eprintln!("removed {removed} word(s) from {}", working_path.display());
}
}
Ok(())
}
fn apply_fix(file: &Path, at: usize, word: &str, to: &str) -> Result<()> {
let src = std::fs::read(file)?;
let end = match at.checked_add(word.len()) {
Some(end) if end <= src.len() => end,
_ => anyhow::bail!(
"byte range [{at}, {at}+{}) is outside {} ({} bytes)",
word.len(),
file.display(),
src.len()
),
};
if &src[at..end] != word.as_bytes() {
anyhow::bail!(
"word at offset {at} is {:?}, not {word:?} (file may have changed)",
std::str::from_utf8(&src[at..end]).unwrap_or("<invalid utf-8>")
);
}
let mut out = Vec::with_capacity(src.len() - word.len() + to.len());
out.extend_from_slice(&src[..at]);
out.extend_from_slice(to.as_bytes());
out.extend_from_slice(&src[end..]);
fsutil::write_atomic(file, &out)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testutil;
fn test_engine() -> Engine {
let sys = sysdict::resolve_embedded();
let dict = engine::load_dictionary(&sys.aff, &sys.dic).unwrap();
Engine::new(
dict,
dict::WorkingDict::default(),
PathBuf::from("/dev/null"),
)
}
#[test]
fn apply_fix_replaces_exactly_the_named_bytes() {
let s = testutil::scratch("fix");
let p = s.path("a.md");
std::fs::write(&p, "Hello wrold today\n").unwrap();
apply_fix(&p, 6, "wrold", "world").unwrap();
assert_eq!(std::fs::read_to_string(&p).unwrap(), "Hello world today\n");
}
#[test]
fn apply_fix_refuses_when_the_word_moved() {
let s = testutil::scratch("fix-moved");
let p = s.path("a.md");
std::fs::write(&p, "Hello world today\n").unwrap();
let err = apply_fix(&p, 6, "wrold", "world").unwrap_err();
assert!(err.to_string().contains("not"), "{err}");
assert_eq!(std::fs::read_to_string(&p).unwrap(), "Hello world today\n");
}
#[test]
fn apply_fix_rejects_out_of_range_offsets() {
let s = testutil::scratch("fix-range");
let p = s.path("a.md");
std::fs::write(&p, "short\n").unwrap();
assert!(apply_fix(&p, 100, "wrold", "world").is_err());
assert!(apply_fix(&p, usize::MAX, "wrold", "world").is_err());
assert_eq!(std::fs::read_to_string(&p).unwrap(), "short\n");
}
#[test]
fn resolve_files_walks_directory_arguments() {
let s = testutil::scratch("walk");
std::fs::create_dir_all(s.path("sub")).unwrap();
std::fs::write(s.path("sub").join("a.md"), "x").unwrap();
std::fs::write(s.path("sub").join("b.txt"), "x").unwrap();
std::fs::write(s.path("sub").join("c.png"), "x").unwrap();
let found = resolve_files(&[s.path("sub")]);
let names: Vec<String> = found
.iter()
.filter_map(|p| p.file_name()?.to_str().map(String::from))
.collect();
assert!(names.contains(&"a.md".to_string()), "{names:?}");
assert!(names.contains(&"b.txt".to_string()), "{names:?}");
assert!(!names.contains(&"c.png".to_string()), "{names:?}");
let named = resolve_files(&[s.path("sub").join("c.png")]);
assert_eq!(named.len(), 1);
}
#[test]
fn check_all_flags_unreadable_files() {
let s = testutil::scratch("scan-fail");
let good = s.path("good.md");
std::fs::write(&good, "teh cdoe\n").unwrap();
let missing = s.path("nope.md");
let engine = test_engine();
let scan = check_all(
&[good.clone(), missing],
format::Options::default(),
&engine,
false,
)
.unwrap();
assert!(scan.failed, "unreadable file did not register as a failure");
assert_eq!(scan.errors.len(), 1);
assert!(
!scan.misspellings.is_empty(),
"the readable file should still have been checked"
);
let scan = check_all(&[good], format::Options::default(), &engine, false).unwrap();
assert!(!scan.failed);
assert!(scan.errors.is_empty());
}
}