json-pop 0.0.2

A small JSON parser from parser/lexer generators.
Documentation 
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

#![cfg(feature = "pretty_errors")]
use crate::error::CompilationError;
use crate::parser::ParseError;
use crate::value;
use codespan_reporting::diagnostic::{Diagnostic, Label};
use codespan_reporting::files::SimpleFiles;
use codespan_reporting::term;
use codespan_reporting::term::termcolor::{ColorChoice, StandardStream};

pub fn from_parse_error<'a, T: AsRef<str> + 'a>(
    filename: &'a str,
    data: &'a T,
    error: &ParseError<'a>,
) -> (SimpleFiles<&'a str, &'a str>, Diagnostic<usize>) {
    use lalrpop_util::ParseError::*;

    let mut files = SimpleFiles::new();
    let file_id = files.add(filename, data.as_ref());
    let join_expected = |expected: &Vec<String>| -> String {
        if let Some((caboose, rest)) = expected.split_last() {
            if rest.is_empty() {
                format!("Expected: {}", &caboose)
            } else {
                format!("Expected: {} or {}", rest.join(", "), &caboose)
            }
        } else {
            // If this error occurs we need to test for it at the caller.
            "Had great expectations?".to_string()
        }
    };

    let diag = match error {
        InvalidToken { location } => Diagnostic::error()
            .with_message("Invalid token")
            .with_labels(vec![Label::primary(file_id, *location..*location)]),
        UnrecognizedEOF { location, expected } => Diagnostic::error()
            .with_message("Unexpected EOF")
            .with_labels(vec![
                Label::primary(file_id, *location..*location).with_message(join_expected(expected))
            ]),
        UnrecognizedToken {
            token: (start, _tok, end),
            expected,
        } => Diagnostic::error()
            .with_message("Unrecognized token")
            .with_labels(vec![
                Label::primary(file_id, *start..*end).with_message(join_expected(expected))
            ]),
        ExtraToken {
            token: (start, _tok, end),
        } => Diagnostic::error()
            .with_message("Extra token")
            .with_labels(vec![Label::primary(file_id, *start..*end)])
            .with_message("Extra token"),
        User { error } => {
            let range = match error {
                CompilationError::LexicalError { range }
                | CompilationError::NumericalError { range }
                | CompilationError::UnterminatedStringLiteral { range } => range,
            };

            Diagnostic::error()
                .with_message(format!("{:?}", error))
                .with_labels(vec![Label::primary(file_id, range.clone())])
        }
    };
    (files, diag)
}

pub fn maybe_show_error<'a>(
    _source: &str,
    parsed: Result<value::Value<'a>, crate::parser::ParseError<'a>>,
) -> Result<value::Value<'a>, crate::error::JsonPopError<'a>> {
    if let Err(error) = parsed {
        let writer = StandardStream::stderr(ColorChoice::Auto);
        let config = codespan_reporting::term::Config::default();
        let (files, diagnostic) = from_parse_error("stdin", &_source, &error);
        term::emit(&mut writer.lock(), &config, &files, &diagnostic)?;
        Err(crate::error::JsonPopError::Parse(error))
    } else {
        parsed.map_err(crate::error::JsonPopError::Parse)
    }
}