Yeah! I needed something highly extensible, flexible, and specifically WITH scoping rules so it always produces correct HTML. For instance, there's stuff like:
[b]This is bold! [i]AND ITALIC?[/b] oops where's [/i]?
Where you have unmatching closing tags. While a simple regex replacement may handle this any number of ways, this library will produce:
html
<b>This is bold! <i>AND ITALIC?</i></b> oops where's ?
Another example:
And so [s] I'm just like [s] opening tons of [sup] tags? Maybe I'll close this [/s] one
html
And so <s> I'm just like <s> opening tons of <sup> tags? Maybe I'll close this </sup></s> one</s>
All unclosed tags are automatically closed in the correct order, including any that were left at the end of the text. Unmatched closing tags are removed. Of course, this may not be what you want, but I've found that most older or established bbcode parsers work this way. With this library, you can feel (generally) safe knowing it will produce proper HTML.
With scoping rules, you also get access to tags which can reject other tags inside of them, for "verbatim" sections. For instance, in the extended tagset, I have [code] which
rust
let bbcode = BBCode::default().unwrap(); //Or catch error
let html = bbcode.parse("[url]https://github.com[/url]")
Or, if you want the extended set (see next section for list):
```rust // These are just vectors, which means you can construct your own! let mut matchers = BBCode::basics().unwrap(); let mut extras = BBCode::extras().unwrap(); matchers.append(&mut extras);
//Note: this step could be expensive, as it has to compile a couple dozen regexes let bbcode = BBCode::from_matchers(matchers);
// Cheap copy: they share the same pre-compiled regex, share it around! let bbcode2 = bbcode.clone(); ```
Or, if you want to add your own tag:
rust
//Version 1 is ugly, will probably add helper functions
let mut matchers = BBCode::basics().unwrap();
let tags = vec![
//These were ommitted but you can add them back in easily!
TagInfo::simple("center"),
TagInfo::simple("left"),
TagInfo::simple("right"),
];
let mut mytags = BBCode::tags_to_matches(tags).unwrap();
matchers.append(&mut mytags);
let bbcode = BBCode::from_matchers(matchers);
You can also setup more complex tags (but this structure is subject to change)
rust
//Other lines same as above
let tags = vec![
//Example of the "code" tag (already implemented in [`Self::extras()`)
TagInfo {
tag: "code",
outtag: "pre",
tag_type : TagType::DefinedArg("data-code"), //This tag tags oenextra item, name in enum is nmme
rawextra : Some(r#"class="code""#),
valparse: TagValueParse::ForceVerbatim,
blankconsume: BlankConsume::End(1) // block level tags consume up to 1 newline after both their starting and closing tags
},
];
BBCode is so varied, there's so many crazy tags and systems and nobody was ever able to agree on any, or at least if they did, it was too late. These are the tags supported in the 'basic' set:
Some of those may be nonstandard, and you may be missing some you find standard! If so, there's also an optional extended list:
And of course, the usual HTML characters are escaped: ', ", &, <, >
URLs not inside a url or img tag are auto-linked, or at least a best attempt is made at autolinking them (your mileage may vary)
perf featureI mostly published this for my own projects, which have specific requirements, but if for some reason this gets picked up and used and there are gaps or bugs or other required features, I'd be willing to work on it! I just don't see that happening lol