feat(rust)!: replace add parse_with_options, deprecate parse_with

Co-Authored-By: ObserverOfTime <chronobserver@disroot.org>
Co-Authored-By: Jamee Kim <jameekim@nodaplife.me>

Author: 3 people

Cargo.lock

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
 use std::num::NonZeroU16;
 
-use tree_sitter::{InputEdit, Language, Node, Parser, Point, Range, Tree, TreeCursor};
+use tree_sitter::{
+    InputEdit, Language, Node, ParseOptions, Parser, Point, Range, Tree, TreeCursor,
+};
 
 use crate::{INLINE_LANGUAGE, LANGUAGE};
 
@@ -16,7 +18,7 @@ pub struct MarkdownParser {
 
 /// A stateful object for walking a [`MarkdownTree`] efficiently.
 ///
-/// This exposes the same methdos as [`TreeCursor`], but abstracts away the
+/// This exposes the same methods as [`TreeCursor`], but abstracts away the
 /// double block / inline structure of [`MarkdownTree`].
 pub struct MarkdownCursor<'a> {
     markdown_tree: &'a MarkdownTree,
@@ -33,7 +35,7 @@ impl<'a> MarkdownCursor<'a> {
         }
     }
 
-    /// Returns `true` if the current node is from the (inline language)[INLINE_LANGUAGE]
+    /// Returns `true` if the current node is from the [INLINE_LANGUAGE](inline language)
     ///
     /// This information is needed to handle "tree-sitter internal" data like
     /// [`field_id`](Self::field_id) correctly.
@@ -230,6 +232,28 @@ impl MarkdownTree {
     }
 }
 
+/// The options used while parsing a [`MarkdownTree`].
+///
+/// This abstracts away the double block / inline structure of [`MarkdownParser`].
+#[derive(Default)]
+pub struct MarkdownParseOptions<'a> {
+    block_options: Option<ParseOptions<'a>>,
+    inline_options: Option<ParseOptions<'a>>,
+}
+
+impl<'a> MarkdownParseOptions<'a> {
+    /// Creates a new [MarkdownParseOptions] instance.
+    pub fn new(
+        block_options: Option<ParseOptions<'a>>,
+        inline_options: Option<ParseOptions<'a>>,
+    ) -> Self {
+        MarkdownParseOptions {
+            block_options,
+            inline_options,
+        }
+    }
+}
+
 impl Default for MarkdownParser {
     fn default() -> Self {
         let block_language = LANGUAGE.into();
@@ -244,6 +268,16 @@ impl Default for MarkdownParser {
 }
 
 impl MarkdownParser {
+    /// Parse a slice of UTF8 text.
+    #[deprecated(since = "0.5.0", note = "Prefer `parse_with_options` instead")]
+    pub fn parse_with<T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
+        &mut self,
+        callback: &mut F,
+        old_tree: Option<&MarkdownTree>,
+    ) -> Option<MarkdownTree> {
+        self.parse_with_options(callback, old_tree, MarkdownParseOptions::default())
+    }
+
     /// Parse a slice of UTF8 text.
     ///
     /// # Arguments:
@@ -252,14 +286,17 @@ impl MarkdownParser {
     ///   If the text of the document has changed since `old_tree` was
     ///   created, then you must edit `old_tree` to match the new text using
     ///   [MarkdownTree::edit].
+    /// * `options` The [options][MarkdownParseOptions] used for parsing.
+    ///   Use `MarkdownParseOptions::default()` if you don't need to pass any options.
     ///
     /// Returns a [MarkdownTree] if parsing succeeded, or `None` if:
     ///  * The timeout set with [tree_sitter::Parser::set_timeout_micros] expired
     ///  * The cancellation flag set with [tree_sitter::Parser::set_cancellation_flag] was flipped
-    pub fn parse_with<T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
+    pub fn parse_with_options<T: AsRef<[u8]>, F: FnMut(usize, Point) -> T>(
         &mut self,
         callback: &mut F,
         old_tree: Option<&MarkdownTree>,
+        mut options: MarkdownParseOptions<'_>,
     ) -> Option<MarkdownTree> {
         let MarkdownParser {
             parser,
@@ -275,7 +312,7 @@ impl MarkdownParser {
         let block_tree = parser.parse_with_options(
             callback,
             old_tree.map(|tree| &tree.block_tree),
-            None, // No progress callback
+            options.block_options.as_mut().map(|b_opt| b_opt.reborrow()),
         )?;
         let (mut inline_trees, mut inline_indices) = if let Some(old_tree) = old_tree {
             let len = old_tree.inline_trees.len();
@@ -329,7 +366,10 @@ impl MarkdownParser {
             let inline_tree = parser.parse_with_options(
                 callback,
                 old_tree.and_then(|old_tree| old_tree.inline_trees.get(i)),
-                None, // No progress callback
+                options
+                    .inline_options
+                    .as_mut()
+                    .map(|b_opt| b_opt.reborrow()),
             )?;
             inline_trees.push(inline_tree);
             inline_indices.insert(node.id(), i);
@@ -358,7 +398,11 @@ impl MarkdownParser {
     ///  * The timeout set with [tree_sitter::Parser::set_timeout_micros] expired
     ///  * The cancellation flag set with [tree_sitter::Parser::set_cancellation_flag] was flipped
     pub fn parse(&mut self, text: &[u8], old_tree: Option<&MarkdownTree>) -> Option<MarkdownTree> {
-        self.parse_with(&mut |byte, _| &text[byte..], old_tree)
+        self.parse_with_options(
+            &mut |byte, _| &text[byte..],
+            old_tree,
+            MarkdownParseOptions::default(),
+        )
     }
 }