osu-file-parser 1.1.0

A crate to parse an osu! beatmap file
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::str::FromStr;

use nom::{
    branch::alt,
    bytes::complete::{tag, take_till, take_until, take_while},
    character::complete::multispace0,
    character::complete::{char, space0},
    combinator::{eof, map_res, rest},
    error::{FromExternalError, ParseError},
    multi::{many0, separated_list0},
    sequence::{delimited, preceded, terminated, tuple},
    IResult,
};

use crate::osu_file::{Version, VersionedFromStr};

// pub fn leading_ws<'a, F: 'a, O, E: ParseError<&'a str>>(
//     inner: F,
// ) -> impl FnMut(&'a str) -> IResult<&'a str, O, E>
// where
//     F: FnMut(&'a str) -> IResult<&'a str, O, E>,
// {
//     preceded(multispace0, inner)
// }

// pub fn trailing_ws<'a, F: 'a, O, E: ParseError<&'a str>>(
//     inner: F,
// ) -> impl FnMut(&'a str) -> IResult<&'a str, O, E>
// where
//     F: FnMut(&'a str) -> IResult<&'a str, O, E>,
// {
//     terminated(inner, multispace0)
// }

// pub fn ws<'a, F: 'a, O, E: ParseError<&'a str>>(
//     inner: F,
// ) -> impl FnMut(&'a str) -> IResult<&'a str, O, E>
// where
//     F: FnMut(&'a str) -> IResult<&'a str, O, E>,
// {
//     delimited(multispace0, inner, multispace0)
// }

/// Parses fields that has a structure of `key: value`, returning in form of `(key, ws, value, ws)`.
pub fn get_colon_field_value_lines(s: &str) -> IResult<&str, Vec<(&str, &str, &str, &str)>> {
    let field_name = take_till(|c| c == ':' || c == '\n');
    let field_separator = char(':');
    let field_value = take_till(|c| c == '\r' || c == '\n');
    // we keep whitespace information that can contain newlines
    let field_line = tuple((
        terminated(field_name, field_separator),
        space0,
        field_value,
        multispace0,
    ));

    many0(field_line)(s)
}

pub fn pipe_vec_versioned_map<'a, E, T>(
    version: Version,
) -> impl FnMut(&'a str) -> IResult<&'a str, Vec<T>, E>
where
    E: ParseError<&'a str> + nom::error::FromExternalError<&'a str, <T as VersionedFromStr>::Err>,
    T: VersionedFromStr,
{
    let item = take_while(|c: char| !['|', ',', '\r', '\n'].contains(&c));
    let item = map_res(item, move |s: &str| {
        T::from_str(s, version).map(|v| v.unwrap())
    });

    separated_list0(tag("|"), item)
}

pub fn comma<'a, E>() -> impl FnMut(&'a str) -> IResult<&'a str, &str, E>
where
    E: ParseError<&'a str>,
{
    tag(",")
}

pub fn comma_field<'a, E>() -> impl FnMut(&'a str) -> IResult<&str, &str, E>
where
    E: ParseError<&'a str>,
{
    take_while(|c: char| c != ',')
}

pub fn comma_field_type<'a, E, T>() -> impl FnMut(&'a str) -> IResult<&str, T, E>
where
    E: ParseError<&'a str> + FromExternalError<&'a str, <T as FromStr>::Err>,
    T: FromStr,
{
    map_res(comma_field(), |i| i.parse())
}

pub fn comma_field_versioned_type<'a, E, T>(
    version: Version,
) -> impl FnMut(&'a str) -> IResult<&str, T, E>
where
    E: ParseError<&'a str> + FromExternalError<&'a str, <T as VersionedFromStr>::Err>,
    T: VersionedFromStr,
{
    map_res(comma_field(), move |i| {
        T::from_str(i, version).map(|i| i.unwrap())
    })
}

pub fn consume_rest_type<'a, E, T>() -> impl FnMut(&'a str) -> IResult<&str, T, E>
where
    E: ParseError<&'a str> + FromExternalError<&'a str, <T as FromStr>::Err>,
    T: FromStr,
{
    map_res(rest, |s: &str| s.parse())
}

pub fn consume_rest_versioned_type<'a, E, T>(
    version: Version,
) -> impl FnMut(&'a str) -> IResult<&str, T, E>
where
    E: ParseError<&'a str> + FromExternalError<&'a str, <T as VersionedFromStr>::Err>,
    T: VersionedFromStr,
{
    map_res(rest, move |s: &str| {
        T::from_str(s, version).map(|s| s.unwrap())
    })
}

pub fn nothing<'a, E>() -> impl FnMut(&'a str) -> IResult<&str, &str, E>
where
    E: ParseError<&'a str>,
{
    preceded(space0, eof)
}

pub fn square_section<'a>(
) -> impl FnMut(&'a str) -> IResult<&'a str, (&str, &str, &str, &str), nom::error::Error<&str>> {
    let section_open = tag("[");
    let section_close = tag("]");
    let section_name_inner = take_till(|c: char| c == ']' || c == '\n');
    let section_name = delimited(section_open, section_name_inner, section_close);
    let section_until = alt((take_until("\n["), rest));

    tuple((multispace0, section_name, multispace0, section_until))
}