tinyrs 0.2.0

Parse Tiny format mappings in Rust.
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

use crate::{identifier, parse_java_type, JavaType};
use nom::{
    branch::alt,
    bytes::complete::tag,
    character::complete::{char, line_ending, not_line_ending, space1},
    combinator::map,
    error::{context, ParseError},
    multi::{many0, separated_nonempty_list},
    sequence::{preceded, terminated, tuple},
    IResult,
};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum Entry {
    Comment(String),

    Class {
        names: Vec<String>,
    },

    Field {
        names: Vec<String>,
        owner: String,
        class: JavaType,
    },

    Method {
        names: Vec<String>,
        owner: String,
        arguments: Vec<JavaType>,
        return_type: JavaType,
    },
}

fn comment<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Entry, E> {
    context(
        "comment",
        map(
            // This will not take the last comment if the file does not end with a new line.
            // If the last comment is vital, the caller will simply have to tack on a new line.
            preceded(char('#'), terminated(not_line_ending, line_ending)),
            |c: &'a str| Entry::Comment(c.into()),
        ),
    )(input)
}

fn class<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Entry, E> {
    context(
        "class",
        preceded(
            terminated(tag("CLASS"), space1),
            map(
                terminated(
                    separated_nonempty_list(space1, map(identifier, str::to_owned)),
                    line_ending,
                ),
                |names| Entry::Class { names },
            ),
        ),
    )(input)
}

fn field<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Entry, E> {
    context(
        "field",
        preceded(
            terminated(tag("FIELD"), space1),
            map(
                tuple((
                    terminated(identifier, space1),
                    terminated(parse_java_type, space1),
                    terminated(
                        separated_nonempty_list(space1, map(identifier, str::to_owned)),
                        line_ending,
                    ),
                )),
                |(owner, class, names)| Entry::Field {
                    names,
                    owner: owner.into(),
                    class,
                },
            ),
        ),
    )(input)
}

fn method<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Entry, E> {
    context(
        "method",
        preceded(
            terminated(tag("METHOD"), space1),
            map(
                tuple((
                    terminated(identifier, space1),
                    preceded(char('('), terminated(many0(parse_java_type), char(')'))),
                    terminated(parse_java_type, space1),
                    terminated(
                        separated_nonempty_list(space1, map(identifier, str::to_owned)),
                        line_ending,
                    ),
                )),
                |(owner, arguments, return_type, names)| Entry::Method {
                    names,
                    owner: owner.into(),
                    arguments,
                    return_type,
                },
            ),
        ),
    )(input)
}

pub fn parse_entries<'a, E: ParseError<&'a str>>(
    input: &'a str,
) -> IResult<&'a str, Vec<Entry>, E> {
    context("v1 entries", many0(alt((comment, class, method, field))))(input)
}