{}` blocks to convert "hidden" lines and to wrap them in
/// a ``.
fn hide_lines(html: &str, code_config: &Code) -> String {
static LANGUAGE_REGEX: LazyLock =
LazyLock::new(|| Regex::new(r"\blanguage-(\w+)\b").unwrap());
static HIDELINES_REGEX: LazyLock =
LazyLock::new(|| Regex::new(r"\bhidelines=(\S+)").unwrap());
CODE_BLOCK_RE
.replace_all(html, |caps: &Captures<'_>| {
let text = &caps[1];
let classes = &caps[2];
let code = &caps[3];
if classes.contains("language-rust") {
format!(
"{}",
classes,
hide_lines_rust(code)
)
} else {
// First try to get the prefix from the code block
let hidelines_capture = HIDELINES_REGEX.captures(classes);
let hidelines_prefix = match &hidelines_capture {
Some(capture) => Some(&capture[1]),
None => {
// Then look up the prefix by language
LANGUAGE_REGEX.captures(classes).and_then(|capture| {
code_config.hidelines.get(&capture[1]).map(|p| p.as_str())
})
}
};
match hidelines_prefix {
Some(prefix) => format!(
"{}",
classes,
hide_lines_with_prefix(code, prefix)
),
None => text.to_owned(),
}
}
})
.into_owned()
}
fn hide_lines_rust(content: &str) -> String {
static BORING_LINES_REGEX: LazyLock =
LazyLock::new(|| Regex::new(r"^(\s*)#(.?)(.*)$").unwrap());
let mut result = String::with_capacity(content.len());
let mut lines = content.lines().peekable();
while let Some(line) = lines.next() {
// Don't include newline on the last line.
let newline = if lines.peek().is_none() { "" } else { "\n" };
if let Some(caps) = BORING_LINES_REGEX.captures(line) {
if &caps[2] == "#" {
result += &caps[1];
result += &caps[2];
result += &caps[3];
result += newline;
continue;
} else if matches!(&caps[2], "" | " ") {
result += "";
result += &caps[1];
result += &caps[3];
result += newline;
result += "";
continue;
}
}
result += line;
result += newline;
}
result
}
fn hide_lines_with_prefix(content: &str, prefix: &str) -> String {
let mut result = String::with_capacity(content.len());
for line in content.lines() {
if line.trim_start().starts_with(prefix) {
let pos = line.find(prefix).unwrap();
let (ws, rest) = (&line[..pos], &line[pos + prefix.len()..]);
result += "";
result += ws;
result += rest;
result += "\n";
result += "";
continue;
}
result += line;
result += "\n";
}
result
}
fn partition_source(s: &str) -> (String, String) {
let mut after_header = false;
let mut before = String::new();
let mut after = String::new();
for line in s.lines() {
let trimline = line.trim();
let header = trimline.chars().all(char::is_whitespace) || trimline.starts_with("#![");
if !header || after_header {
after_header = true;
after.push_str(line);
after.push('\n');
} else {
before.push_str(line);
before.push('\n');
}
}
(before, after)
}
struct RenderItemContext<'a> {
handlebars: &'a Handlebars<'a>,
destination: PathBuf,
data: serde_json::Map,
is_index: bool,
book_config: BookConfig,
html_config: HtmlConfig,
edition: Option,
chapter_titles: &'a HashMap,
}
/// Redirect mapping.
///
/// The key is the source path (like `foo/bar.html`). The value is a tuple
/// `(destination_path, fragment_map)`. The `destination_path` is the page to
/// redirect to. `fragment_map` is the map of fragments that override the
/// destination. For example, a fragment `#foo` could redirect to any other
/// page or site.
type CombinedRedirects = BTreeMap)>;
fn combine_fragment_redirects(redirects: &HashMap) -> CombinedRedirects {
let mut combined: CombinedRedirects = BTreeMap::new();
// This needs to extract the fragments to generate the fragment map.
for (original, new) in redirects {
if let Some((source_path, source_fragment)) = original.rsplit_once('#') {
let e = combined.entry(source_path.to_string()).or_default();
if let Some(old) = e.1.insert(format!("#{source_fragment}"), new.clone()) {
log::error!(
"internal error: found duplicate fragment redirect \
{old} for {source_path}#{source_fragment}"
);
}
} else {
let e = combined.entry(original.to_string()).or_default();
e.0 = new.clone();
}
}
combined
}
/// Collects fragment redirects for an existing page.
///
/// The returned map has keys like `#foo` and the value is the new destination
/// path or URL.
fn collect_redirects_for_path(
path: &Path,
redirects: &HashMap,
) -> Result> {
let path = format!("/{}", path.display().to_string().replace('\\', "/"));
if redirects.contains_key(&path) {
bail!(
"redirect found for existing chapter at `{path}`\n\
Either delete the redirect or remove the chapter."
);
}
let key_prefix = format!("{path}#");
let map = redirects
.iter()
.filter_map(|(source, dest)| {
source
.strip_prefix(&key_prefix)
.map(|fragment| (format!("#{fragment}"), dest.to_string()))
})
.collect();
Ok(map)
}
#[cfg(test)]
mod tests {
use super::*;
use mdbook_core::config::TextDirection;
use pretty_assertions::assert_eq;
#[test]
fn original_build_header_links() {
let inputs = vec![
(
"blah blah Foo
",
r##"blah blah Foo
"##,
),
(
"Foo
",
r##"Foo
"##,
),
(
"Foo^bar
",
r##"Foo^bar
"##,
),
(
"",
r##"
"##,
),
(
"Hï
",
r##"Hï
"##,
),
(
"Foo
Foo
",
r##"Foo
Foo
"##,
),
// id only
(
r##"Foo
"##,
r##"Foo
"##,
),
// class only
(
r##"Foo
"##,
r##"Foo
"##,
),
// both id and class
(
r##"Foo
"##,
r##"Foo
"##,
),
];
for (src, should_be) in inputs {
let got = build_header_links(src);
assert_eq!(got, should_be);
}
}
#[test]
fn add_playground() {
let inputs = [
(
"x()",
"# #![allow(unused)]\n# fn main() {\nx()\n# }
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"let s = \"foo\n # bar\n\";",
"let s = \"foo\n # bar\n\";
",
),
(
"let s = \"foo\n ## bar\n\";",
"let s = \"foo\n ## bar\n\";
",
),
(
"let s = \"foo\n # bar\n#\n\";",
"let s = \"foo\n # bar\n#\n\";
",
),
(
"let s = \"foo\n # bar\n\";",
"let s = \"foo\n # bar\n\";",
),
(
"#![no_std]\nlet s = \"foo\";\n #[some_attr]",
"#![no_std]\nlet s = \"foo\";\n #[some_attr]
",
),
];
for (src, should_be) in &inputs {
let got = add_playground_pre(
src,
&Playground {
editable: true,
..Playground::default()
},
None,
);
assert_eq!(&*got, *should_be);
}
}
#[test]
fn add_playground_edition2015() {
let inputs = [
(
"x()",
"# #![allow(unused)]\n# fn main() {\nx()\n# }
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"fn main() {}",
"fn main() {}
",
),
];
for (src, should_be) in &inputs {
let got = add_playground_pre(
src,
&Playground {
editable: true,
..Playground::default()
},
Some(RustEdition::E2015),
);
assert_eq!(&*got, *should_be);
}
}
#[test]
fn add_playground_edition2018() {
let inputs = [
(
"x()",
"# #![allow(unused)]\n# fn main() {\nx()\n# }
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"fn main() {}",
"fn main() {}
",
),
];
for (src, should_be) in &inputs {
let got = add_playground_pre(
src,
&Playground {
editable: true,
..Playground::default()
},
Some(RustEdition::E2018),
);
assert_eq!(&*got, *should_be);
}
}
#[test]
fn add_playground_edition2021() {
let inputs = [
(
"x()",
"# #![allow(unused)]\n# fn main() {\nx()\n# }
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"fn main() {}",
"fn main() {}
",
),
(
"fn main() {}",
"fn main() {}
",
),
];
for (src, should_be) in &inputs {
let got = add_playground_pre(
src,
&Playground {
editable: true,
..Playground::default()
},
Some(RustEdition::E2021),
);
assert_eq!(&*got, *should_be);
}
}
#[test]
fn hide_lines_language_rust() {
let inputs = [
(
"\n# #![allow(unused)]\n# fn main() {\nx()\n# }
",
"\n#![allow(unused)]\nfn main() {\nx()\n}
",
),
// # must be followed by a space for a line to be hidden
(
"\n#fn main() {\nx()\n#}
",
"\n#fn main() {\nx()\n#}
",
),
(
"fn main() {}
",
"fn main() {}
",
),
(
"let s = \"foo\n # bar\n\";
",
"let s = \"foo\n bar\n\";
",
),
(
"let s = \"foo\n ## bar\n\";
",
"let s = \"foo\n # bar\n\";
",
),
(
"let s = \"foo\n # bar\n#\n\";
",
"let s = \"foo\n bar\n\n\";
",
),
(
"let s = \"foo\n # bar\n\";",
"let s = \"foo\n bar\n\";",
),
(
"#![no_std]\nlet s = \"foo\";\n #[some_attr]
",
"#![no_std]\nlet s = \"foo\";\n #[some_attr]
",
),
];
for (src, should_be) in &inputs {
let got = hide_lines(src, &Code::default());
assert_eq!(&*got, *should_be);
}
}
#[test]
fn hide_lines_language_other() {
let inputs = [
(
"~hidden()\nnothidden():\n~ hidden()\n ~hidden()\n nothidden()",
"hidden()\nnothidden():\n hidden()\n hidden()\n nothidden()\n",
),
(
"!!!hidden()\nnothidden():\n!!! hidden()\n !!!hidden()\n nothidden()",
"hidden()\nnothidden():\n hidden()\n hidden()\n nothidden()\n",
),
];
for (src, should_be) in &inputs {
let got = hide_lines(
src,
&Code {
hidelines: {
let mut map = HashMap::new();
map.insert("python".to_string(), "~".to_string());
map
},
},
);
assert_eq!(&*got, *should_be);
}
}
#[test]
fn test_json_direction() {
assert_eq!(json!(TextDirection::RightToLeft), json!("rtl"));
assert_eq!(json!(TextDirection::LeftToRight), json!("ltr"));
}
}