feat: list parsing
This commit is contained in:
parent
75362bd2a8
commit
ad9f29bcb9
|
@ -5,3 +5,5 @@ authors = ["PoiScript <poiscript@gmail.com>"]
|
|||
|
||||
[dependencies]
|
||||
jetscii = "0.4.3"
|
||||
lazy_static = "1.2.0"
|
||||
regex = "1"
|
||||
|
|
|
@ -1,3 +1,5 @@
|
|||
use regex::Regex;
|
||||
|
||||
#[cfg_attr(test, derive(PartialEq))]
|
||||
#[derive(Debug)]
|
||||
pub struct Block;
|
||||
|
@ -12,9 +14,9 @@ impl Block {
|
|||
let args = eol!(src);
|
||||
let name = until_while!(src, 8, |c| c == b' ' || c == b'\n', |c: u8| c
|
||||
.is_ascii_alphabetic())?;
|
||||
// TODO: ignore case match
|
||||
let content = src.find(&format!("\n#+END_{}", &src[8..name]))?;
|
||||
let end = eol!(src, content + 1);
|
||||
let end_re = format!(r"(?im)^[ \t]*#\+END_{}[ \t]*$", &src[8..name]);
|
||||
let end_re = Regex::new(&end_re).unwrap();
|
||||
let (content, end) = end_re.find(src).map(|m| (m.start(), m.end()))?;
|
||||
|
||||
Some((
|
||||
&src[8..name],
|
||||
|
@ -24,13 +26,34 @@ impl Block {
|
|||
Some(&src[name..args])
|
||||
},
|
||||
args,
|
||||
content + 1,
|
||||
end + 1,
|
||||
content,
|
||||
// including the eol character
|
||||
if end < src.len() && src.as_bytes()[end] == b'\n' {
|
||||
end + 1
|
||||
} else {
|
||||
end
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse() {
|
||||
// TODO: testing
|
||||
assert_eq!(
|
||||
Block::parse("#+BEGIN_SRC\n#+END_SRC"),
|
||||
Some(("SRC", None, 11, 12, 21))
|
||||
);
|
||||
assert_eq!(
|
||||
Block::parse(
|
||||
r#"#+BEGIN_SRC rust
|
||||
fn main() {
|
||||
// print "Hello World!" to the console
|
||||
println!("Hello World!");
|
||||
}
|
||||
#+END_SRC
|
||||
"#
|
||||
),
|
||||
Some(("SRC", Some(" rust"), 16, 104, 114))
|
||||
);
|
||||
// TODO: more testing
|
||||
}
|
||||
|
|
226
src/elements/list.rs
Normal file
226
src/elements/list.rs
Normal file
|
@ -0,0 +1,226 @@
|
|||
pub struct List;
|
||||
|
||||
impl List {
|
||||
#[inline]
|
||||
fn is_item(src: &str) -> bool {
|
||||
if src.len() < 2 {
|
||||
return false;
|
||||
}
|
||||
|
||||
let bytes = src.as_bytes();
|
||||
let i = match bytes[0] {
|
||||
b'*' | b'-' | b'+' => 1,
|
||||
b'0'...b'9' => {
|
||||
let i = bytes
|
||||
.iter()
|
||||
.position(|&c| !c.is_ascii_digit())
|
||||
.unwrap_or_else(|| src.len());
|
||||
if i >= src.len() - 1 {
|
||||
return false;
|
||||
}
|
||||
let c = bytes[i];
|
||||
if !(c == b'.' || c == b')') {
|
||||
return false;
|
||||
}
|
||||
i + 1
|
||||
}
|
||||
_ => return false,
|
||||
};
|
||||
|
||||
// bullet is follwed by a space or line ending
|
||||
bytes[i] == b' ' || bytes[i] == b'\n'
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn is_ordered(byte: u8) -> bool {
|
||||
match byte {
|
||||
b'*' | b'-' | b'+' => false,
|
||||
b'0'...b'9' => true,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
// returns (contents_begin, contents_end)
|
||||
// TODO: handle nested list
|
||||
pub fn parse_item(src: &str, ident: usize) -> (usize, usize) {
|
||||
(
|
||||
src[ident..].find(' ').map(|i| ident + i + 1).unwrap(),
|
||||
if ident > 0 {
|
||||
src.find(&format!("\n{:1$}", " ", ident))
|
||||
.map(|i| i + 1)
|
||||
.unwrap_or_else(|| src.len())
|
||||
} else {
|
||||
src.find('\n').map(|i| i + 1).unwrap_or_else(|| src.len())
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// return (ident, is_ordered, end)
|
||||
pub fn parse(src: &str) -> Option<(usize, bool, usize)> {
|
||||
macro_rules! ident {
|
||||
($src:expr) => {
|
||||
$src.as_bytes()
|
||||
.iter()
|
||||
.position(|&c| c != b' ' && c != b'\t')
|
||||
.unwrap_or(0)
|
||||
};
|
||||
}
|
||||
|
||||
let bytes = src.as_bytes();
|
||||
let starting_ident = ident!(src);
|
||||
|
||||
if !Self::is_item(&src[starting_ident..]) {
|
||||
return None;
|
||||
}
|
||||
|
||||
let is_ordered = Self::is_ordered(bytes[starting_ident]);
|
||||
let mut pos = starting_ident;
|
||||
while let Some(i) = src[pos..]
|
||||
.find('\n')
|
||||
.map(|i| i + pos + 1)
|
||||
.filter(|&i| i != src.len())
|
||||
{
|
||||
let ident = ident!(src[i..]);
|
||||
|
||||
// less indented than its starting line
|
||||
if ident < starting_ident {
|
||||
return Some((starting_ident, is_ordered, i - 1));
|
||||
}
|
||||
|
||||
if ident > starting_ident {
|
||||
pos = i;
|
||||
continue;
|
||||
}
|
||||
|
||||
if bytes[ident + i] == b'\n' && pos < src.len() {
|
||||
let nextline_ident = ident!(src[ident + i + 1..]);
|
||||
|
||||
// check if it's two consecutive empty lines
|
||||
if nextline_ident < starting_ident
|
||||
|| (ident + i + 1 + nextline_ident < src.len()
|
||||
&& bytes[ident + i + 1 + nextline_ident] == b'\n')
|
||||
{
|
||||
return Some((starting_ident, is_ordered, ident + i + 1 + nextline_ident));
|
||||
}
|
||||
|
||||
if nextline_ident == starting_ident {
|
||||
if Self::is_item(&src[i + nextline_ident + 1..]) {
|
||||
pos = i + nextline_ident + 1;
|
||||
continue;
|
||||
} else {
|
||||
return Some((starting_ident, is_ordered, ident + i + 1 + nextline_ident));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if Self::is_item(&src[i + ident..]) {
|
||||
pos = i;
|
||||
continue;
|
||||
} else {
|
||||
return Some((starting_ident, is_ordered, i - 1));
|
||||
}
|
||||
}
|
||||
|
||||
Some((starting_ident, is_ordered, src.len()))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse() {
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r"+ item1
|
||||
+ item2
|
||||
+ item3"
|
||||
),
|
||||
Some((0, false, 23))
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r"* item1
|
||||
* item2
|
||||
|
||||
* item3"
|
||||
),
|
||||
Some((0, false, 24))
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r"- item1
|
||||
- item2
|
||||
|
||||
|
||||
- item1"
|
||||
),
|
||||
Some((0, false, 17))
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r"1. item1
|
||||
2. item1
|
||||
3. item2"
|
||||
),
|
||||
Some((0, true, 28))
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r" 1) item1
|
||||
2) item1
|
||||
3) item2"
|
||||
),
|
||||
Some((2, true, 10))
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r" + item1
|
||||
1) item1
|
||||
+ item2"
|
||||
),
|
||||
Some((2, false, 32))
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse(
|
||||
r" item1
|
||||
+ item1
|
||||
+ item2"
|
||||
),
|
||||
None
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn is_item() {
|
||||
assert!(List::is_item("+ item"));
|
||||
assert!(List::is_item("- item"));
|
||||
assert!(List::is_item("10. item"));
|
||||
assert!(List::is_item("10) item"));
|
||||
assert!(List::is_item("1. item"));
|
||||
assert!(List::is_item("1) item"));
|
||||
assert!(List::is_item("10. "));
|
||||
assert!(List::is_item("10.\n"));
|
||||
assert!(!List::is_item("10."));
|
||||
assert!(!List::is_item("-item"));
|
||||
assert!(!List::is_item("+item"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_item() {
|
||||
assert_eq!(List::parse_item("+ Item1\n+ Item2", 0), (2, 8));
|
||||
assert_eq!(
|
||||
List::parse_item(
|
||||
r"+ item1
|
||||
+ item1
|
||||
+ item2",
|
||||
0
|
||||
),
|
||||
(2, 8)
|
||||
);
|
||||
assert_eq!(
|
||||
List::parse_item(
|
||||
r" 1. item1
|
||||
+ item2",
|
||||
2
|
||||
),
|
||||
(5, 11)
|
||||
);
|
||||
}
|
|
@ -72,6 +72,11 @@ pub enum Element<'a> {
|
|||
},
|
||||
Rule,
|
||||
Comment(&'a str),
|
||||
List {
|
||||
ident: usize,
|
||||
is_ordered: bool,
|
||||
end: usize,
|
||||
},
|
||||
}
|
||||
|
||||
impl<'a> Element<'a> {
|
||||
|
@ -125,6 +130,23 @@ impl<'a> Element<'a> {
|
|||
};
|
||||
}
|
||||
|
||||
if bytes[pos] == b'+'
|
||||
|| bytes[pos] == b'-'
|
||||
|| bytes[pos] == b'*'
|
||||
|| (bytes[pos] >= b'0' && bytes[pos] <= b'9')
|
||||
{
|
||||
if let Some((ident, is_ordered, list_end)) = List::parse(&src[end..]) {
|
||||
ret!(
|
||||
Element::List {
|
||||
ident,
|
||||
is_ordered,
|
||||
end: list_end
|
||||
},
|
||||
end
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if bytes[pos] == b'\n' {
|
||||
return (start, Some(Element::Paragraph { end, trailing: pos }), None);
|
||||
}
|
||||
|
@ -134,7 +156,8 @@ impl<'a> Element<'a> {
|
|||
|
||||
// Rule
|
||||
if bytes[pos] == b'-' {
|
||||
if let Some(off) = Rule::parse(&src[pos..]) {
|
||||
let off = Rule::parse(&src[pos..]);
|
||||
if off != 0 {
|
||||
ret!(Element::Rule, off);
|
||||
}
|
||||
}
|
||||
|
@ -227,7 +250,7 @@ impl<'a> Element<'a> {
|
|||
}
|
||||
|
||||
// Comment
|
||||
if bytes[pos] == b'#' && bytes.get(pos + 1).filter(|&&b| b == b' ').is_some() {
|
||||
if bytes[pos] == b'#' && bytes.get(pos + 1).map(|&b| b == b' ').unwrap_or(false) {
|
||||
let eol = src[pos..]
|
||||
.find('\n')
|
||||
.map(|i| i + pos + 1)
|
||||
|
|
|
@ -1,34 +1,35 @@
|
|||
use regex::Regex;
|
||||
|
||||
lazy_static! {
|
||||
static ref RULE_REGEX: Regex = Regex::new(r"^[ \t]*-{5,}[ \t]*\n?$").unwrap();
|
||||
}
|
||||
|
||||
#[cfg_attr(test, derive(PartialEq))]
|
||||
#[derive(Debug)]
|
||||
pub struct Rule;
|
||||
|
||||
impl Rule {
|
||||
pub fn parse(src: &str) -> Option<usize> {
|
||||
let end = eol!(src);
|
||||
let leading = until_while!(src, 0, b'-', |c| c == b' ' || c == b'\t')?;
|
||||
if src[leading..end].chars().all(|c| c == '-') && end - leading > 4 {
|
||||
Some(end)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
pub fn parse(src: &str) -> usize {
|
||||
RULE_REGEX.find(src).map(|m| m.end()).unwrap_or(0)
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse() {
|
||||
assert_eq!(Rule::parse("-----").unwrap(), "-----".len());
|
||||
assert_eq!(Rule::parse("--------").unwrap(), "--------".len());
|
||||
assert_eq!(Rule::parse(" -----").unwrap(), " -----".len());
|
||||
assert_eq!(Rule::parse("\t\t-----").unwrap(), "\t\t-----".len());
|
||||
|
||||
assert!(Rule::parse("").is_none());
|
||||
assert!(Rule::parse("----").is_none());
|
||||
assert!(Rule::parse(" ----").is_none());
|
||||
assert!(Rule::parse(" 0----").is_none());
|
||||
assert!(Rule::parse("0 ----").is_none());
|
||||
assert!(Rule::parse("0------").is_none());
|
||||
assert!(Rule::parse("----0----").is_none());
|
||||
assert!(Rule::parse("\t\t----").is_none());
|
||||
assert!(Rule::parse("------0").is_none());
|
||||
assert!(Rule::parse("----- 0").is_none());
|
||||
assert_eq!(Rule::parse("-----"), "-----".len());
|
||||
assert_eq!(Rule::parse("--------"), "--------".len());
|
||||
assert_eq!(Rule::parse(" -----"), " -----".len());
|
||||
assert_eq!(Rule::parse("\t\t-----"), "\t\t-----".len());
|
||||
assert_eq!(Rule::parse("\t\t-----\n"), "\t\t-----\n".len());
|
||||
assert_eq!(Rule::parse("\t\t----- \n"), "\t\t----- \n".len());
|
||||
assert_eq!(Rule::parse(""), 0);
|
||||
assert_eq!(Rule::parse("----"), 0);
|
||||
assert_eq!(Rule::parse(" ----"), 0);
|
||||
assert_eq!(Rule::parse(" 0----"), 0);
|
||||
assert_eq!(Rule::parse("0 ----"), 0);
|
||||
assert_eq!(Rule::parse("0------"), 0);
|
||||
assert_eq!(Rule::parse("----0----"), 0);
|
||||
assert_eq!(Rule::parse("\t\t----"), 0);
|
||||
assert_eq!(Rule::parse("------0"), 0);
|
||||
assert_eq!(Rule::parse("----- 0"), 0);
|
||||
}
|
||||
|
|
|
@ -85,11 +85,25 @@ impl<W: Write> Handler<W> for HtmlHandler {
|
|||
fn handle_end_dyn_block(&mut self, w: &mut W) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
fn handle_list_start(&mut self, w: &mut W) -> Result<()> {
|
||||
Ok(())
|
||||
fn handle_start_list(&mut self, w: &mut W, is_ordered: bool) -> Result<()> {
|
||||
if is_ordered {
|
||||
write!(w, "<ol>")
|
||||
} else {
|
||||
write!(w, "<ul>")
|
||||
}
|
||||
fn handle_list_end(&mut self, w: &mut W) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
fn handle_end_list(&mut self, w: &mut W, is_ordered: bool) -> Result<()> {
|
||||
if is_ordered {
|
||||
write!(w, "</ol>")
|
||||
} else {
|
||||
write!(w, "</ul>")
|
||||
}
|
||||
}
|
||||
fn handle_start_list_item(&mut self, w: &mut W) -> Result<()> {
|
||||
write!(w, "<li>")
|
||||
}
|
||||
fn handle_end_list_item(&mut self, w: &mut W) -> Result<()> {
|
||||
write!(w, "</li>")
|
||||
}
|
||||
fn handle_aff_keywords(&mut self, w: &mut W) -> Result<()> {
|
||||
Ok(())
|
||||
|
|
|
@ -34,8 +34,10 @@ pub trait Handler<W: Write> {
|
|||
fn handle_verse_block(&mut self, w: &mut W, contents: &str, args: Option<&str>) -> Result<()>;
|
||||
fn handle_start_dyn_block(&mut self, w: &mut W, name: &str, args: Option<&str>) -> Result<()>;
|
||||
fn handle_end_dyn_block(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_list_start(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_list_end(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_start_list(&mut self, w: &mut W, is_ordered: bool) -> Result<()>;
|
||||
fn handle_end_list(&mut self, w: &mut W, is_ordered: bool) -> Result<()>;
|
||||
fn handle_start_list_item(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_end_list_item(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_aff_keywords(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_call(&mut self, w: &mut W) -> Result<()>;
|
||||
fn handle_clock(&mut self, w: &mut W) -> Result<()>;
|
||||
|
@ -91,92 +93,76 @@ impl<'a, W: Write, H: Handler<W>> Render<'a, W, H> {
|
|||
pub fn render(&mut self) -> Result<()> {
|
||||
use parser::Event::*;
|
||||
|
||||
let w = &mut self.writer;
|
||||
|
||||
for event in &mut self.parser {
|
||||
match event {
|
||||
StartHeadline(hdl) => self.handler.handle_start_headline(&mut self.writer, hdl)?,
|
||||
EndHeadline => self.handler.handle_end_headline(&mut self.writer)?,
|
||||
StartSection => self.handler.handle_start_section(&mut self.writer)?,
|
||||
EndSection => self.handler.handle_end_section(&mut self.writer)?,
|
||||
StartParagraph => self.handler.handle_start_paragraph(&mut self.writer)?,
|
||||
EndParagraph => self.handler.handle_end_paragraph(&mut self.writer)?,
|
||||
StartCenterBlock => self.handler.handle_start_center_block(&mut self.writer)?,
|
||||
EndCenterBlock => self.handler.handle_end_center_block(&mut self.writer)?,
|
||||
StartQuoteBlock => self.handler.handle_start_quote_block(&mut self.writer)?,
|
||||
EndQuoteBlock => self.handler.handle_end_quote_block(&mut self.writer)?,
|
||||
StartHeadline(hdl) => self.handler.handle_start_headline(w, hdl)?,
|
||||
EndHeadline => self.handler.handle_end_headline(w)?,
|
||||
StartSection => self.handler.handle_start_section(w)?,
|
||||
EndSection => self.handler.handle_end_section(w)?,
|
||||
StartParagraph => self.handler.handle_start_paragraph(w)?,
|
||||
EndParagraph => self.handler.handle_end_paragraph(w)?,
|
||||
StartCenterBlock => self.handler.handle_start_center_block(w)?,
|
||||
EndCenterBlock => self.handler.handle_end_center_block(w)?,
|
||||
StartQuoteBlock => self.handler.handle_start_quote_block(w)?,
|
||||
EndQuoteBlock => self.handler.handle_end_quote_block(w)?,
|
||||
StartSpecialBlock { name, args } => {
|
||||
self.handler
|
||||
.handle_start_special_block(&mut self.writer, name, args)?
|
||||
self.handler.handle_start_special_block(w, name, args)?
|
||||
}
|
||||
EndSpecialBlock => self.handler.handle_end_special_block(&mut self.writer)?,
|
||||
EndSpecialBlock => self.handler.handle_end_special_block(w)?,
|
||||
CommentBlock { contents, args } => {
|
||||
self.handler
|
||||
.handle_comment_block(&mut self.writer, contents, args)?
|
||||
self.handler.handle_comment_block(w, contents, args)?
|
||||
}
|
||||
ExampleBlock { contents, args } => {
|
||||
self.handler
|
||||
.handle_example_block(&mut self.writer, contents, args)?
|
||||
self.handler.handle_example_block(w, contents, args)?
|
||||
}
|
||||
ExportBlock { contents, args } => {
|
||||
self.handler
|
||||
.handle_export_block(&mut self.writer, contents, args)?
|
||||
}
|
||||
SrcBlock { contents, args } => {
|
||||
self.handler
|
||||
.handle_src_block(&mut self.writer, contents, args)?
|
||||
self.handler.handle_export_block(w, contents, args)?
|
||||
}
|
||||
SrcBlock { contents, args } => self.handler.handle_src_block(w, contents, args)?,
|
||||
VerseBlock { contents, args } => {
|
||||
self.handler
|
||||
.handle_verse_block(&mut self.writer, contents, args)?
|
||||
self.handler.handle_verse_block(w, contents, args)?
|
||||
}
|
||||
StartDynBlock { name, args } => {
|
||||
self.handler
|
||||
.handle_start_dyn_block(&mut self.writer, name, args)?
|
||||
self.handler.handle_start_dyn_block(w, name, args)?
|
||||
}
|
||||
EndDynBlock => self.handler.handle_end_dyn_block(&mut self.writer)?,
|
||||
ListStart => self.handler.handle_list_start(&mut self.writer)?,
|
||||
ListEnd => self.handler.handle_list_end(&mut self.writer)?,
|
||||
AffKeywords => self.handler.handle_aff_keywords(&mut self.writer)?,
|
||||
Call => self.handler.handle_call(&mut self.writer)?,
|
||||
Clock => self.handler.handle_clock(&mut self.writer)?,
|
||||
Comment(c) => self.handler.handle_comment(&mut self.writer, c)?,
|
||||
TableStart => self.handler.handle_table_start(&mut self.writer)?,
|
||||
TableEnd => self.handler.handle_table_end(&mut self.writer)?,
|
||||
TableCell => self.handler.handle_table_cell(&mut self.writer)?,
|
||||
LatexEnv => self.handler.handle_latex_env(&mut self.writer)?,
|
||||
FnDef { label, contents } => {
|
||||
self.handler
|
||||
.handle_fn_def(&mut self.writer, label, contents)?
|
||||
}
|
||||
Keyword { key, value } => {
|
||||
self.handler.handle_keyword(&mut self.writer, key, value)?
|
||||
}
|
||||
Rule => self.handler.handle_rule(&mut self.writer)?,
|
||||
Cookie(cookie) => self.handler.handle_cookie(&mut self.writer, cookie)?,
|
||||
FnRef(fnref) => self.handler.handle_fn_ref(&mut self.writer, fnref)?,
|
||||
InlineCall(inlinecall) => self
|
||||
.handler
|
||||
.handle_inline_call(&mut self.writer, inlinecall)?,
|
||||
InlineSrc(inlinesrc) => self
|
||||
.handler
|
||||
.handle_inline_src(&mut self.writer, inlinesrc)?,
|
||||
Link(link) => self.handler.handle_link(&mut self.writer, link)?,
|
||||
Macros(macros) => self.handler.handle_macros(&mut self.writer, macros)?,
|
||||
RadioTarget(radiotarget) => self
|
||||
.handler
|
||||
.handle_radio_target(&mut self.writer, radiotarget)?,
|
||||
Snippet(snippet) => self.handler.handle_snippet(&mut self.writer, snippet)?,
|
||||
Target(target) => self.handler.handle_target(&mut self.writer, target)?,
|
||||
StartBold => self.handler.handle_start_bold(&mut self.writer)?,
|
||||
EndBold => self.handler.handle_end_bold(&mut self.writer)?,
|
||||
StartItalic => self.handler.handle_start_italic(&mut self.writer)?,
|
||||
EndItalic => self.handler.handle_end_italic(&mut self.writer)?,
|
||||
StartStrike => self.handler.handle_start_strike(&mut self.writer)?,
|
||||
EndStrike => self.handler.handle_end_strike(&mut self.writer)?,
|
||||
StartUnderline => self.handler.handle_start_underline(&mut self.writer)?,
|
||||
EndUnderline => self.handler.handle_end_underline(&mut self.writer)?,
|
||||
Verbatim(contents) => self.handler.handle_verbatim(&mut self.writer, contents)?,
|
||||
Code(contents) => self.handler.handle_code(&mut self.writer, contents)?,
|
||||
Text(contents) => self.handler.handle_text(&mut self.writer, contents)?,
|
||||
EndDynBlock => self.handler.handle_end_dyn_block(w)?,
|
||||
StartList { is_ordered } => self.handler.handle_start_list(w, is_ordered)?,
|
||||
EndList { is_ordered } => self.handler.handle_end_list(w, is_ordered)?,
|
||||
StartListItem => self.handler.handle_start_list_item(w)?,
|
||||
EndListItem => self.handler.handle_end_list_item(w)?,
|
||||
AffKeywords => self.handler.handle_aff_keywords(w)?,
|
||||
Call => self.handler.handle_call(w)?,
|
||||
Clock => self.handler.handle_clock(w)?,
|
||||
Comment(c) => self.handler.handle_comment(w, c)?,
|
||||
TableStart => self.handler.handle_table_start(w)?,
|
||||
TableEnd => self.handler.handle_table_end(w)?,
|
||||
TableCell => self.handler.handle_table_cell(w)?,
|
||||
LatexEnv => self.handler.handle_latex_env(w)?,
|
||||
FnDef { label, contents } => self.handler.handle_fn_def(w, label, contents)?,
|
||||
Keyword { key, value } => self.handler.handle_keyword(w, key, value)?,
|
||||
Rule => self.handler.handle_rule(w)?,
|
||||
Cookie(cookie) => self.handler.handle_cookie(w, cookie)?,
|
||||
FnRef(fnref) => self.handler.handle_fn_ref(w, fnref)?,
|
||||
InlineCall(inlinecall) => self.handler.handle_inline_call(w, inlinecall)?,
|
||||
InlineSrc(inlinesrc) => self.handler.handle_inline_src(w, inlinesrc)?,
|
||||
Link(link) => self.handler.handle_link(w, link)?,
|
||||
Macros(macros) => self.handler.handle_macros(w, macros)?,
|
||||
RadioTarget(radiotarget) => self.handler.handle_radio_target(w, radiotarget)?,
|
||||
Snippet(snippet) => self.handler.handle_snippet(w, snippet)?,
|
||||
Target(target) => self.handler.handle_target(w, target)?,
|
||||
StartBold => self.handler.handle_start_bold(w)?,
|
||||
EndBold => self.handler.handle_end_bold(w)?,
|
||||
StartItalic => self.handler.handle_start_italic(w)?,
|
||||
EndItalic => self.handler.handle_end_italic(w)?,
|
||||
StartStrike => self.handler.handle_start_strike(w)?,
|
||||
EndStrike => self.handler.handle_end_strike(w)?,
|
||||
StartUnderline => self.handler.handle_start_underline(w)?,
|
||||
EndUnderline => self.handler.handle_end_underline(w)?,
|
||||
Verbatim(contents) => self.handler.handle_verbatim(w, contents)?,
|
||||
Code(contents) => self.handler.handle_code(w, contents)?,
|
||||
Text(contents) => self.handler.handle_text(w, contents)?,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,8 @@
|
|||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
#[macro_use]
|
||||
extern crate jetscii;
|
||||
extern crate regex;
|
||||
|
||||
#[macro_use]
|
||||
mod utils;
|
||||
|
|
138
src/parser.rs
138
src/parser.rs
|
@ -5,19 +5,56 @@ use objects::*;
|
|||
#[cfg_attr(test, derive(PartialEq))]
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub enum Container {
|
||||
Headline { beg: usize, end: usize },
|
||||
Section { end: usize },
|
||||
Headline {
|
||||
beg: usize,
|
||||
end: usize,
|
||||
},
|
||||
Section {
|
||||
end: usize,
|
||||
},
|
||||
|
||||
Paragraph { end: usize, trailing: usize },
|
||||
CenterBlock { contents_end: usize, end: usize },
|
||||
QuoteBlock { contents_end: usize, end: usize },
|
||||
SpecialBlock { contents_end: usize, end: usize },
|
||||
DynBlock { contents_end: usize, end: usize },
|
||||
Paragraph {
|
||||
end: usize,
|
||||
trailing: usize,
|
||||
},
|
||||
CenterBlock {
|
||||
contents_end: usize,
|
||||
end: usize,
|
||||
},
|
||||
QuoteBlock {
|
||||
contents_end: usize,
|
||||
end: usize,
|
||||
},
|
||||
SpecialBlock {
|
||||
contents_end: usize,
|
||||
end: usize,
|
||||
},
|
||||
DynBlock {
|
||||
contents_end: usize,
|
||||
end: usize,
|
||||
},
|
||||
|
||||
Italic { end: usize },
|
||||
Strike { end: usize },
|
||||
Bold { end: usize },
|
||||
Underline { end: usize },
|
||||
List {
|
||||
ident: usize,
|
||||
is_ordered: bool,
|
||||
end: usize,
|
||||
},
|
||||
ListItem {
|
||||
end: usize,
|
||||
},
|
||||
|
||||
Italic {
|
||||
end: usize,
|
||||
},
|
||||
Strike {
|
||||
end: usize,
|
||||
},
|
||||
Bold {
|
||||
end: usize,
|
||||
},
|
||||
Underline {
|
||||
end: usize,
|
||||
},
|
||||
}
|
||||
|
||||
#[cfg_attr(test, derive(PartialEq))]
|
||||
|
@ -68,8 +105,14 @@ pub enum Event<'a> {
|
|||
contents: &'a str,
|
||||
},
|
||||
|
||||
ListStart,
|
||||
ListEnd,
|
||||
StartList {
|
||||
is_ordered: bool,
|
||||
},
|
||||
EndList {
|
||||
is_ordered: bool,
|
||||
},
|
||||
StartListItem,
|
||||
EndListItem,
|
||||
|
||||
AffKeywords,
|
||||
|
||||
|
@ -200,6 +243,15 @@ impl<'a> Parser<'a> {
|
|||
contents_end: contents_end + self.off,
|
||||
end: end + self.off,
|
||||
}),
|
||||
Element::List {
|
||||
ident,
|
||||
is_ordered,
|
||||
end,
|
||||
} => self.stack.push(Container::List {
|
||||
ident,
|
||||
is_ordered,
|
||||
end: end + self.off,
|
||||
}),
|
||||
_ => (),
|
||||
}
|
||||
self.off += off;
|
||||
|
@ -238,6 +290,15 @@ impl<'a> Parser<'a> {
|
|||
obj.into()
|
||||
}
|
||||
|
||||
fn next_list_item(&mut self, end: usize, ident: usize) -> Event<'a> {
|
||||
let (beg, end) = List::parse_item(&self.text[self.off..end], ident);
|
||||
self.stack.push(Container::ListItem {
|
||||
end: self.off + end,
|
||||
});
|
||||
self.off += beg;
|
||||
Event::StartListItem
|
||||
}
|
||||
|
||||
fn end(&mut self) -> Event<'a> {
|
||||
match self.stack.pop().unwrap() {
|
||||
Container::Paragraph { .. } => Event::EndParagraph,
|
||||
|
@ -251,6 +312,38 @@ impl<'a> Parser<'a> {
|
|||
Container::QuoteBlock { .. } => Event::EndQuoteBlock,
|
||||
Container::SpecialBlock { .. } => Event::EndSpecialBlock,
|
||||
Container::DynBlock { .. } => Event::EndDynBlock,
|
||||
Container::List { is_ordered, .. } => Event::EndList { is_ordered },
|
||||
Container::ListItem { .. } => Event::EndListItem,
|
||||
}
|
||||
}
|
||||
|
||||
fn check_off(&self) {
|
||||
use self::Container::*;
|
||||
|
||||
if let Some(container) = self.stack.last() {
|
||||
match *container {
|
||||
Headline { end, .. }
|
||||
| Section { end }
|
||||
| List { end, .. }
|
||||
| ListItem { end }
|
||||
| Italic { end }
|
||||
| Strike { end }
|
||||
| Bold { end }
|
||||
| Underline { end } => {
|
||||
assert!(self.off <= end);
|
||||
}
|
||||
Paragraph { end, trailing } => {
|
||||
assert!(self.off <= trailing);
|
||||
assert!(self.off <= end);
|
||||
}
|
||||
CenterBlock { contents_end, end }
|
||||
| QuoteBlock { contents_end, end }
|
||||
| SpecialBlock { contents_end, end }
|
||||
| DynBlock { contents_end, end } => {
|
||||
assert!(self.off <= contents_end);
|
||||
assert!(self.off <= end);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -259,6 +352,9 @@ impl<'a> Iterator for Parser<'a> {
|
|||
type Item = Event<'a>;
|
||||
|
||||
fn next(&mut self) -> Option<Event<'a>> {
|
||||
//
|
||||
self.check_off();
|
||||
|
||||
if self.stack.is_empty() {
|
||||
if self.off >= self.text.len() {
|
||||
None
|
||||
|
@ -299,6 +395,21 @@ impl<'a> Iterator for Parser<'a> {
|
|||
self.next_ele(contents_end)
|
||||
}
|
||||
}
|
||||
Container::List { end, ident, .. } => {
|
||||
if self.off >= end {
|
||||
self.end()
|
||||
} else {
|
||||
self.next_list_item(end, ident)
|
||||
}
|
||||
}
|
||||
Container::ListItem { end } => {
|
||||
if self.off >= end {
|
||||
self.end()
|
||||
} else {
|
||||
// TODO: handle nested list
|
||||
self.next_obj(end)
|
||||
}
|
||||
}
|
||||
Container::Section { end } => {
|
||||
if self.off >= end {
|
||||
self.end()
|
||||
|
@ -370,6 +481,7 @@ impl<'a> From<Element<'a>> for Event<'a> {
|
|||
Element::ExportBlock { args, contents } => Event::ExportBlock { args, contents },
|
||||
Element::SrcBlock { args, contents } => Event::SrcBlock { args, contents },
|
||||
Element::VerseBlock { args, contents } => Event::VerseBlock { args, contents },
|
||||
Element::List { is_ordered, .. } => Event::StartList { is_ordered },
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue