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

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

use crate::ast::{Stmt, Time, Spanned};

use super::common::integer;

fn time() -> impl Parser<char, Spanned<Time>, Error = Simple<char>>  {
  integer()
    .then(
      just("-")
        .padded()
        .ignore_then(integer())
        .or_not()
    )
    .map_with_span(|(from, to), span| (span, match to {
      Some(to) => Time::Range(from, to),
      None => Time::Instant(from),
    }))
}

fn language() -> impl Parser<char, Spanned<String>, Error = Simple<char>> {
  ident().map_with_span(|lang, span| (span, lang))
}

pub fn parser() -> impl Parser<char, Stmt, Error = Simple<char>> {
  let start = just("@")
    .padded();

  let time_only = start
    .ignore_then(time())
    .map(|t| Stmt::Milestone { time: Some(t), language: None });

  let language_only = start
    .ignore_then(language())
    .map(|l| Stmt::Milestone { time: None, language: Some(l) });

  let both = start
    .ignore_then(time())
    .then_ignore(just(",").padded())
    .then(language())
    .map(|(t, l)| Stmt::Milestone { time: Some(t), language: Some(l) });

  choice([
    both.boxed(),
    time_only.boxed(),
    language_only.boxed(),
  ])
  
}

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

  use crate::ast::{
    Stmt,
    Time,
  };

  #[test]
  fn it_parses_an_instant_milestone() {
    let src = "@ 42";
    let res = parser().parse(src.to_string());
    assert_eq!(
      res,
      Ok(
        Stmt::Milestone {
          time: Some((2..4, Time::Instant(42))),
          language: None
        }
      )
    )
  }

  #[test]
  fn it_parses_a_range_milestone() {
    let src = "@ 0-100";
    let res = parser().parse(src.to_string());
    assert_eq!(
      res,
      Ok(
        Stmt::Milestone {
          time: Some((2..7, Time::Range(0, 100))),
          language: None
        }
      )
    )
  }

  #[test]
  fn it_parses_a_milestone_with_a_language() {
    let src = "@ 42, TokiPona";
    let res = parser().parse(src.to_string());
    assert_eq!(
      res,
      Ok(
        Stmt::Milestone {
          time: Some((2..4, Time::Instant(42))),
          language: Some((6..14, "TokiPona".into())),
        }
      )
    )
  }

  #[test]
  fn it_parses_a_milestone_with_only_a_language() {
    let src = "@ TokiPona";
    let res = parser().parse(src.to_string());
    assert_eq!(
      res,
      Ok(
        Stmt::Milestone {
          time: None,
          language: Some((2..10, "TokiPona".into())),
        }
      )
    )
  }

  #[test]
  fn it_does_not_parse_a_milestone_without_a_time_or_a_language() {
    let src = "@ ";
    let res = parser().parse(src.to_string());
    assert!(res.is_err())
  }
}