marser 0.1.0

Parser combinator toolkit with matcher-level backtracking and rich error reporting.
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

mod grammar;

#[cfg(not(test))]
use std::{env, fs, process};

#[cfg(not(test))]
use marser::error::ParserError;
use marser::parser::Parser;
#[cfg(all(feature = "parser-trace", not(test)))]
use marser::trace::TraceFormat;

use grammar::{JsonValue, get_json_grammar};

#[cfg(not(test))]
const DEFAULT_JSON_PATH: &str = "tests/data/json1.json";

#[cfg(not(test))]
fn usage(program: &str) -> ! {
    eprintln!(
        "Usage: {program} <path-to-json-file>{}",
        if cfg!(feature = "parser-trace") {
            " [--trace-file <path>]"
        } else {
            ""
        }
    );
    process::exit(2);
}

#[cfg(not(test))]
fn print_parse_ok(value: &JsonValue<'_>, errors: &[ParserError], path: &str, source: &str) {
    ParserError::eprint_many(errors, path, source);
    println!("\n--- Recovered JSON: ---");
    println!("{}", value.serialize_pretty());
}

#[cfg(not(test))]
struct Cli {
    path: String,
    /// When set, write trace JSON here (`parser-trace` only).
    #[cfg(feature = "parser-trace")]
    trace_file: Option<String>,
}

#[cfg(not(test))]
impl Cli {
    fn parse(mut args: env::Args) -> Self {
        let program = args.next().unwrap_or_else(|| "json".to_string());
        let mut path = DEFAULT_JSON_PATH.to_string();
        #[cfg(feature = "parser-trace")]
        let mut trace_file: Option<String> = None;
        #[cfg(feature = "parser-trace")]
        let mut expect_trace_path = false;

        for arg in args {
            #[cfg(feature = "parser-trace")]
            {
                if expect_trace_path {
                    trace_file = Some(arg);
                    expect_trace_path = false;
                    continue;
                }
                if arg == "--trace-file" {
                    expect_trace_path = true;
                    continue;
                }
            }

            if path != DEFAULT_JSON_PATH {
                usage(&program);
            }
            path = arg;
        }

        Self {
            path,
            #[cfg(feature = "parser-trace")]
            trace_file,
        }
    }
}

#[cfg(not(test))]
fn read_source(path: &str) -> String {
    match fs::read_to_string(path) {
        Ok(content) => content,
        Err(err) => {
            eprintln!("Failed to read '{path}': {err}");
            process::exit(1);
        }
    }
}

#[cfg(all(not(test), feature = "parser-trace"))]
fn run_traced<'src, P>(parser: P, sample: &'src str, cli: &Cli)
where
    P: Parser<'src, &'src str, Output = JsonValue<'src>> + Clone + 'src,
{
    let path = cli.path.as_str();
    if let Some(trace_file_path) = cli.trace_file.as_ref() {
        match parser.parse_str_with_trace_to_file(sample, trace_file_path, TraceFormat::Json) {
            Ok((value, errors)) => {
                eprintln!("trace written to {trace_file_path}");
                print_parse_ok(&value, &errors, path, sample);
            }
            Err(marser::ParseWithTraceToFileError::Parse(err)) => err.eprint(path, sample),
            Err(marser::ParseWithTraceToFileError::Io(err)) => {
                eprintln!("Failed to write trace file '{trace_file_path}': {err}");
                process::exit(1);
            }
        }
    } else {
        match parser.parse_str_with_trace(sample) {
            Ok((value, errors, _trace)) => {
                print_parse_ok(&value, &errors, path, sample);
            }
            Err(err) => err.eprint(path, sample),
        }
    }
}

#[cfg(all(not(test), not(feature = "parser-trace")))]
fn run_plain<'src, P>(parser: P, sample: &'src str, path: &str)
where
    P: Parser<'src, &'src str, Output = JsonValue<'src>> + Clone + 'src,
{
    match parser.parse_str(sample) {
        Ok((value, errors)) => {
            print_parse_ok(&value, &errors, path, sample);
        }
        Err(err) => err.eprint(path, sample),
    }
}

#[cfg(not(test))]
fn main() {
    let cli = Cli::parse(env::args());
    let sample = read_source(&cli.path);
    let parser = get_json_grammar();
    #[cfg(feature = "parser-trace")]
    run_traced(parser, sample.as_str(), &cli);
    #[cfg(not(feature = "parser-trace"))]
    run_plain(parser, sample.as_str(), cli.path.as_str());
}