neotoma 0.1.0

A flexible, cached parser combinator framework for 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
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
146
147
148
149
150
151
152

pub mod cache;
pub mod class;
pub mod either;
pub mod eof;
pub mod grammar;
pub mod literal;
pub mod optional;
pub mod parser;
pub mod recursive;
pub mod repeat;
pub mod result;
pub mod sequence;
pub mod until;
pub mod utf8class;
pub mod utf8util;

// Re-export the most commonly used types and functions at the root level
// for better ergonomics

// Core parser trait and utilities
pub use parser::{Parser, Source, parse};

// Common result types
pub use result::{Error, ParseResult};

// Main parser types (used in almost every parser combination)
pub use class::Class;
pub use literal::Literal;
pub use utf8class::Utf8Class;

// Common combinators
pub use eof::EndOfFile;
pub use optional::Optional;
pub use recursive::Recursive;
pub use repeat::Repeat;

// Grammar parsing with named rules and recursion
pub use grammar::GrammarParser;

// Composition macros are already exported at crate root via #[macro_export]
// seq! and oneof! are available directly

// Prelude module for glob imports
pub mod prelude {
    //! Commonly used imports for parser development
    //!
    //! # Example
    //!
    //! ```rust
    //! use neotoma::prelude::*;
    //! use neotoma::{seq, oneof}; // Macros are at crate root
    //!
    //! // Now you have access to all the commonly used types
    //! let parser = seq![
    //!     Literal::from_str("hello"),
    //!     Optional::new(Utf8Class::whitespace()),
    //!     Literal::from_str("world")
    //! ];
    //! ```

    pub use crate::{
        Class,
        // Combinators
        EndOfFile,
        Error,
        // Grammar parsing
        GrammarParser,
        // Main parser types
        Literal,
        Optional,
        ParseResult,
        // Core traits and functions
        Parser,
        Recursive,
        Repeat,
        Source,
        Utf8Class,
        // Composition macros (re-exported from crate root)
        // Note: seq! and oneof! macros are available directly, not as paths
        // Cache trait for implementing custom parsers
        cache::ParsingCache,
        parse,
    };
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::io::Cursor;

    // Tests moved from tests/test_root_exports.rs

    #[test]
    fn test_root_level_exports_basic() {
        // Test that we can use the types directly from root
        let literal = Literal::from_str("test");

        let cursor = Cursor::new(b"test");
        let mut source = Source::new(cursor);

        let result = parse(literal, &mut source);
        assert!(result.is_ok());
    }

    #[test]
    fn test_root_level_exports_with_macros() {
        // Test using the seq! macro with root-level imports
        let parser = seq![
            Literal::from_str("Hello"),
            Optional::new(Utf8Class::whitespace()),
            Literal::from_str("World")
        ];

        let cursor = Cursor::new(b"Hello World");
        let mut source = Source::new(cursor);

        let result = parse(parser, &mut source);
        assert!(result.is_ok());
    }

    #[test]
    fn test_root_level_exports_oneof() {
        // Test oneof! macro with root-level imports
        let parser = oneof![Literal::from_str("hello"), Literal::from_str("world")];

        let cursor = Cursor::new(b"hello");
        let mut source = Source::new(cursor);

        let result = parse(parser, &mut source);
        assert!(result.is_ok());
    }

    #[test]
    fn test_prelude_import() {
        // Test the prelude module
        use crate::prelude::*;

        let parser = seq![Literal::from_str("test"), Optional::new(Utf8Class::alpha())];

        let cursor = Cursor::new(b"testx");
        let mut source = Source::new(cursor);

        let result = parse(parser, &mut source);
        assert!(result.is_ok());
    }

    #[test]
    fn test_grammar_parser_exported() {
        // Ensure GrammarParser is available at root level
        let _parser = GrammarParser::new();
    }
}