chore: prep v1.12.1

chore: prep v1.12.0 release

CHANGELOG.md

@@ -2,7 +2,29 @@
 
 ## Unreleased
 
-## 1.11.0
+## 1.12.1
+
+### Fixed
+
+- Panic when searching for an indent in non-ASCII content. Thanks to [@CoralPink](https://github.com/CoralPink) for the report! ([#128](https://github.com/tommilligan/mdbook-admonish/pull/128)
+
+## 1.12.0
+
+### Added
+
+- Admonitions are now supported when indented inside other elements, such as a list. Thanks to [@mattburgess](https://github.com/mattburgess) for the report! ([#124](https://github.com/tommilligan/mdbook-admonish/pull/124)
+
+## 1.11.1
+
+### Fixed
+
+- Reverted internal dependency upgrades that unintentionally increased MSRV from 1.66.0 in 1.11.0
+
+## 1.11.0 (yanked)
+
+**Note:** This release has been yanked.
+
+It unintentionally increased the MSRV from 1.66.0
 
 ### Changed
 
@@ -146,7 +168,11 @@ This behaviour is [documented in the readme here](https://github.com/tommilligan
 - Flattened indentation of generated HTML, otherwise it's styled as a markdown code block
 - Fixed edge cases where the info string changes length when parsed, causing title/body to be incorrectly split
 
-## 1.3.0
+## 1.3.0 (yanked)
+
+**Note:** This release has been yanked.
+
+It unintentionally introduced a serious parsing bug.
 
 ### Added
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mdbook-admonish"
-version = "1.11.0"
+version = "1.12.1"
 edition = "2021"
 
 authors = ["Tom Milligan <code@tommilligan.net>"]
@@ -25,22 +25,22 @@ name = "mdbook_admonish"
 path = "src/lib.rs"
 
 [dependencies]
-anyhow = "1.0.72"
+anyhow = "1.0.75"
 clap = { version = "4", default_features = false, features = ["std", "derive"], optional = true }
 env_logger = { version = "0.10", default_features = false, optional = true }
-log = "0.4.19"
+log = "0.4.20"
 mdbook = "0.4.34"
 once_cell = "1.18.0"
 pulldown-cmark = "0.9.3"
-regex = "1.9.3"
+regex = "1.9.5"
 semver = "1.0.18"
-serde = { version = "1.0.183", features = ["derive"] }
-serde_json = "1.0.104"
+serde = { version = "1.0.188", features = ["derive"] }
+serde_json = "1.0.107"
 # The version of toml that mdbook uses internally (and uses in it's public api)
 # Only used for compatilibilty with the mdbook public api
 toml_mdbook = { package = "toml", version = "0.5.11" }
-toml = "0.7.6"
-toml_edit = { version = "0.19.14", optional = true }
+toml = "0.7.8"
+toml_edit = { version = "0.19.15", optional = true }
 
 [dev-dependencies]
 pretty_assertions = "1.4.0"

integration/expected/chapter_1_main.html

@@ -90,4 +90,29 @@ let x = 20;
 <span class="boring">}</span></code></pre></pre>
 </div>
 </div>
+<p>In a list:</p>
+<ol>
+<li>
+<p>Thing one</p>
+<pre><code class="language-sh">Thing one
+</code></pre>
+</li>
+<li>
+<p>Thing two</p>
+<div id="admonition-note-4" class="admonition note">
+<div class="admonition-title">
+<p>Note</p>
+<p><a class="admonition-anchor-link" href="#admonition-note-4"></a></p>
+</div>
+<div>
+<p>Thing two</p>
+</div>
+</div>
+</li>
+<li>
+<p>Thing three</p>
+<pre><code class="language-sh">Thing three
+</code></pre>
+</li>
+</ol>
 

integration/src/chapter_1.md

@@ -41,3 +41,23 @@ let x = 10;
 let x = 20;
 ```
 ````
+
+In a list:
+
+1. Thing one
+
+   ```sh
+   Thing one
+   ```
+
+1. Thing two
+
+   ```admonish
+   Thing two
+   ```
+
+1. Thing three
+
+   ```sh
+   Thing three
+   ```

src/markdown.rs

@@ -28,12 +28,15 @@ pub(crate) fn preprocess(
     for (event, span) in events.into_offset_iter() {
         if let Event::Start(Tag::CodeBlock(Fenced(info_string))) = event.clone() {
             let span_content = &content[span.start..span.end];
+            const INDENT_SCAN_MAX: usize = 1024;
+            let indent = indent_of(content, span.start, INDENT_SCAN_MAX);
 
             let admonition = match parse_admonition(
                 info_string.as_ref(),
                 admonition_defaults,
                 span_content,
                 on_failure,
+                indent,
             ) {
                 Some(admonition) => admonition,
                 None => continue,
@@ -62,11 +65,73 @@ pub(crate) fn preprocess(
     Ok(content)
 }
 
+/// Returns the indent of the given position.
+///
+/// Defined as the number of characters between the given `position` (where
+/// position is a valid char boundary byte-index in `content`),
+/// and the previous newline character `\n`.
+///
+/// `max` is the maximum number of characters to scan before assuming there is
+/// no indent (will return zero if exceeded).
+///
+/// ## Panics
+///
+/// Will panic if `position` is not a valid utf-8 char boundary index of `content`.
+fn indent_of(content: &str, position: usize, max: usize) -> usize {
+    // Scan for a line start before this span.
+    content[..position]
+        .chars()
+        .rev()
+        // For safety, only scan up to a fixed limit of the text
+        .take(max)
+        .position(|c| c == '\n')
+        // If we can't find a newline, assume no indent
+        .unwrap_or_default()
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
     use pretty_assertions::assert_eq;
 
+    #[test]
+    fn indent_of_samples() {
+        for (content, position, max, expected) in [
+            // Empty case
+            ("", 0, 10, 0),
+            ("no newline", 4, 10, 0),
+            // Newline at position 5, difference from 8 is 3
+            ("with\nnewline", 8, 10, 3),
+            // If no newline in safety limit, return 0
+            ("with\nnewline", 8, 2, 0),
+            // Safety limit is characters, not bytes
+            // Regression test for FIXME LINK
+            (
+                "例えばこれは",
+                // Position is generated by mdbook internals, should be valid char limit
+                // This mimics the second character starting the span
+                "例".len(),
+                // Any arbitrary safetly limit should be valid
+                1,
+                // Should not panic
+                0,
+            ),
+            (
+                "例え\n  れは",
+                // Position is generated by mdbook internals, should be valid char limit
+                // This mimics the second character starting the span
+                "例え\n  ".len(),
+                // Any arbitrary safetly limit should be valid
+                4,
+                // Should not panic
+                2,
+            ),
+        ] {
+            let actual = indent_of(content, position, max);
+            assert_eq!(actual, expected);
+        }
+    }
+
     fn prep(content: &str) -> String {
         preprocess(
             content,
@@ -732,4 +797,62 @@ Text
 
         assert_eq!(expected, prep(content));
     }
+
+    #[test]
+    fn list_embed() {
+        let content = r#"# Chapter
+
+1. Thing one
+
+   ```sh
+   Thing one
+   ```
+
+1. Thing two
+
+   ```admonish
+   Thing two
+   ```
+
+1. Thing three
+
+   ```sh
+   Thing three
+   ```
+"#;
+
+        let expected = r##"# Chapter
+
+1. Thing one
+
+   ```sh
+   Thing one
+   ```
+
+1. Thing two
+
+   
+   <div id="admonition-note" class="admonition note">
+   <div class="admonition-title">
+   
+   Note
+   
+   <a class="admonition-anchor-link" href="#admonition-note"></a>
+   </div>
+   <div>
+   
+      Thing two
+   
+   </div>
+   </div>
+
+1. Thing three
+
+   ```sh
+   Thing three
+   ```
+"##;
+
+        assert_eq!(expected, prep(content));
+    }
 }

src/parse.rs

@@ -23,6 +23,7 @@ pub(crate) fn parse_admonition<'a>(
     admonition_defaults: &'a AdmonitionDefaults,
     content: &'a str,
     on_failure: OnFailure,
+    indent: usize,
 ) -> Option<Result<Admonition<'a>>> {
     // We need to know fence details anyway for error messages
     let extracted = extract_admonish_body(content);
@@ -30,8 +31,6 @@ pub(crate) fn parse_admonition<'a>(
     let info = AdmonitionMeta::from_info_string(info_string, admonition_defaults)?;
     let info = match info {
         Ok(info) => info,
-        // FIXME return error messages to break build if configured
-        // Err(message) => return Some(Err(content)),
         Err(message) => {
             // Construct a fence capable of enclosing whatever we wrote for the
             // actual input block
@@ -63,6 +62,7 @@ Original markdown input:
 {enclosing_fence}
 "#
                         )),
+                        indent,
                     })
                 }
                 OnFailure::Bail => Err(anyhow!("Error processing admonition, bailing:\n{content}")),
@@ -70,7 +70,24 @@ Original markdown input:
         }
     };
 
-    Some(Ok(Admonition::new(info, extracted.body)))
+    Some(Ok(Admonition::new(
+        info,
+        extracted.body,
+        // Note that this is a bit hacky - the fence information comes from the start
+        // of the block, and includes the whole line.
+        //
+        // This is more likely to be what we want, as ending indentation is unrelated
+        // according to the commonmark spec (ref https://spec.commonmark.org/0.12/#example-85)
+        //
+        // The main case we're worried about here is indenting enough to be inside list items,
+        // and in this case the starting code fence must be indented enough to be considered
+        // part of the list item.
+        //
+        // The hacky thing is that we're considering line indent in the document as a whole,
+        // not relative to the context of some containing item. But I think that's what we
+        // want for now, anyway.
+        indent,
+    )))
 }
 
 /// We can't trust the info string length to find the start of the body

src/render.rs

@@ -31,10 +31,11 @@ pub(crate) struct Admonition<'a> {
     pub(crate) content: Cow<'a, str>,
     pub(crate) additional_classnames: Vec<String>,
     pub(crate) collapsible: bool,
+    pub(crate) indent: usize,
 }
 
 impl<'a> Admonition<'a> {
-    pub(crate) fn new(info: AdmonitionMeta, content: &'a str) -> Self {
+    pub(crate) fn new(info: AdmonitionMeta, content: &'a str, indent: usize) -> Self {
         let AdmonitionMeta {
             directive,
             title,
@@ -47,6 +48,7 @@ impl<'a> Admonition<'a> {
             content: Cow::Borrowed(content),
             additional_classnames,
             collapsible,
+            indent,
         }
     }
 
@@ -66,17 +68,18 @@ impl<'a> Admonition<'a> {
         let mut additional_class = Cow::Borrowed(self.directive.classname());
         let title = &self.title;
         let content = &self.content;
+        let indent = " ".repeat(self.indent);
 
         let title_block = if self.collapsible { "summary" } else { "div" };
 
         let title_html = if !title.is_empty() {
             Cow::Owned(format!(
-                r##"<{title_block} class="admonition-title">
-
-{title}
-
-<a class="admonition-anchor-link" href="#{ANCHOR_ID_PREFIX}-{anchor_id}"></a>
-</{title_block}>
+                r##"{indent}<{title_block} class="admonition-title">
+{indent}
+{indent}{title}
+{indent}
+{indent}<a class="admonition-anchor-link" href="#{ANCHOR_ID_PREFIX}-{anchor_id}"></a>
+{indent}</{title_block}>
 "##
             ))
         } else {
@@ -100,13 +103,13 @@ impl<'a> Admonition<'a> {
         //   rendered as markdown paragraphs.
         format!(
             r#"
-<{admonition_block} id="{ANCHOR_ID_PREFIX}-{anchor_id}" class="admonition {additional_class}">
-{title_html}<div>
-
-{content}
-
-</div>
-</{admonition_block}>"#,
+{indent}<{admonition_block} id="{ANCHOR_ID_PREFIX}-{anchor_id}" class="admonition {additional_class}">
+{title_html}{indent}<div>
+{indent}
+{indent}{content}
+{indent}
+{indent}</div>
+{indent}</{admonition_block}>"#,
         )
     }