fkl-parser 0.4.0

Feakin is a architecture design and visual collaboration tool. This is the parser for Feakin.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::error::Error as StdError;
use std::fmt;

#[derive(Debug)]
pub enum ErrorKind {
  Msg(String),
  // Json(serde_json::Error),
  // todo: for includes file
  Io(std::io::ErrorKind),
  // SyntaxError(SyntaxError),
  // InvalidToken
  // ExtraToken
}

// #[derive(Debug)]
// pub struct SyntaxError {
//   line: String,
//   message: String,
//   location: (usize),
//   line_col: (usize, usize),
// }

#[derive(Debug)]
pub struct ParseError {
  pub kind: ErrorKind,
  source: Option<Box<dyn StdError + Sync + Send>>,
}

impl fmt::Display for ParseError {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match &self.kind {
      ErrorKind::Msg(ref message) => write!(f, "{}", message),
      ErrorKind::Io(ref io_error) => {
        write!(f, "Io error while writing rendered value to output: {:?}", io_error)
      }
      // ErrorKind::SyntaxError(token) => {
      //   write!(f, "Unrecognized token `{:?}`", token)
      // }
    }
  }
}

impl StdError for ParseError {
  fn source(&self) -> Option<&(dyn StdError + 'static)> {
    self.source.as_ref().map(|c| &**c as &(dyn StdError + 'static))
  }
}

impl ParseError {
  /// Creates generic error
  pub fn msg(value: impl ToString) -> Self {
    Self { kind: ErrorKind::Msg(value.to_string()), source: None }
  }

  pub fn io_error(error: std::io::Error) -> Self {
    Self { kind: ErrorKind::Io(error.kind()), source: Some(Box::new(error)) }
  }

  // pub fn syntax_error(error: SyntaxError) -> ParseError {
  //   ParseError {
  //     kind: ErrorKind::SyntaxError(error),
  //     source: None,
  //   }
  // }

  // pub fn json(value: serde_json::Error) -> Self {
  //   Self { kind: ErrorKind::Json(value), source: None }
  // }
}

impl From<std::io::Error> for ParseError {
  fn from(error: std::io::Error) -> Self {
    Self::io_error(error)
  }
}

impl From<&str> for ParseError {
  fn from(e: &str) -> Self {
    Self::msg(e)
  }
}

impl From<String> for ParseError {
  fn from(e: String) -> Self {
    Self::msg(e)
  }
}

// impl From<serde_json::Error> for ParseError {
//   fn from(e: serde_json::Error) -> Self {
//     Self::json(e)
//   }
// }
/// Convenient wrapper around std::Result.
pub type ParseResult<T> = Result<T, ParseError>;

#[cfg(test)]
mod tests {
  #[test]
  fn test_error_is_send_and_sync() {
    fn test_send_sync<T: Send + Sync>() {}

    test_send_sync::<super::ParseError>();
  }
}