chore: prepare for v0.10.0-alpha.1

src/syntax/object.rs

@@ -0,0 +1,194 @@
+use nom::{AsBytes, IResult, InputLength, InputTake};
+
+use super::{
+    combinator::GreenElement,
+    cookie::cookie_node,
+    emphasis::{bold_node, code_node, italic_node, strike_node, underline_node, verbatim_node},
+    fn_ref::fn_ref_node,
+    inline_call::inline_call_node,
+    inline_src::inline_src_node,
+    input::Input,
+    link::link_node,
+    macros::macros_node,
+    radio_target::radio_target_node,
+    snippet::snippet_node,
+    target::target_node,
+    timestamp::{timestamp_active_node, timestamp_diary_node, timestamp_inactive_node},
+};
+
+pub struct InlinePositions<'a> {
+    bytes: &'a [u8],
+    pos: usize,
+    next: Option<usize>,
+}
+
+impl InlinePositions<'_> {
+    pub fn new(bytes: &[u8]) -> InlinePositions {
+        InlinePositions {
+            bytes,
+            pos: 0,
+            next: Some(0),
+        }
+    }
+}
+
+impl Iterator for InlinePositions<'_> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next.take().or_else(|| {
+            jetscii::bytes!(b'@', b'<', b'[', b' ', b'(', b'{', b'\'', b'"', b'\n')
+                .find(&self.bytes[self.pos..])
+                .map(|i| {
+                    self.pos += i + 1;
+
+                    match self.bytes[self.pos - 1] {
+                        b'{' => {
+                            self.next = Some(self.pos);
+                            self.pos - 1
+                        }
+                        b' ' | b'(' | b'\'' | b'"' | b'\n' => self.pos,
+                        _ => self.pos - 1,
+                    }
+                })
+        })
+    }
+}
+
+pub fn object_nodes(input: Input) -> Vec<GreenElement> {
+    // debug_assert!(!input.is_empty());
+    let nodes = object_nodes_base(input);
+    debug_assert_eq!(
+        input.as_str(),
+        nodes.iter().fold(String::new(), |s, i| s + &i.to_string()),
+        "parser must be lossless"
+    );
+    nodes
+}
+
+fn object_nodes_base(input: Input) -> Vec<GreenElement> {
+    let mut children = vec![];
+
+    let mut i = input;
+    'l: loop {
+        for (input, head) in InlinePositions::new(i.as_bytes()).map(|idx| i.take_split(idx)) {
+            if let Ok((input, node)) = object_node(input) {
+                if !head.is_empty() {
+                    children.push(head.text_token())
+                }
+                children.push(node);
+                i = input;
+                continue 'l;
+            }
+        }
+
+        break;
+    }
+
+    if !i.is_empty() {
+        children.push(i.text_token());
+    }
+
+    children
+}
+
+fn object_node(i: Input) -> IResult<Input, GreenElement, ()> {
+    if i.input_len() < 3 {
+        return Err(nom::Err::Error(()));
+    }
+
+    match &i.as_bytes()[0] {
+        b'*' => bold_node(i),
+        b'+' => strike_node(i),
+        b'/' => italic_node(i),
+        b'_' => underline_node(i),
+        b'=' => verbatim_node(i),
+        b'~' => code_node(i),
+        b'@' => snippet_node(i),
+        b'{' => macros_node(i),
+        b'<' => radio_target_node(i)
+            .or_else(|_| target_node(i))
+            .or_else(|_| timestamp_diary_node(i))
+            .or_else(|_| timestamp_active_node(i)),
+        b'[' => cookie_node(i)
+            .or_else(|_| link_node(i))
+            .or_else(|_| fn_ref_node(i))
+            .or_else(|_| timestamp_inactive_node(i)),
+        b'c' => inline_call_node(i),
+        b's' => inline_src_node(i),
+        _ => Err(nom::Err::Error(())),
+    }
+}
+
+#[test]
+fn parse() {
+    use crate::{
+        syntax::{combinator::node, SyntaxKind, SyntaxNode},
+        ParseConfig,
+    };
+
+    let t = |input: &str| {
+        let config = &ParseConfig::default();
+        let children = object_nodes((input, config).into());
+        SyntaxNode::new_root(node(SyntaxKind::PARAGRAPH, children).into_node().unwrap())
+    };
+
+    insta::assert_debug_snapshot!(
+        t("~org-inlinetask-min-level~[fn:oiml:The default value of \n~org-inlinetask-min-level~ is =15=.]"),
+        @r###"
+    PARAGRAPH@0..93
+      CODE@0..26
+        TILDE@0..1 "~"
+        TEXT@1..25 "org-inlinetask-min-level"
+        TILDE@25..26 "~"
+      FN_REF@26..93
+        L_BRACKET@26..27 "["
+        TEXT@27..29 "fn"
+        COLON@29..30 ":"
+        TEXT@30..34 "oiml"
+        COLON@34..35 ":"
+        TEXT@35..57 "The default value of \n"
+        CODE@57..83
+          TILDE@57..58 "~"
+          TEXT@58..82 "org-inlinetask-min-level"
+          TILDE@82..83 "~"
+        TEXT@83..87 " is "
+        VERBATIM@87..91
+          EQUAL@87..88 "="
+          TEXT@88..90 "15"
+          EQUAL@90..91 "="
+        TEXT@91..92 "."
+        R_BRACKET@92..93 "]"
+    "###
+    );
+
+    insta::assert_debug_snapshot!(
+      t(r#"Org is a /plaintext markup syntax/ developed with *Emacs* in 2003.
+The canonical parser is =org-element.el=, which provides a number of
+functions starting with ~org-element-~."#),
+      @r###"
+    PARAGRAPH@0..175
+      TEXT@0..9 "Org is a "
+      ITALIC@9..34
+        SLASH@9..10 "/"
+        TEXT@10..33 "plaintext markup syntax"
+        SLASH@33..34 "/"
+      TEXT@34..50 " developed with "
+      BOLD@50..57
+        STAR@50..51 "*"
+        TEXT@51..56 "Emacs"
+        STAR@56..57 "*"
+      TEXT@57..91 " in 2003.\nThe canonic ..."
+      VERBATIM@91..107
+        EQUAL@91..92 "="
+        TEXT@92..106 "org-element.el"
+        EQUAL@106..107 "="
+      TEXT@107..160 ", which provides a nu ..."
+      CODE@160..174
+        TILDE@160..161 "~"
+        TEXT@161..173 "org-element-"
+        TILDE@173..174 "~"
+      TEXT@174..175 "."
+    "###
+    );
+}