panache 2.41.0

An LSP, formatter, and linter for Markdown, Quarto, and R Markdown
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use panache::format;

#[test]
fn inline_code_with_class() {
    let input = "Text with `code`{.python} inline.\n";
    let output = format(input, None, None);
    assert!(output.contains("`code`{.python}"));
}

#[test]
fn inline_code_with_id() {
    let input = "See `result`{#main-result} for details.\n";
    let output = format(input, None, None);
    assert!(output.contains("`result`{#main-result}"));
}

#[test]
fn inline_code_with_multiple_classes() {
    let input = "Run `script`{.python .eval .hide}.\n";
    let output = format(input, None, None);
    assert!(output.contains("`script`{.python .eval .hide}"));
}

#[test]
fn inline_code_with_full_attributes() {
    let input = "Use `func()`{#fn .haskell key=val}.\n";
    let output = format(input, None, None);
    assert!(output.contains("`func()`{#fn .haskell key=\"val\"}"));
}

#[test]
fn inline_code_without_attributes() {
    let input = "Plain `code` works.\n";
    let output = format(input, None, None);
    assert!(output.contains("`code`"));
    assert!(!output.contains("{"));
}

#[test]
fn multiple_inline_code_with_attributes() {
    let input = "Call `foo()`{.py} then `bar()`{.r}.\n";
    let output = format(input, None, None);
    assert!(output.contains("`foo()`{.py}"));
    assert!(output.contains("`bar()`{.r}"));
}

#[test]
fn double_backtick_with_attributes() {
    let input = "Code: ``has `backtick` inside``{.lang}.\n";
    let output = format(input, None, None);
    assert!(output.contains("``has `backtick` inside``{.lang}"));
}

#[test]
fn inline_code_attributes_in_wrapping_paragraph() {
    let cfg = panache::ConfigBuilder::default().line_width(40).build();
    let input =
        "This is a long paragraph with `code`{.python} that should wrap at the configured width.\n";
    let output = format(input, Some(cfg), None);
    // Should preserve inline code with attributes even when wrapping
    assert!(output.contains("`code`{.python}"));
}

#[test]
fn inline_code_space_before_attributes() {
    // Space between backticks and { should not parse as attributes
    let input = "Code: `test` {.python}.\n";
    let output = format(input, None, None);
    assert!(output.contains("`test`"));
    // The {.python} should be treated as regular text
    assert!(output.contains("{.python}"));
}

#[test]
fn inline_code_mixed_with_emphasis() {
    let input = "This *emphasized* and `code`{.lang} text.\n";
    let output = format(input, None, None);
    assert!(output.contains("*emphasized*"));
    assert!(output.contains("`code`{.lang}"));
}

#[test]
fn idempotent_formatting() {
    let input = "Text with `code`{#id .class key=value} inline.\n";
    let first = format(input, None, None);
    let second = format(&first, None, None);
    assert_eq!(first, second);
}

#[test]
fn inline_code_attributes_quoted_values() {
    let input = "Use `func()`{key=\"value with spaces\"}.\n";
    let output = format(input, None, None);
    assert!(output.contains("`func()`{key=\"value with spaces\"}"));
}

#[test]
fn multiline_triple_backtick_codespan_stays_idempotent() {
    let input = "Add thin space between single and double quotes.\n```\n% pandoc -t latex+smart\n---\nlang: en-GB\n---\n'[\"On the Outside\"]{}: Constructing Cycling Citizenship.'\n^D\n`\\,{``On the Outside''}: Constructing Cycling Citizenship.'\n```\n";
    let first = format(input, None, None);
    let second = format(&first, None, None);
    assert_eq!(first, second);
}

#[test]
fn backticks_inside_codespan_stays_idempotent() {
    let input = "`` hi````there ``\n";
    let first = format(input, None, None);
    let second = format(&first, None, None);
    assert_eq!(first, second);
}

#[test]
fn whitespace_only_codespan_stays_idempotent() {
    let input = "Hard line breaks, which are created either by ending a line with two or more spaces (`  `) or by using a backslash (`\\\\n`), are preserved regardless of the wrapping mode:\n";
    let first = format(input, None, None);
    let second = format(&first, None, None);
    assert_eq!(first, second);
    assert!(first.contains("spaces (``  ``)"));
}

#[test]
fn nested_backtick_rmarkdown_paragraph_stays_idempotent() {
    let cfg = panache::ConfigBuilder::default().line_width(72).build();
    let input = "There are two types of R code in R Markdown/**knitr** documents: R code chunks\\index{code chunk}, and inline R code\\index{inline R code}. The syntax for the latter is `` ``r ''`r R_CODE` ``, and it can be embedded inline with other document elements. R code chunks look like plain code blocks, but have `{r}` after the three backticks and (optionally) chunk options inside `{}`, e.g.,\n";
    let first = format(input, Some(cfg.clone()), None);
    let second = format(&first, Some(cfg), None);
    assert_eq!(first, second);
}