Struct ParserConfig

Source

pub struct ParserConfig {
    pub comments: bool,
    pub max_depth: usize,
}

Expand description

ParserConfig for reading Links Notation documents.

Provides configuration options for controlling how a document is read.

Fields§

§comments: bool

If true, a # written where a line or a token starts opens a comment that runs to the end of the line (default: true)

§max_depth: usize

How deep links may nest: every parenthesized group and every indentation level is one level. A document nested deeper is refused with ParseError::NestingTooDeep rather than recursed into until the stack overflows (default: DEFAULT_MAX_DEPTH)

Implementations§

Source §

impl ParserConfig

Source

pub fn new() -> Self

Create a new ParserConfig with default values

§Examples

use links_notation::ParserConfig;

assert!(ParserConfig::new().comments);

Source

pub fn without_comments() -> Self

Create a ParserConfig that reads # as an ordinary reference character, the way documents written before comments existed were read.

§Examples

use links_notation::{parse_lino_with_config, ParserConfig};

let parsed = parse_lino_with_config("# a b", &ParserConfig::without_comments()).unwrap();
assert_eq!(format!("{}", parsed), "((# a b))");

Examples found in repository ?

examples/comments.rs (line 27)

9fn main() {
10    let documents = [
11        "# a note about the document\ndeploy: staging\n",
12        "deploy: staging # only staging, for now\n",
13        "issue#1047: open\n",
14        "\"# not a comment\": still a reference\n",
15        "parent\n  # what the child is for\n  child\n",
16    ];
17
18    for document in documents {
19        match parse_lino(document) {
20            Ok(links) => println!("{document:?}\n  parses as {links}"),
21            Err(error) => println!("{document:?}\n  {error}"),
22        }
23    }
24
25    // Documents that predate comments can be read with `#` as an ordinary
26    // character.
27    let config = ParserConfig::without_comments();
28    let document = "# a b\n";
29    match parse_lino_with_config(document, &config) {
30        Ok(links) => println!("\nwithout comments {document:?}\n  parses as {links}"),
31        Err(error) => println!("\nwithout comments {document:?}\n  {error}"),
32    }
33}

Source

pub fn with_comments(comments: bool) -> Self

Create a ParserConfig that turns comments on or off

§Examples

use links_notation::ParserConfig;

assert_eq!(ParserConfig::with_comments(false), ParserConfig::without_comments());

Source

pub fn with_max_depth(self, max_depth: usize) -> Self

The same configuration, refusing links nested deeper than max_depth.

Every level of nesting is a level of recursion in the parser, so raising the limit far past the default is only safe on a larger stack.

§Examples

use links_notation::{parse_lino_to_links_with_config, ParseError, ParserConfig};

let config = ParserConfig::new().with_max_depth(2);
assert!(parse_lino_to_links_with_config("((a))", &config).is_ok());
assert!(matches!(
    parse_lino_to_links_with_config("(((a)))", &config),
    Err(ParseError::NestingTooDeep(_))
));