$ jp-grep --help

A custom grep implementation; always behaves as egrep

Usage: jp-grep [OPTIONS] [PATTERN] [PATHS]...

Arguments:
  [PATTERN]   The regular expression to evaluate; may also be specified with -e
  [PATHS]...  Paths to search for matches; if none are provided read from stdin

Options:
  -A, --after-context <AFTER_CONTEXT>
          Lines of context to print after each match
  -B, --before-context <BEFORE_CONTEXT>
          Lines of context to print before each match
  -C, --context <CONTEXT>
          Lines to print both before and after
  -c, --count
          Only print the matching count
  -E, --extended-regexp
          Extended regex mode (egrep); this option is ignored (always true)
  -e, --regexp <ADDITIONAL_PATTERNS>
          Additional patterns, will return a line if any match
  -h, --no-filename
          Never print filenames
      --help
          Display this help message
  -i, --ignore-case
          Default to case insensitive match
  -n, --line-number
          Print line numbers before matches and context
  -r, --recursive
          Recursively add any directories (-R also works)
  -v, --invert-match
          Invert the match; only print lines that don't match any pattern
  -V, --version
          Print version

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ParserError {
    RemainingInput,
    UnexpectedEnd,
    InvalidCharacter(char, &'static str),
    InvalidUnicodeCodePoint(u32),
    InvalidRange(char, char),
    InvalidRepeatRange(u32, u32),
}

impl std::fmt::Display for ParserError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParserError::RemainingInput => write!(f, "Unexpected input after parsing"),
            ParserError::UnexpectedEnd => write!(f, "Unexpected end of input"),
            ParserError::InvalidCharacter(c, expected) => {
                write!(f, "Invalid character '{}', expected {}", c, expected)
            }
            ParserError::InvalidUnicodeCodePoint(code_point) => {
                write!(f, "Invalid unicode code point: {}", code_point)
            }
            ParserError::InvalidRange(start, end) => {
                write!(f, "Invalid range: {}-{}", start, end)
            }
            ParserError::InvalidRepeatRange(start, end) => {
                write!(f, "Invalid range: {}-{}", start, end)
            }
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ParserErrorWithPosition {
    pub position: usize,
    pub error: ParserError,
}

jp-grep 'this is some long complicated pattern, \hXX see?'

Error parsing regex: Invalid character 'X', expected hex digit
| this is some long complicated pattern, \hXX see?
|                                          ^

$ jp-grep -c -v -e '//' -e '^\s*$' **/*.rs

1241

// Collect the Lines iterators we're going to be working on
enum Readable {
    Stdin,
    File(PathBuf),
}

impl Readable {
    fn lines(&mut self) -> Box<dyn Iterator<Item = std::io::Result<String>> + '_> {
        match self {
            Readable::Stdin => Box::new(
                stdin()
                    .lock()
                    .lines()
                    .map(|line| line.map(|s| s.to_string())),
            ),
            Readable::File(r) => Box::new({
                BufReader::new(File::open(r.clone()).expect(
                    format!("Failed to open file: {path}", path = r.to_string_lossy()).as_str(),
                ))
                .lines()
                .map(|line| line.map(|s| s.to_string()))
            }),
        }
    }
}

// Collect all inputs as 'Readable' iterators
// This will handle multiple provided paths the cases for directories (recursive or not)
fn collect_input(args: &Args) -> Vec<(String, Readable)> {
    let mut files = vec![];

    if args.paths.is_empty() {
        files.push(("stdin".to_string(), Readable::Stdin));
    } else {
        let mut path_queue = args
            .paths
            .iter()
            .map(|p| PathBuf::from(p))
            .collect::<VecDeque<_>>();

        while let Some(path) = path_queue.pop_front() {
            if path.is_dir() {
                if !args.recursive {
                    eprintln!(
                        "Error: {path} is a directory, but -r/--recursive was not set",
                        path = path.to_string_lossy()
                    );
                    std::process::exit(1);
                }

                // Handle recursively adding directories
                match fs::read_dir(path.clone()) {
                    Ok(entries) => {
                        for entry in entries {
                            match entry {
                                Ok(e) => path_queue.push_back(e.path()),
                                Err(e) => {
                                    eprintln!("Error reading directory entry: {error}", error = e);
                                    std::process::exit(1);
                                }
                            }
                        }
                    }
                    Err(e) => {
                        eprintln!(
                            "Error reading directory {path}: {error}",
                            path = path.to_string_lossy(),
                            error = e
                        );
                        std::process::exit(1);
                    }
                }
            } else if path.is_file() {
                files.push((path.to_string_lossy().to_string(), Readable::File(path)))
            } else {
                eprintln!(
                    "Error: {path} is not a file or directory",
                    path = path.to_string_lossy()
                );
                std::process::exit(1);
            }
        }
    }

    files
}

fn print_line(
    content: &str,
    line_number: usize,
    path: &str,
    print_line_numbers: bool,
    print_filename: bool,
) {
    if print_line_numbers {
        if print_filename {
            println!(
                "{path}:{no}:{content}",
                path = path,
                no = line_number,
                content = content
            );
        } else {
            println!("{no}:{content}", no = line_number, content = content);
        }
    } else {
        if print_filename {
            println!("{path}:{content}", path = path, content = content);
        } else {
            println!("{content}", content = content);
        }
    }
}