logparse 0.1.0

parse arbitrary messages containing rust-like debug output to syntax highlight them
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

use proptest_derive::Arbitrary;
use std::borrow::Cow;

#[derive(Copy, Clone, Debug, PartialEq)]
pub enum Separator {
    Eq,
    Colon,
    DoubleColon,
}

#[derive(Copy, Clone, Debug, Arbitrary, PartialEq)]
pub enum QuoteType {
    Single,
    Double,
    Backtick,
}

#[derive(Clone, Debug, Arbitrary, PartialEq)]
pub enum Delimiter {
    Paren,
    Bracket,
    Brace,
    Angle,
}

#[derive(Clone, Debug, PartialEq)]
pub struct AnyString<'a> {
    pub prefix: Cow<'a, str>,
    pub ty: QuoteType,
    pub contents: Cow<'a, str>,
    pub num_hashtags: usize,
    pub suffix: Cow<'a, str>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Space<'a>(pub Cow<'a, str>);

#[derive(Copy, Clone, Debug, PartialEq, Arbitrary)]
pub enum PathSep {
    /// Happens at the start of paths, for the no leading / case
    None,
    Slash,
    Backslash,
}

#[derive(Clone, Debug, PartialEq)]
pub struct PathSegment<'a> {
    pub leading_separator: PathSep,
    pub segment: Cow<'a, str>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct FileLocation<'a> {
    pub line: Cow<'a, str>,
    pub offset: Option<Cow<'a, str>>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct FileName<'a> {
    pub leading_separator: PathSep,
    pub segment: Cow<'a, str>,
    pub ext_excluding_dot: Option<Cow<'a, str>>,
    pub location: Option<FileLocation<'a>>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Path<'a> {
    pub drive_excluding_colon: Option<char>,

    pub segments: Vec<PathSegment<'a>>,
    pub filename: FileName<'a>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Number<'a>(pub Cow<'a, str>);

/// Anything that doesn't contain spaces, and that can be a prefix of `Delimited`.
/// i.e. an english word, or rust `::`-separated Path
#[derive(Clone, Debug, PartialEq)]
pub enum Atom<'a> {
    Text(Cow<'a, str>),
}

#[derive(Clone, Debug, PartialEq)]
pub enum Token<'a> {
    True,
    False,
    None,

    Path(Path<'a>),
    String(AnyString<'a>),
    Number(Number<'a>),

    // TODO: RustPath
    Separated {
        before: Box<Token<'a>>,
        space_before: Space<'a>,
        separator: Separator,
        after: Box<Segment<'a>>,
    },
    Delimited(Delimited<'a>),

    Atom(Atom<'a>),
}

#[derive(Clone, Debug, PartialEq)]
pub struct Delimited<'a> {
    pub prefix: Option<Atom<'a>>,
    pub delimiter: Delimiter,
    pub contents: Segments<'a>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Segment<'a> {
    pub leading_space: Space<'a>,
    pub token: Token<'a>,
}

#[derive(Clone, Debug, PartialEq)]
pub struct Segments<'a> {
    pub segments: Vec<Segment<'a>>,
    pub trailing_space: Space<'a>,
}