Skip to main content

parse_file/
parse_file.rs

1//! Parse GQL files without executing database operations.
2use std::ffi::OsString;
3use std::io::{Read, Write};
4
5use gql_parser::{format_ast, parse};
6
7const USAGE: &str =
8    "usage: parse_file [--dump-ast] [--] FILE [FILE ...]\nUse - to read GQL from stdin.";
9
10fn main() -> Result<(), Box<dyn std::error::Error>> {
11    run(
12        std::env::args_os().skip(1),
13        &mut std::io::stdin().lock(),
14        &mut std::io::stdout().lock(),
15    )
16}
17
18fn run(
19    args: impl IntoIterator<Item = OsString>,
20    stdin: &mut dyn Read,
21    output: &mut dyn Write,
22) -> Result<(), Box<dyn std::error::Error>> {
23    let mut dump_ast = false;
24    let mut positional = false;
25    let mut files = Vec::new();
26    for arg in args {
27        if !positional && arg == "--" {
28            positional = true;
29        } else if !positional && arg == "--dump-ast" {
30            dump_ast = true;
31        } else if !positional && (arg == "--help" || arg == "-h") {
32            writeln!(output, "{USAGE}")?;
33            return Ok(());
34        } else if !positional && arg != "-" && arg.to_string_lossy().starts_with('-') {
35            return Err(format!("unknown option {arg:?}\n{USAGE}").into());
36        } else {
37            files.push(arg);
38        }
39    }
40    if files.is_empty() {
41        return Err(USAGE.into());
42    }
43    if files.iter().filter(|file| *file == "-").count() > 1 {
44        return Err("stdin (-) may only be read once".into());
45    }
46    let multiple = files.len() > 1;
47    for file in files {
48        let input = if file == "-" {
49            let mut input = String::new();
50            stdin.read_to_string(&mut input)?;
51            input
52        } else {
53            std::fs::read_to_string(&file).map_err(|error| format!("{file:?}: {error}"))?
54        };
55        let program = parse(&input).map_err(|error| format!("{file:?}: {error}"))?;
56        if dump_ast {
57            if multiple {
58                writeln!(output, "==> {file:?} <==")?;
59            }
60            write!(output, "{}", format_ast(&program))?;
61        }
62    }
63    Ok(())
64}
65
66#[cfg(test)]
67mod tests {
68    use super::*;
69
70    fn invoke(args: &[&str], input: &str) -> Result<String, Box<dyn std::error::Error>> {
71        let mut output = Vec::new();
72        run(
73            args.iter().map(OsString::from),
74            &mut input.as_bytes(),
75            &mut output,
76        )?;
77        Ok(String::from_utf8(output)?)
78    }
79
80    #[test]
81    fn validation_is_quiet() {
82        assert_eq!(invoke(&["-"], "RETURN 1 AS value").unwrap(), "");
83    }
84
85    #[test]
86    fn dumps_stdin_using_public_formatter() {
87        let input = "RETURN 1 + 2 * 3 AS value";
88        assert_eq!(
89            invoke(&["--dump-ast", "-"], input).unwrap(),
90            format_ast(&parse(input).unwrap())
91        );
92    }
93
94    #[test]
95    fn errors_include_the_input_source() {
96        let err = invoke(&["--dump-ast", "-"], "RETURN '")
97            .unwrap_err()
98            .to_string();
99        assert!(err.contains("\"-\": unterminated string"), "{err}");
100    }
101
102    #[test]
103    fn help_does_not_require_input() {
104        assert_eq!(invoke(&["--help"], "").unwrap(), format!("{USAGE}\n"));
105    }
106
107    #[test]
108    fn rejects_missing_input_unknown_options_and_repeated_stdin() {
109        for args in [
110            &[][..],
111            &["--dump-ast"][..],
112            &["--unknown"][..],
113            &["-", "-"][..],
114        ] {
115            assert!(invoke(args, "RETURN 1 AS value").is_err(), "{args:?}");
116        }
117    }
118
119    #[test]
120    fn propagates_output_errors() {
121        struct BrokenWriter;
122        impl Write for BrokenWriter {
123            fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
124                Err(std::io::ErrorKind::BrokenPipe.into())
125            }
126            fn flush(&mut self) -> std::io::Result<()> {
127                Ok(())
128            }
129        }
130        let err = run(
131            ["--dump-ast".into(), "-".into()],
132            &mut b"RETURN 1 AS value".as_slice(),
133            &mut BrokenWriter,
134        )
135        .unwrap_err();
136        assert_eq!(
137            err.downcast_ref::<std::io::Error>().unwrap().kind(),
138            std::io::ErrorKind::BrokenPipe
139        );
140    }
141}