chronlang-parser 0.1.7

A parser for Chronlang, a computer language for crafting constructed languages.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use chumsky::{prelude::*, text::ident};

use crate::ast::Stmt;

pub fn parser() -> impl Parser<char, Stmt, Error = Simple<char>> {

  let name = just("@")
    .then(ident::<char, Simple<char>>())
    .map(|(at, id)| at.to_owned() + &id);

  let segment = name
    .or(ident())
    .or(just(".").map(|s| s.to_string()))
    .or(just("..").map(|s| s.to_string()));

  let path = just("/")
    .or_not()
    .then(
      segment
        .map_with_span(|seg, span| (span, seg))
        .separated_by(just("/"))
        .at_least(1)
    )
    .map(|(slash, segs)| (slash.is_some(), segs));

  let names = ident()
    .map_with_span(|name, span| (span, name))
    .separated_by(just(",").padded())
    .allow_trailing()
    .delimited_by(just("(").padded(), just(")").padded())
    .or(just("*").map_with_span(|star, span| vec![(span, star.to_string())]));

  just("import")
    .padded()
    .ignore_then(names)
    .then_ignore(just("from").padded())
    .then(path)
    .map(|(names, (absolute, path))| Stmt::Import { path, absolute, names })
}

#[cfg(test)]
mod test {
  use super::*;

  #[test]
  fn it_parses_a_relative_star_import() {
    let src = "import * from ./my/phonology";
    assert_eq!(
      parser().parse(src.to_string()),
      Ok(Stmt::Import {
        path: vec![
          (14..15, ".".into()),
          (16..18, "my".into()),
          (19..28, "phonology".into()),
        ],
        absolute: false,
        names: vec![(7..8, "*".into())]
      })
    )
  }

  #[test]
  fn it_parses_an_absolute_star_import() {
    let src = "import * from /my/phonology";
    assert_eq!(
      parser().parse(src.to_string()),
      Ok(Stmt::Import {
        path: vec![
          (15..17, "my".into()),
          (18..27, "phonology".into()),
        ],
        absolute: true,
        names: vec![(7..8, "*".into())]
      })
    )
  }

  #[test]
  fn it_parses_an_external_import() {
    let src = "import * from @core/ipa";
    assert_eq!(
      parser().parse(src.to_string()),
      Ok(Stmt::Import {
        path: vec![
          (14..19, "@core".into()),
          (20..23, "ipa".into()),
        ],
        absolute: false,
        names: vec![(7..8, "*".into())]
      })
    )
  }

  #[test]
  fn it_parses_named_imports() {
    let src = "import (C, V) from @core/ipa";
    assert_eq!(
      parser().parse(src.to_string()),
      Ok(Stmt::Import {
        path: vec![
          (19..24, "@core".into()),
          (25..28, "ipa".into()),
        ],
        absolute: false,
        names: vec![(8..9, "C".into()), (11..12, "V".into())]
      })
    )
  }

  #[test]
  fn it_parses_multiline_imports() {
    let src = "import (
      Place,
      Manner,
    ) from @core/ipa";
    assert_eq!(
      parser().parse(src.to_string()),
      Ok(Stmt::Import {
        path: vec![
          (47..52, "@core".into()),
          (53..56, "ipa".into()),
        ],
        absolute: false,
        names: vec![(15..20, "Place".into()), (28..34, "Manner".into())]
      })
    )
  }
}