spidior 0.2.2

A tool for handling sed-like substitution tasks where pesky source code semantics are getting in the way.
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

use clap::Parser;
use languages::clike::Clike;
use languages::parsing::*;
use std::{error::Error, fs};
use walkdir::WalkDir;
use std::io::{self, BufRead};

#[macro_use]
extern crate lalrpop_util;

mod editing;
mod languages;
mod nfa;
mod regex2nfa;
mod regexparser;

use crate::regex2nfa::build_nfa;

#[derive(Parser)]
#[clap(version = "0.2.2", author = "John Westhoff <johnjwesthoff@gmail.com>")]
struct Opts {
    /// The path to the files we are reading
    #[clap(short, long, default_value = ".")]
    path: String,
    /// The query string for find/replace for each file we find in the input, required if `dump` is not set
    #[clap(short = 'q', long, required_unless_present("dump"))]
    query: Option<String>,
    /// Whether we are are interactively replacing things or not
    #[clap(short = 'I', long)]
    interactive: bool,
    /// Whether we should edit files in place or print to stdout
    #[clap(short, long)]
    in_place: bool,
    /// Whether we should just dump info without replacing
    #[clap(short, long)]
    dump: bool,
    /// Whether we should print info about the regex nfa
    #[clap(short, long)]
    nfa: bool,
    /// Whether we should search recursively
    #[clap(short, long)]
    recursive: bool,
}

fn ask(replace: &str, with: &str) -> bool {
    eprintln!("Replace:\n{}\nWith:\n{}\n?", replace, with);
    let mut answer = String::new();
    let stdin = io::stdin();
    stdin.lock().read_line(&mut answer).unwrap();
    return answer.to_lowercase().starts_with("y");
}

fn main() -> Result<(), Box<dyn Error>> {
    let opts: Opts = Opts::parse();
    if opts.dump {
        dump(opts)
    } else {
        replace(opts)
    }
}

fn dump(opts: Opts) -> Result<(), Box<dyn Error>> {
    let c = Clike {};
    let mut dumps = Vec::new();
    for entry in get_dir_iter(opts.recursive, &opts.path)
    {
        let path = entry.path();
        if path.is_file() {
            if let Ok(contents) = fs::read_to_string(path) {
                dumps.push(Info::new(path.to_string_lossy().to_string(), c.read_functions(&contents), c.read_identifiers(&contents)));
            }
        }
    }
    println!("{}", serde_json::to_string(&dumps).unwrap());
    Ok(())
}

fn replace(opts: Opts) -> Result<(), Box<dyn Error>> {
    let replace = regexparser::parse(&opts.query.unwrap())?;
    if opts.nfa {
        let (nfa, _start, _end) = build_nfa(replace.clone().find);
        eprintln!("NFA is `{:?}`", nfa);
    }

    for entry in get_dir_iter(opts.recursive, &opts.path)
    {
        let path = entry.path();
        if path.is_file() {
            if let Ok(contents) = fs::read_to_string(path) {
                let f_name = entry.file_name().to_string_lossy();
                let path_name = path.to_string_lossy().to_string();
                let res = nfa::replacer::replace(&path_name, &contents, replace.clone(), if opts.interactive { ask } else { |_, _| true} )?;
                eprintln!("Parsing file {}", f_name);
                if opts.in_place {
                    fs::write(path, &res)?;
                } else {
                    println!("{}", res);
                }
            }
        }
    }
    Ok(())
}

fn get_dir_iter(recursive: bool, path: &str) -> impl Iterator<Item=walkdir::DirEntry> {
    let mut iter = WalkDir::new(path);
    if !recursive {
        iter = iter.max_depth(1);
    }
    iter.follow_links(true)
        .into_iter()
        .filter_map(|e| e.ok())
}