murkdown 0.1.1

An experimental semantic markup language and static site generator for composing and decomposing hypertext documents
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

use std::fmt::Display;

use pest::iterators::Pair;

use super::Rule;
use crate::types::LibError;

/// Argument
#[derive(Debug, Eq, PartialEq, Clone)]
pub enum Arg {
    MediaType(String),
    Int(i64),
    File(String),
    URIPath(String),
    PropRef(String),
    Str(String),
    StackRef(String),
}

impl Display for Arg {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Arg::MediaType(v) => write!(f, "TO {}", v),
            Arg::Int(v) => write!(f, "{}", v),
            Arg::File(v) => write!(f, "TO  \"{}\"", v),
            Arg::URIPath(v) => write!(f, "AS \"{}\"", v),
            Arg::PropRef(v) => write!(f, "PROP {}", v),
            Arg::Str(v) => write!(f, "\"{}\"", v),
            Arg::StackRef(v) => write!(f, "{}", v),
        }
    }
}

impl TryFrom<Pair<'_, Rule>> for Arg {
    type Error = LibError;

    fn try_from(pair: Pair<'_, Rule>) -> Result<Self, Self::Error> {
        match pair.as_rule() {
            Rule::Str => Ok(Arg::Str(pair.as_str().to_string())),
            Rule::Int => Ok(Arg::Int(pair.as_str().parse::<i64>().map_err(|_| {
                LibError::invalid_rule_argument_type(pair.as_str(), "int")
            })?)),
            Rule::StackRef => Ok(Arg::StackRef(pair.as_str().to_string())),
            Rule::PropRef => Ok(Arg::PropRef(pair.as_str().to_string())),
            Rule::File => Ok(Arg::File(pair.as_str().to_string())),
            Rule::URIPath => Ok(Arg::URIPath(pair.as_str().to_string())),
            Rule::MediaType => Ok(Arg::MediaType(pair.as_str().to_string())),
            _ => Err(LibError::invalid_rule_argument(pair.as_str())),
        }
    }
}

impl PartialEq<&str> for Arg {
    fn eq(&self, other: &&str) -> bool {
        match self {
            Arg::File(s)
            | Arg::URIPath(s)
            | Arg::MediaType(s)
            | Arg::Str(s)
            | Arg::PropRef(s)
            | Arg::StackRef(s) => s == *other,
            Arg::Int(s) => s.to_string() == *other,
        }
    }
}