Integrate LocalResources into markdown generation

Author: GuillaumeGomez

src/librustdoc/externalfiles.rs

@@ -47,6 +47,8 @@ impl ExternalHtml {
                 edition,
                 playground,
                 heading_offset: HeadingOffset::H2,
+                depth: 0,
+                local_resources: None,
             }
             .into_string()
         );
@@ -63,6 +65,8 @@ impl ExternalHtml {
                 edition,
                 playground,
                 heading_offset: HeadingOffset::H2,
+                depth: 0,
+                local_resources: None,
             }
             .into_string()
         );

src/librustdoc/formats/cache.rs

@@ -520,7 +520,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
 }
 
 #[derive(Default)]
-pub(crate) struct LocalResources {
+pub struct LocalResources {
     /// The key is the original location of the resource. The value is the new name.
     pub(crate) resources_to_copy: FxHashMap<PathBuf, String>,
     /// This will be used when generating the HTML, once everything is generated, we copy these
@@ -529,20 +529,18 @@ pub(crate) struct LocalResources {
     /// The key is the depth and the value is hashmap where the key is the path of the resource in
     /// the markdown and the value is the new path to the resources in the rustdoc output folder.
     pub(crate) resources_correspondance: FxHashMap<usize, FxHashMap<String, String>>,
-    pub(crate) total_entries: usize,
 }
 
 impl LocalResources {
     pub(crate) fn add_entry_at_depth(&mut self, depth: usize, key: String, value: String) {
-        if self
-            .resources_correspondance
+        self.resources_correspondance
             .entry(depth)
             .or_insert_with(FxHashMap::default)
-            .insert(key, value)
-            .is_none()
-        {
-            self.total_entries += 1;
-        }
+            .insert(key, value);
+    }
+
+    pub(crate) fn get_at_depth(&self, depth: usize, key: &str) -> Option<&String> {
+        self.resources_correspondance.get(&depth).and_then(|e| e.get(key))
     }
 }
 

src/librustdoc/html/markdown.rs

@@ -42,6 +42,7 @@ use std::str;
 
 use crate::clean::RenderedLink;
 use crate::doctest;
+use crate::formats::cache::LocalResources;
 use crate::html::escape::Escape;
 use crate::html::format::Buffer;
 use crate::html::highlight;
@@ -101,6 +102,8 @@ pub struct Markdown<'a> {
     /// Offset at which we render headings.
     /// E.g. if `heading_offset: HeadingOffset::H2`, then `# something` renders an `<h2>`.
     pub heading_offset: HeadingOffset,
+    pub depth: usize,
+    pub local_resources: Option<&'a LocalResources>,
 }
 /// A tuple struct like `Markdown` that renders the markdown with a table of contents.
 pub(crate) struct MarkdownWithToc<'a> {
@@ -109,13 +112,50 @@ pub(crate) struct MarkdownWithToc<'a> {
     pub(crate) error_codes: ErrorCodes,
     pub(crate) edition: Edition,
     pub(crate) playground: &'a Option<Playground>,
+    pub(crate) depth: usize,
+    pub(crate) local_resources: Option<&'a LocalResources>,
 }
 /// A tuple struct like `Markdown` that renders the markdown escaping HTML tags
 /// and includes no paragraph tags.
 pub(crate) struct MarkdownItemInfo<'a>(pub(crate) &'a str, pub(crate) &'a mut IdMap);
 /// A tuple struct like `Markdown` that renders only the first paragraph.
 pub(crate) struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [RenderedLink]);
 
+struct LocalResourcesReplacer<'b, I> {
+    inner: I,
+    local_resources: Option<&'b LocalResources>,
+    depth: usize,
+}
+
+impl<'b, I> LocalResourcesReplacer<'b, I> {
+    fn new(iter: I, local_resources: Option<&'b LocalResources>, depth: usize) -> Self {
+        Self { inner: iter, local_resources, depth }
+    }
+}
+
+impl<'a, 'b, I: Iterator<Item = Event<'a>>> Iterator for LocalResourcesReplacer<'b, I> {
+    type Item = Event<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let event = self.inner.next()?;
+        // We only modify
+        if let Event::Start(Tag::Image(type_, ref path, ref title)) = event &&
+            !path.starts_with("http://") &&
+            !path.starts_with("https://") &&
+            let Some(local_resources) = &self.local_resources &&
+            let Some(correspondance) = local_resources.get_at_depth(self.depth, &*path)
+        {
+            Some(Event::Start(Tag::Image(
+                type_,
+                CowStr::Boxed(correspondance.clone().into_boxed_str()),
+                title.clone(),
+            )))
+        } else {
+            Some(event)
+        }
+    }
+}
+
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum ErrorCodes {
     Yes,
@@ -1017,6 +1057,8 @@ impl Markdown<'_> {
             edition,
             playground,
             heading_offset,
+            depth,
+            local_resources,
         } = self;
 
         // This is actually common enough to special-case
@@ -1038,6 +1080,7 @@ impl Markdown<'_> {
         let p = HeadingLinks::new(p, None, ids, heading_offset);
         let p = Footnotes::new(p);
         let p = LinkReplacer::new(p.map(|(ev, _)| ev), links);
+        let p = LocalResourcesReplacer::new(p, local_resources, depth);
         let p = TableWrapper::new(p);
         let p = CodeBlocks::new(p, codes, edition, playground);
         html::push_html(&mut s, p);
