panache-cli 2.55.0__tar.gz → 2.56.0__tar.gz

{panache_cli-2.55.0 → panache_cli-2.56.0}/Cargo.lock

@@ -1151,7 +1151,7 @@ checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
 
 [[package]]
 name = "panache"
-version = "2.55.0"
+version = "2.56.0"
 dependencies = [
  "annotate-snippets",
  "assert_cmd",
@@ -1194,7 +1194,7 @@ dependencies = [
 
 [[package]]
 name = "panache-formatter"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "insta",
  "log",
@@ -1202,6 +1202,9 @@ dependencies = [
  "pretty_yaml",
  "pulldown-latex",
  "rowan",
+ "schemars",
+ "serde",
+ "serde_json",
  "similar-asserts",
  "toml",
  "unicode-width",
@@ -1209,7 +1212,7 @@ dependencies = [
 
 [[package]]
 name = "panache-parser"
-version = "0.17.1"
+version = "0.17.2"
 dependencies = [
  "entities",
  "insta",
@@ -1782,9 +1785,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.117"
+version = "2.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2132,9 +2135,9 @@ dependencies = [
 
 [[package]]
 name = "which"
-version = "8.0.3"
+version = "8.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c789537cf2f7f55be8e6192f92e464174ee55f91af622777f7f1ceb0dbccd03e"
+checksum = "48d7cd18d4acb58fb3cdfe9ea54e6cd96a4e7d4cc45c56338b236e82dad47248"
 dependencies = [
  "libc",
 ]

{panache_cli-2.55.0 → panache_cli-2.56.0}/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Johan Larsson <johan@jolars.co>"]
 
 [package]
 name = "panache"
-version = "2.55.0"
+version = "2.56.0"
 edition.workspace = true
 readme = "README.md"
 description = "An LSP, formatter, and linter for Markdown, Quarto, and R Markdown"
@@ -31,14 +31,6 @@ authors.workspace = true
 
 [workspace]
 members = ["crates/panache-parser", "crates/panache-formatter"]
-# Excluded because this crate must be compiled to wasm32-unknown-unknown to work
-# (it relies on `dprint_core::generate_plugin_code!`, which is only defined on
-# that target). Build with:
-#   cargo build --manifest-path crates/panache-dprint/Cargo.toml \
-#     --release --target wasm32-unknown-unknown
-exclude = [
-    "crates/panache-dprint",
-]
 
 [lib]
 doctest = false
@@ -49,8 +41,8 @@ path = "src/main.rs"
 required-features = ["cli"]
 
 [dependencies]
-panache-formatter = { path = "crates/panache-formatter", version = "0.13.0" }
-panache-parser = { path = "crates/panache-parser", version = "0.17.1", features = [
+panache-formatter = { path = "crates/panache-formatter", version = "0.14.0" }
+panache-parser = { path = "crates/panache-parser", version = "0.17.2", features = [
     "serde",
     "schema",
 ] }

{panache_cli-2.55.0 → panache_cli-2.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: panache-cli
-Version: 2.55.0
+Version: 2.56.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{panache_cli-2.55.0 → panache_cli-2.56.0}/crates/panache-formatter/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.14.0](https://github.com/jolars/panache/compare/panache-formatter-v0.13.0...panache-formatter-v0.14.0) (2026-06-17)
+
+### Features
+- **formatter:** expose config-enum JsonSchema behind schema feature ([`5062bb5`](https://github.com/jolars/panache/commit/5062bb52db346572748752210e2c6ec22b97e37d))
+- **formatter:** add `table-indent` config option ([`1365b80`](https://github.com/jolars/panache/commit/1365b801c48fbb8670ff8343884b20e5b427f1c7)), resolves [#344](https://github.com/jolars/panache/issues/344) and [#352](https://github.com/jolars/panache/issues/352)
+- **formatter:** hang math binary continuations flush under the RHS ([`0fae430`](https://github.com/jolars/panache/commit/0fae4303b8a758a7ac3a218170dfc9fb7a0c4409))
+- **formatter:** align assignment-led math chains under the RHS ([`e20d0d6`](https://github.com/jolars/panache/commit/e20d0d6c36b4fa7bae295ea41ddc27d770fa4755))
+
+### Bug Fixes
+- **formatter:** collapse line breaks inside split citations ([`148f69f`](https://github.com/jolars/panache/commit/148f69fb2d97ba5c42eb0b92645163cdc7ee4602))
+
+### Dependencies
+- updated crates/panache-parser to v0.17.2
+
 ## [0.13.0](https://github.com/jolars/panache/compare/panache-formatter-v0.12.0...panache-formatter-v0.13.0) (2026-06-15)
 
 ### Features

{panache_cli-2.55.0 → panache_cli-2.56.0}/crates/panache-formatter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "panache-formatter"
-version = "0.13.0"
+version = "0.14.0"
 edition.workspace = true
 include = [
     "/src/**/*",
@@ -18,12 +18,20 @@ keywords = ["quarto", "pandoc", "markdown", "formatter"]
 categories = ["text-processing"]
 
 [dependencies]
-panache-parser = { path = "../panache-parser", version = "0.17.1" }
+panache-parser = { path = "../panache-parser", version = "0.17.2" }
 log = { version = "0.4.31", features = ["release_max_level_debug"] }
 rowan = "0.16.1"
+serde = { version = "1.0", features = ["derive"], optional = true }
+schemars = { version = "1.0", optional = true }
 unicode-width = "0.2"
 
+[features]
+default = []
+serde = ["dep:serde", "panache-parser/serde"]
+schema = ["serde", "dep:schemars", "panache-parser/schema"]
+
 [dev-dependencies]
+serde_json = "1.0"
 insta = { version = "1.47.2", features = ["json"] }
 # TEMPORARY: cross-validation oracle only (tests/yaml_cross_validation.rs).
 # The in-tree formatter is the source of truth. Drop this dep (and re-base

{panache_cli-2.55.0 → panache_cli-2.56.0}/crates/panache-formatter/src/config.rs

@@ -15,6 +15,9 @@ fn default_external_max_parallel() -> usize {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum MathDelimiterStyle {
     /// Preserve original delimiter style (\(...\) stays \(...\), $...$ stays $...$)
     #[default]
@@ -25,7 +28,13 @@ pub enum MathDelimiterStyle {
     Backslash,
 }
 
+/// Default indentation (in columns) for top-level tables.
+pub const DEFAULT_TABLE_INDENT: usize = 2;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum TabStopMode {
     /// Normalize tabs to spaces (4-column tab stop).
     #[default]
@@ -43,6 +52,9 @@ pub struct FormatterConfig {
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum WrapMode {
     Preserve,
     Reflow,
@@ -53,6 +65,9 @@ pub enum WrapMode {
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum LineEnding {
     Auto,
     Lf,
@@ -60,6 +75,9 @@ pub enum LineEnding {
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum BlankLines {
     /// Preserve original blank lines (any number)
     Preserve,
@@ -166,6 +184,11 @@ pub struct Config {
     pub line_width: usize,
     pub math_indent: usize,
     pub math_delimiter_style: MathDelimiterStyle,
+    /// Indentation (in columns) applied to top-level pipe, simple, and
+    /// multiline tables. Grid tables ignore this and stay flush at column 0,
+    /// since Pandoc only recognizes a grid table whose border starts at column
+    /// 0. Nested tables honor their container indent instead.
+    pub table_indent: usize,
     pub tab_stops: TabStopMode,
     pub tab_width: usize,
     pub wrap: Option<WrapMode>,
@@ -202,6 +225,7 @@ impl Default for Config {
             line_width: 80,
             math_indent: 2,
             math_delimiter_style: MathDelimiterStyle::default(),
+            table_indent: DEFAULT_TABLE_INDENT,
             tab_stops: TabStopMode::Normalize,
             tab_width: 4,
             wrap: Some(WrapMode::Reflow),
@@ -249,6 +273,11 @@ impl ConfigBuilder {
         self
     }
 
+    pub fn table_indent(mut self, indent: usize) -> Self {
+        self.config.table_indent = indent;
+        self
+    }
+
     pub fn tab_width(mut self, width: usize) -> Self {
         self.config.tab_width = width;
         self
@@ -273,3 +302,49 @@ impl ConfigBuilder {
         self.config
     }
 }
+
+#[cfg(all(test, feature = "schema"))]
+mod schema_tests {
+    use super::*;
+
+    /// Assert the emitted JSON Schema exposes exactly the expected lowercase
+    /// wire values (and no PascalCase variant names). Substring checks keep this
+    /// robust to schemars emitting a flat `enum` array vs. a `oneOf`-of-`const`
+    /// shape — the doc comments on some variants become per-value descriptions.
+    fn assert_wire_values<T: schemars::JsonSchema>(expected: &[&str]) {
+        let s = serde_json::to_string(&schemars::schema_for!(T)).unwrap();
+        for value in expected {
+            assert!(
+                s.contains(&format!("\"{value}\"")),
+                "expected lowercase wire value {value:?} in schema: {s}"
+            );
+        }
+    }
+
+    #[test]
+    fn math_delimiter_style_values_are_lowercase() {
+        assert_wire_values::<MathDelimiterStyle>(&["preserve", "dollars", "backslash"]);
+    }
+
+    #[test]
+    fn tab_stop_mode_values_are_lowercase() {
+        assert_wire_values::<TabStopMode>(&["normalize", "preserve"]);
+    }
+
+    #[test]
+    fn wrap_mode_values_are_lowercase() {
+        assert_wire_values::<WrapMode>(&["preserve", "reflow", "sentence", "semantic"]);
+        let s = serde_json::to_string(&schemars::schema_for!(WrapMode)).unwrap();
+        assert!(!s.contains("\"Reflow\""), "PascalCase variant leaked: {s}");
+    }
+
+    #[test]
+    fn line_ending_values_are_lowercase() {
+        assert_wire_values::<LineEnding>(&["auto", "lf", "crlf"]);
+    }
+
+    #[test]
+    fn blank_lines_values_are_lowercase() {
+        assert_wire_values::<BlankLines>(&["preserve", "collapse"]);
+    }
+}

{panache_cli-2.55.0 → panache_cli-2.56.0}/crates/panache-formatter/src/formatter/inline.rs

@@ -33,6 +33,85 @@ fn expand_tabs_code_span(text: &str, tab_width: usize) -> String {
     out.trim().to_string()
 }
 
+/// Render a `CITATION` or `CROSSREF` node by concatenating its child tokens.
+///
+/// Both kinds share the same syntax (`[ ... @key ... ]`) and are emitted the
+/// same way: smart-normalize text tokens, skip the whitespace that follows a
+/// blockquote marker, then collapse any internal line break (a citation may be
+/// split across input lines) so the unit reflows like ordinary inline text
+/// instead of pinning a hard newline into the paragraph.
+fn format_citation_like(node: &SyntaxNode, config: &Config) -> String {
+    let mut result = String::new();
+    let mut skip_marker_whitespace = false;
+    for child in node.children_with_tokens() {
+        match child {
+            NodeOrToken::Token(tok) if tok.kind() == SyntaxKind::BLOCK_QUOTE_MARKER => {
+                skip_marker_whitespace = true;
+            }
+            NodeOrToken::Token(tok)
+                if tok.kind() == SyntaxKind::WHITESPACE && skip_marker_whitespace =>
+            {
+                skip_marker_whitespace = false;
+            }
+            NodeOrToken::Token(tok) => {
+                skip_marker_whitespace = false;
+                result.push_str(
+                    normalize_smart_punctuation(
+                        tok.text(),
+                        config.formatter_extensions.smart,
+                        config.formatter_extensions.smart_quotes,
+                    )
+                    .as_ref(),
+                );
+            }
+            NodeOrToken::Node(n) => {
+                skip_marker_whitespace = false;
+                result.push_str(&n.text().to_string());
+            }
+        }
+    }
+    collapse_internal_newlines(&result).into_owned()
+}
+
+/// Collapse any whitespace run that contains a line break into a single space.
+///
+/// A citation or cross-reference split across input lines leaves a literal
+/// newline inside the assembled string. Emitting it verbatim makes the
+/// surrounding paragraph un-reflowable, so we normalize it the way the wrapper
+/// treats ordinary inter-word whitespace.
+fn collapse_internal_newlines(text: &str) -> std::borrow::Cow<'_, str> {
+    if !text.contains('\n') {
+        return std::borrow::Cow::Borrowed(text);
+    }
+    let mut out = String::with_capacity(text.len());
+    let mut chars = text.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch.is_whitespace() {
+            // Consume the whole whitespace run, tracking whether it contains a
+            // line break.
+            let mut has_newline = ch == '\n';
+            let mut run = String::from(ch);
+            while let Some(&next) = chars.peek() {
+                if next.is_whitespace() {
+                    has_newline |= next == '\n';
+                    run.push(next);
+                    chars.next();
+                } else {
+                    break;
+                }
+            }
+            if has_newline {
+                out.push(' ');
+            } else {
+                out.push_str(&run);
+            }
+        } else {
+            out.push(ch);
+        }
+    }
+    std::borrow::Cow::Owned(out)
+}
+
 /// Format an inline node to normalized string (e.g., emphasis with asterisks)
 pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
     match node.kind() {
@@ -615,70 +694,7 @@ pub(super) fn format_inline_node(node: &SyntaxNode, config: &Config) -> String {
                 .join(" ");
             format!("^[{}]", normalized)
         }
-        SyntaxKind::CITATION => {
-            let mut result = String::new();
-            let mut skip_marker_whitespace = false;
-            for child in node.children_with_tokens() {
-                match child {
-                    NodeOrToken::Token(tok) if tok.kind() == SyntaxKind::BLOCK_QUOTE_MARKER => {
-                        skip_marker_whitespace = true;
-                    }
-                    NodeOrToken::Token(tok)
-                        if tok.kind() == SyntaxKind::WHITESPACE && skip_marker_whitespace =>
-                    {
-                        skip_marker_whitespace = false;
-                    }
-                    NodeOrToken::Token(tok) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(
-                            normalize_smart_punctuation(
-                                tok.text(),
-                                config.formatter_extensions.smart,
-                                config.formatter_extensions.smart_quotes,
-                            )
-                            .as_ref(),
-                        );
-                    }
-                    NodeOrToken::Node(n) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(&n.text().to_string());
-                    }
-                }
-            }
-            result
-        }
-        SyntaxKind::CROSSREF => {
-            let mut result = String::new();
-            let mut skip_marker_whitespace = false;
-            for child in node.children_with_tokens() {
-                match child {
-                    NodeOrToken::Token(tok) if tok.kind() == SyntaxKind::BLOCK_QUOTE_MARKER => {
-                        skip_marker_whitespace = true;
-                    }
-                    NodeOrToken::Token(tok)
-                        if tok.kind() == SyntaxKind::WHITESPACE && skip_marker_whitespace =>
-                    {
-                        skip_marker_whitespace = false;
-                    }
-                    NodeOrToken::Token(tok) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(
-                            normalize_smart_punctuation(
-                                tok.text(),
-                                config.formatter_extensions.smart,
-                                config.formatter_extensions.smart_quotes,
-                            )
-                            .as_ref(),
-                        );
-                    }
-                    NodeOrToken::Node(n) => {
-                        skip_marker_whitespace = false;
-                        result.push_str(&n.text().to_string());
-                    }
-                }
-            }
-            result
-        }
+        SyntaxKind::CITATION | SyntaxKind::CROSSREF => format_citation_like(node, config),
         _ => {
             // For other inline nodes, just return their text
             node.text().to_string()

{panache_cli-2.55.0 → panache_cli-2.56.0}/crates/panache-formatter/src/formatter/math/STYLE.md

@@ -101,14 +101,16 @@ Returned unchanged, never reflowed:
    wider than `line-width` is broken at its **top-level** operators in a
    two-level hierarchy keyed on `operators::break_priority` (**relations** >
    **binary** > everything else). The first relation stays on the opening line;
-   every later relation starts a continuation **aligned under the first
-   relation's column**. Then any relation segment that is still over-width
-   splits before each top-level **binary** operator, with each `+ term` nested
-   one indent step (2 spaces) deeper, under the relation's right-hand side. The
-   width budget charges the flat `math-indent` against `line-width`, so a broken
-   line plus its leading indent still stays within `line-width`. It is
-   source-cosmetic only --- math ignores whitespace, so the rendered equation is
-   unchanged:
+   every later relation starts a continuation aligned under the **first
+   relation** (`linebreak::relation_column`) --- the classic stacked-`=` layout
+   for an equality/comparison chain. Then any relation segment that is still
+   over-width splits before each top-level **binary** operator, with each
+   `+ term` sitting **flush** under that segment's own right-hand side. The
+   relation/RHS offset alone supplies the visual nesting; binary continuations
+   never pick up an extra step. The width budget charges the flat `math-indent`
+   against `line-width`, so a broken line plus its leading indent still stays
+   within `line-width`. It is source-cosmetic only --- math ignores whitespace,
+   so the rendered equation is unchanged:
 
    ```
    A = aaaaaaaaaa
@@ -120,6 +122,26 @@ Returned unchanged, never reflowed:
    (At a width where each relation segment fits, no binary breaking happens and
    only the relation split shows: `A = aaaa + bbbb` / `= cccc + dddd`.)
 
+   **Assignment exception.** When the leading relation is an *assignment* arrow
+   (`\gets`, `\leftarrow`, `\mapsto`, `\coloneqq`, or `:=`), the arrow defines
+   its LHS rather than equating it, so it is **not** part of the equality chain
+   it introduces. The equality continuations then anchor under the assignment's
+   *right-hand side* (`linebreak::rhs_start_column`) instead of under the arrow,
+   so a wide arrow (`\gets` is 5 cols) does not drag them left. The selector is
+   `linebreak::continuation_anchor` / `first_relation_is_assignment`. `\to` and
+   `\rightarrow` are intentionally *not* assignments (they are usually limits or
+   mappings).
+
+   ```
+   \beta_0 \gets \beta_0 + \frac{4}{n} …
+                 = \beta_0 - \frac{1}{L_0} …
+                 = 1/4
+   ```
+
+   This is **fully deterministic**: the layout is a pure function of the
+   content, `line-width`, and `math-indent` --- the author's own line breaks and
+   indentation are never preserved, only recomputed.
+
    - **Top-level only.** An operator at delimiter depth > 0 --- inside `(…)`,
      `[…]`, or `\left…\right` (tracked by an open/close counter, since those are
      *flat token runs*, not nesting nodes), or anywhere inside a `{…}` brace
@@ -138,16 +160,29 @@ Returned unchanged, never reflowed:
      (Contrast environment-body rows, which keep soft-newline boundaries.) The
      exception: a soft newline terminating a `%` comment stays a boundary, or
      the next line is absorbed into the comment.
+   - **`\\` relation chains align like an implicit `aligned`.** A genuine hard
+     `\\` *does* split logical rows. When ≥ 2 such `\\`-joined rows form a
+     relation chain --- the head ends in `\\` and every following row
+     `begins_with_top_level_relation` (a continuation like `= b`) --- the
+     continuations hang at the head's `continuation_anchor` (under the first
+     relation, or the assignment's RHS), exactly as the within-row relation
+     breaks do, so a `\\`-broken chain in bare `$$` reads like an `aligned` even
+     without one (`relation_chain_alignment`). This fires regardless of width
+     (the `\\` are forced breaks). A group containing a top-level `&` is left to
+     the existing free-row path (a bare `&` is not a column separator), and `\\`
+     rows that are not a relation chain stay flush at the bare `math-indent`.
    - **Scope:** every over-width free row with a top-level relation **or**
      binary operator is broken. A **relation chain** (≥ 2 relations) splits at
      its relations, then nests binary terms inside each over-width segment (as
      above). A **single-relation** row splits its over-width binary RHS, each
-     `+ term` nested under the right-hand side. A **standalone binary chain**
-     (no relation) splits with the first term as the head and each `+ term`
-     flush under it. The unifying rule: a binary continuation aligns under the
+     `+ term` flush under the right-hand side. A **standalone binary chain** (no
+     relation) splits with the first term as the head and each `+ term` flush
+     under it. The unifying rule: a binary continuation aligns flush under the
      **first term of its operand sequence** (for a relation segment that is its
-     RHS; for a bare chain it is the chain itself, so the `+` sits flush). A row
-     with **no** top-level relation or binary operator (e.g. a single wide
+     RHS; for a bare chain it is the chain itself). The relation/RHS offset is
+     the only nesting; `math-indent` shifts the whole block but never the
+     internal alignment, so the equation's shape is identical at any indent. A
+     row with **no** top-level relation or binary operator (e.g. a single wide
      `\frac{…}{…}`) is left on one over-width line --- like an unbreakable long
      word in prose reflow. Inline and environment-body math are not line-broken.