{}` blocks to convert "hidden" lines and to wrap them in
/// a ``.
fn hide_lines(html: &str, code_config: &Code) -> String {
static LANGUAGE_REGEX: Lazy = Lazy::new(|| Regex::new(r"\blanguage-(\w+)\b").unwrap());
static HIDELINES_REGEX: Lazy = Lazy::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: Lazy = Lazy::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 &caps[2] != "!" && &caps[2] != "[" {
result += "";
result += &caps[1];
if &caps[2] != " " {
result += &caps[2];
}
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,
}
#[cfg(test)]
mod tests {
use crate::config::TextDirection;
use super::*;
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}
",),
(
"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"));
}
}