jsonrepair 0.1.0

Fast, low-dependency JSON repair for Rust. Turns 'almost JSON' into valid JSON; supports streaming and writer-based output.
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

use std::fmt;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RepairErrorKind {
    UnexpectedEnd,
    UnexpectedChar(char),
    ObjectKeyExpected,
    ColonExpected,
    InvalidUnicodeEscape,
    Parse(String),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RepairError {
    pub kind: RepairErrorKind,
    pub position: usize,
}

impl RepairError {
    pub fn new(kind: RepairErrorKind, position: usize) -> Self {
        Self { kind, position }
    }

    #[cfg(feature = "serde")]
    pub fn from_serde(what: &str, err: serde_json::Error) -> Self {
        let pos = err.line(); // coarse fallback
        Self {
            kind: RepairErrorKind::Parse(format!("serde_json {} error: {}", what, err)),
            position: pos,
        }
    }
}

impl fmt::Display for RepairError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.kind {
            RepairErrorKind::UnexpectedEnd => {
                write!(f, "Unexpected end at position {}", self.position)
            }
            RepairErrorKind::UnexpectedChar(c) => {
                write!(
                    f,
                    "Unexpected character {:?} at position {}",
                    c, self.position
                )
            }
            RepairErrorKind::ObjectKeyExpected => {
                write!(f, "Object key expected at position {}", self.position)
            }
            RepairErrorKind::ColonExpected => {
                write!(f, "Colon expected at position {}", self.position)
            }
            RepairErrorKind::InvalidUnicodeEscape => {
                write!(f, "Invalid unicode escape at position {}", self.position)
            }
            RepairErrorKind::Parse(msg) => write!(f, "{} at position {}", msg, self.position),
        }
    }
}

impl std::error::Error for RepairError {}