rust-lang · jyn514 · Aug 3, 2020 · Aug 2, 2020 · Aug 2, 2020 · Aug 2, 2020
@@ -27,7 +27,6 @@ backtrace = "0.3"
 failure = { version = "0.1.3", features = ["backtrace"] }
 comrak = { version = "0.3", default-features = false }
 toml = "0.5"
-kuchiki = "0.8"
 schemamama = "0.3"
 schemamama_postgres = "0.2"
 systemstat = "0.1.4"
@@ -41,6 +40,7 @@ path-slash = "0.1.3"
 once_cell = { version = "1.4.0", features = ["parking_lot"] }
 base64 = "0.12.1"
 strum = { version = "0.18.0", features = ["derive"] }
+lol_html = "0.2"
 
 # Async
 tokio = { version = "0.2.22", features = ["rt-threaded"] }
@@ -82,6 +82,7 @@ procfs = "0.7"
 
 [dev-dependencies]
 criterion = "0.3"
+kuchiki = "0.8"
 rand = "0.7.3"
 
 [[bench]]

@@ -27,6 +27,9 @@ pub(crate) struct FakeRelease<'a> {
     readme: Option<&'a str>,
 }
 
+const DEFAULT_CONTENT: &[u8] =
+    b"<html><head></head><body>default content for test/fakes</body></html>";
+
 impl<'a> FakeRelease<'a> {
     pub(super) fn new(db: &'a TestDatabase, storage: Arc<Storage>) -> Self {
         FakeRelease {
@@ -121,7 +124,14 @@ impl<'a> FakeRelease<'a> {
         self
     }
 
-    pub(crate) fn rustdoc_file(mut self, path: &'a str, data: &'a [u8]) -> Self {
+    /// Since we switched to LOL HTML, all data must have a valid <head> and <body>.
+    /// To avoid duplicating them in every test, this just makes up some content.
+    pub(crate) fn rustdoc_file(mut self, path: &'a str) -> Self {
+        self.rustdoc_files.push((path, DEFAULT_CONTENT));
+        self
+    }
+
+    pub(crate) fn rustdoc_file_with(mut self, path: &'a str, data: &'a [u8]) -> Self {
         self.rustdoc_files.push((path, data));
         self
     }
@@ -217,7 +227,7 @@ impl<'a> FakeRelease<'a> {
             let index = [&package.name, "index.html"].join("/");
             let mut rustdoc_files = self.rustdoc_files;
             if package.is_library() && !rustdoc_files.iter().any(|(path, _)| path == &index) {
-                rustdoc_files.push((&index, b"default index content"));
+                rustdoc_files.push((&index, DEFAULT_CONTENT));
             }
             for (source_path, data) in &self.source_files {
                 if source_path.starts_with("src/") {

@@ -1,62 +1,67 @@
-use crate::error::Result;
-use failure::err_msg;
-use kuchiki::traits::TendrilSink;
-use kuchiki::NodeRef;
+use crate::web::page::TemplateData;
+use lol_html::errors::RewritingError;
+use tera::Context;
 
-/// Extracts the contents of the `<head>` and `<body>` tags from an HTML document, as well as the
-/// classes on the `<body>` tag, if any.
-pub fn extract_head_and_body(html: &str) -> Result<(String, String, String)> {
-    let dom = kuchiki::parse_html().one(html);
+pub(crate) fn rewrite_lol(
+    html: &str,
+    ctx: Context,
+    templates: &TemplateData,
+) -> Result<String, RewritingError> {
+    use lol_html::html_content::{ContentType, Element};
+    use lol_html::{ElementContentHandlers, RewriteStrSettings};
 
-    let head = dom
-        .select_first("head")
-        .map_err(|_| err_msg("couldn't find <head> tag in rustdoc output"))?;
-    let body = dom
-        .select_first("body")
-        .map_err(|_| err_msg("couldn't find <body> tag in rustdoc output"))?;
+    let templates = templates.templates.load();
+    let tera_head = templates.render("rustdoc/head.html", &ctx).unwrap();
+    let tera_body = templates.render("rustdoc/body.html", &ctx).unwrap();
 
-    let class = body
-        .attributes
-        .borrow()
-        .get("class")
-        .map(|v| v.to_owned())
-        .unwrap_or_default();
+    let head_handler = |head: &mut Element| {
+        head.append(&tera_head, ContentType::Html);
+        Ok(())
+    };
+    // Before: <body> ... rustdoc content ... </body>
+    // After:
+    // ```html
+    // <div id="rustdoc_body_wrapper" class="{{ rustdoc_body_class }}" tabindex="-1">
+    //      ... rustdoc content ...
+    // </div>
+    // ```
+    let body_handler = |rustdoc_body_class: &mut Element| {
+        // Add the `rustdoc` classes to the html body
+        let mut tmp;
+        let klass = if let Some(classes) = rustdoc_body_class.get_attribute("class") {
+            tmp = classes;
+            tmp.push_str(" container-rustdoc");
+            &tmp
+        } else {
+            "container-rustdoc"
+        };
+        rustdoc_body_class.set_attribute("class", klass)?;
+        rustdoc_body_class.set_attribute("id", "rustdoc_body_wrapper")?;
+        rustdoc_body_class.set_attribute("tabindex", "-1")?;
+        // Change the `body` to a `div`
+        rustdoc_body_class.set_tag_name("div")?;
+        // Prepend the tera content
+        rustdoc_body_class.prepend(&tera_body, ContentType::Html);
+        // Now, make this a full <body> tag
+        rustdoc_body_class.before("<body>", ContentType::Html);
+        rustdoc_body_class.after("</body>", ContentType::Html);
 
-    Ok((serialize(head.as_node()), serialize(body.as_node()), class))
-}
-
-fn serialize(v: &NodeRef) -> String {
-    let mut contents = Vec::new();
-    for child in v.children() {
-        child
-            .serialize(&mut contents)
-            .expect("serialization failed");
-    }
-    String::from_utf8(contents).expect("non utf-8 html")
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn small_html() {
-        let (head, body, class) = super::extract_head_and_body(
-            r#"<head><meta name="generator" content="rustdoc"></head><body class="rustdoc struct"><p>hello</p>"#
-        ).unwrap();
-        assert_eq!(head, r#"<meta content="rustdoc" name="generator">"#);
-        assert_eq!(body, "<p>hello</p>");
-        assert_eq!(class, "rustdoc struct");
-    }
+        Ok(())
+    };
 
-    // more of an integration test
-    #[test]
-    fn parse_regex_html() {
-        let original = std::fs::read_to_string("benches/struct.CaptureMatches.html").unwrap();
-        let expected_head = std::fs::read_to_string("tests/regex/head.html").unwrap();
-        let expected_body = std::fs::read_to_string("tests/regex/body.html").unwrap();
-        let (head, body, class) = super::extract_head_and_body(&original).unwrap();
+    let (head_selector, body_selector) = ("head".parse().unwrap(), "body".parse().unwrap());
+    let head = (
+        &head_selector,
+        ElementContentHandlers::default().element(head_handler),
+    );
+    let body = (
+        &body_selector,
+        ElementContentHandlers::default().element(body_handler),
+    );
+    let settings = RewriteStrSettings {
+        element_content_handlers: vec![head, body],
+        ..RewriteStrSettings::default()
+    };
 
-        assert_eq!(head, expected_head.trim());
-        assert_eq!(&body, &expected_body.trim());
-        assert_eq!(class, "rustdoc struct");
-    }
+    lol_html::rewrite_str(html, settings)
 }