adding recursive copy functionality

Author: EtomicBomb

src/librustdoc/config.rs

@@ -296,6 +296,8 @@ pub(crate) struct RenderOptions {
     pub(crate) read_rendered_cci: bool,
     /// If `true` (default) write the shared cross-crate information to the doc root
     pub(crate) write_rendered_cci: bool,
+    /// Copies these folders into our doc root.
+    pub(crate) include_rendered_docs: Vec<PathToDocSubdirectory>,
     /// The location of the doc directory for externally located crates.
     /// Absolute path ending in doc/.
     pub(crate) parts_paths: Vec<PathToParts>,
@@ -505,7 +507,10 @@ impl Options {
             Err(err) => dcx.fatal(err),
         };
 
-        let parts_paths = matches.opt_strs("include-info-json").iter()
+        let include_rendered_docs = matches.opt_strs("include-rendered-docs").into_iter()
+            .map(|p| PathToDocSubdirectory(PathBuf::from(p)))
+            .collect();
+        let parts_paths = matches.opt_strs("include-info-json").into_iter()
             .map(|path| PathToParts(PathBuf::from(path)))
             .collect();
 
@@ -842,6 +847,7 @@ impl Options {
             read_rendered_cci,
             write_rendered_cci,
             parts_paths,
+            include_rendered_docs,
             parts_out_dir,
         };
         Some((options, render_options))
@@ -921,6 +927,10 @@ fn parse_extern_html_roots(
     Ok(externs)
 }
 
+/// Path to the doc subdirectory for a specific crate, for example `target/doc/serde_json`.
+#[derive(Clone, Debug)]
+pub(crate) struct PathToDocSubdirectory(pub PathBuf);
+
 /// Path to cci root, including doc.parts, but not the crate name
 ///
 /// For example, `/home/user/project/target/doc.parts/<crate>/crate-info.json`.

src/librustdoc/html/render/context.rs

@@ -14,6 +14,7 @@ use rustc_span::{sym, FileName, Symbol};
 
 use super::print_item::{full_path, item_path, print_item};
 use super::write_shared::{write_shared};
+use super::copy_dir::{copy_dir_all};
 use super::{
     collect_spans_and_sources, scrape_examples_help,
     sidebar::print_sidebar,
@@ -470,6 +471,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             call_locations,
             no_emit_shared,
             html_no_source,
+            include_rendered_docs,
             ..
         } = options;
 
@@ -573,6 +575,10 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             is_inside_inlined_module: false,
         };
 
+        for extern_docs in include_rendered_docs.iter() {
+            try_err!(copy_dir_all(&extern_docs.0, &cx.dst), &extern_docs.0);
+        }
+
         if emit_crate {
             sources::render(&mut cx, &krate)?;
         }

src/librustdoc/html/render/copy_dir.rs

@@ -0,0 +1,68 @@
+use std::io::{Error, Result, ErrorKind};
+use std::path::{PathBuf};
+use std::fs;
+
+/// Recursively copies the contents of the directory `src` to the directory `dst`.
+/// Analogous to `cp -rf src/* dst`.
+pub(crate) fn copy_dir_all<S: Into<PathBuf>, D: Into<PathBuf>>(src: S, dst: D) -> Result<()> {
+    copy_dir_mono(src.into(), dst.into())
+}
+
+/// Monomorphized version of `copy_dir`
+fn copy_dir_mono(src: PathBuf, dst: PathBuf) -> Result<()> {
+    let mut dirs: Vec<(PathBuf, PathBuf)> = Vec::default();
+
+    if !src.is_dir() {
+        return Err(Error::new(ErrorKind::Other, format!("src path `{src:?}` should be a directory")));
+    }
+    if !dst.is_dir() {
+        return Err(Error::new(ErrorKind::Other, format!("dst path `{dst:?}` should be a directory")));
+    }
+
+    dirs.push((src, dst));
+
+    while let Some((src, dst)) = dirs.pop() {
+        match fs::create_dir(&dst) {
+            Ok(()) => {},
+            Err(e) if e.kind() == ErrorKind::AlreadyExists => {},
+            Err(e) => return Err(e),
+        }
+
+        for entry in src.read_dir()? {
+            let entry = entry?;
+            let file_type = entry.file_type()?;
+            let src_filename = dbg!(entry.file_name());
+            let src = src.join(&src_filename);
+            let dst = dst.join(&src_filename);
+            if file_type.is_dir() {
+                dirs.push((src, dst));
+            } else {
+                fs::copy(&src, &dst)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::copy_dir_all;
+    use tempfile::TempDir;
+//     use std::fs::{write, read_to_string};
+    use std::io::{Result};
+
+    #[test]
+    fn empty_dir() -> Result<()> {
+        let src = TempDir::new()?;
+        let dst = TempDir::new()?;
+        let src = src.path();
+        let dst = dst.path();
+        copy_dir_all(src, dst)?;
+        let mut dst = dst.read_dir()?;
+        assert!(dst.next().is_none(), "we copied nothing into the destination");
+        Ok(())
+    }
+
+
+}

src/librustdoc/html/render/mod.rs

@@ -28,6 +28,7 @@ pub(crate) mod search_index;
 #[cfg(test)]
 mod tests;
 
+mod copy_dir;
 mod context;
 mod print_item;
 mod sidebar;

src/librustdoc/lib.rs

@@ -630,6 +630,15 @@ fn opts() -> Vec<RustcOptGroup> {
                 "PATH",
             )
         }),
+        unstable("include-rendered-docs", |o| {
+            o.optopt(
+                "",
+                "include-rendered-docs",
+                "Copies docs from an external crate to the --out-dir. Expects PATH to be a path directly
+                to the external crate's subdirectory in its doc root.",
+                "PATH",
+            )
+        }),
         // deprecated / removed options
         unstable("disable-minification", |o| o.optflagmulti("", "disable-minification", "removed")),
         stable("plugin-path", |o| {