@@ -1048,7 +1091,15 @@ impl Markdown<'_> {
 
 impl MarkdownWithToc<'_> {
     pub(crate) fn into_string(self) -> String {
-        let MarkdownWithToc { content: md, ids, error_codes: codes, edition, playground } = self;
+        let MarkdownWithToc {
+            content: md,
+            ids,
+            error_codes: codes,
+            edition,
+            playground,
+            depth,
+            local_resources,
+        } = self;
 
         let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
 
@@ -1059,7 +1110,8 @@ impl MarkdownWithToc<'_> {
         {
             let p = HeadingLinks::new(p, Some(&mut toc), ids, HeadingOffset::H1);
             let p = Footnotes::new(p);
-            let p = TableWrapper::new(p.map(|(ev, _)| ev));
+            let p = LocalResourcesReplacer::new(p.map(|(ev, _)| ev), local_resources, depth);
+            let p = TableWrapper::new(p);
             let p = CodeBlocks::new(p, codes, edition, playground);
             html::push_html(&mut s, p);
         }

src/librustdoc/html/render/context.rs

@@ -719,6 +719,22 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             }
         }
 
+        {
+            // Copying the local resources to the destination folder.
+            let resources = &shared.cache.local_resources.resources_to_copy;
+            if !resources.is_empty() {
+                let dst = self
+                    .dst
+                    .join(crate::html::LOCAL_RESOURCES_FOLDER_NAME)
+                    .join(crate_name.as_str());
+                shared.ensure_dir(&dst)?;
+                for (original_path, dest_name) in resources.iter() {
+                    let dst = dst.join(dest_name);
+                    try_err!(std::fs::copy(original_path, &dst), &dst);
+                }
+            }
+        }
+
         // No need for it anymore.
         drop(shared);
 

src/librustdoc/html/render/mod.rs

@@ -404,7 +404,9 @@ fn scrape_examples_help(shared: &SharedContext<'_>) -> String {
             error_codes: shared.codes,
             edition: shared.edition(),
             playground: &shared.playground,
-            heading_offset: HeadingOffset::H1
+            heading_offset: HeadingOffset::H1,
+            depth: 0,
+            local_resources: None,
         }
         .into_string()
     )
@@ -447,6 +449,8 @@ fn render_markdown(
             edition: cx.shared.edition(),
             playground: &cx.shared.playground,
             heading_offset,
+            depth: cx.current.len(),
+            local_resources: Some(&cx.shared.cache.local_resources),
         }
         .into_string()
     )
@@ -1755,7 +1759,9 @@ fn render_impl(
                     error_codes: cx.shared.codes,
                     edition: cx.shared.edition(),
                     playground: &cx.shared.playground,
-                    heading_offset: HeadingOffset::H4
+                    heading_offset: HeadingOffset::H4,
+                    depth: cx.current.len(),
+                    local_resources: Some(&cx.shared.cache.local_resources),
                 }
                 .into_string()
             );

src/librustdoc/html/render/write_shared.rs

@@ -329,7 +329,7 @@ if (typeof exports !== 'undefined') {exports.searchIndex = searchIndex};
             md_opts.output = cx.dst.clone();
             md_opts.external_html = (*cx.shared).layout.external_html.clone();
 
-            crate::markdown::render(&index_page, md_opts, cx.shared.edition())
+            crate::markdown::render(&index_page, md_opts, cx.shared.edition(), Some(&cx))
                 .map_err(|e| Error::new(e, &index_page))?;
         } else {
             let shared = Rc::clone(&cx.shared);

src/librustdoc/lib.rs

@@ -749,7 +749,7 @@ fn main_args(at_args: &[String]) -> MainResult {
             return wrap_return(
                 &diag,
                 interface::run_compiler(config, |_compiler| {
-                    markdown::render(&input, render_options, edition)
+                    markdown::render(&input, render_options, edition, None)
                 }),
             );
         }

src/librustdoc/markdown.rs

@@ -9,10 +9,10 @@ use rustc_span::source_map::DUMMY_SP;
 use crate::config::{Options, RenderOptions};
 use crate::doctest::{Collector, GlobalTestOptions};
 use crate::html::escape::Escape;
-use crate::html::markdown;
 use crate::html::markdown::{
-    find_testable_code, ErrorCodes, HeadingOffset, IdMap, Markdown, MarkdownWithToc,
+    self, find_testable_code, ErrorCodes, HeadingOffset, IdMap, Markdown, MarkdownWithToc,
 };
+use crate::html::render::Context;
 
 /// Separate any lines at the start of the file that begin with `# ` or `%`.
 fn extract_leading_metadata(s: &str) -> (Vec<&str>, &str) {
@@ -41,6 +41,7 @@ pub(crate) fn render<P: AsRef<Path>>(
     input: P,
     options: RenderOptions,
     edition: Edition,
+    cx: Option<&Context<'_>>,
 ) -> Result<(), String> {
     if let Err(e) = create_dir_all(&options.output) {
         return Err(format!("{}: {}", options.output.display(), e));
@@ -71,13 +72,19 @@ pub(crate) fn render<P: AsRef<Path>>(
 
     let mut ids = IdMap::new();
     let error_codes = ErrorCodes::from(options.unstable_features.is_nightly_build());
+    let (local_resources, depth) = match cx {
+        Some(cx) => (Some(&cx.shared.cache.local_resources), cx.current.len()),
+        None => (None, 0),
+    };
     let text = if !options.markdown_no_toc {
         MarkdownWithToc {
             content: text,
             ids: &mut ids,
             error_codes,
             edition,
             playground: &playground,
+            local_resources,
+            depth,
         }
         .into_string()
     } else {
@@ -89,6 +96,8 @@ pub(crate) fn render<P: AsRef<Path>>(
             edition,
             playground: &playground,
             heading_offset: HeadingOffset::H1,
+            local_resources,
+            depth,
         }
         .into_string()
     };