feat: accept ParseOutput in DocPrinter

Author: crowlKats

examples/ddoc/main.rs

@@ -223,15 +223,7 @@ async fn run() -> anyhow::Result<()> {
         serde_json::to_writer_pretty(std::io::stdout(), &doc_nodes_by_url)?;
         println!();
       } else {
-        let mut merged_doc = deno_doc::Document::default();
-        for doc in doc_nodes_by_url.into_values() {
-          if merged_doc.module_doc.is_empty() {
-            merged_doc.module_doc = doc.module_doc;
-          }
-          merged_doc.symbols.extend(doc.symbols);
-        }
-
-        let result = DocPrinter::new(&merged_doc, true, false);
+        let result = DocPrinter::new(&doc_nodes_by_url, true, false);
         println!("{result}");
       }
     }

src/printer.rs

@@ -9,8 +9,8 @@ use crate::js_doc::JsDoc;
 use crate::js_doc::JsDocTag;
 use crate::node::DeclarationDef;
 use crate::node::DeclarationKind;
-use crate::node::Document;
 use crate::node::Symbol;
+use crate::parser::ParseOutput;
 
 use deno_terminal::colors;
 use deno_terminal::colors::Style;
@@ -25,37 +25,44 @@ fn italic_cyan<'a, S: Display + 'a>(s: S) -> Style<Style<S>> {
 }
 
 pub struct DocPrinter<'a> {
-  document: &'a Document,
+  output: &'a ParseOutput,
   use_color: bool,
   private: bool,
 }
 
 impl DocPrinter<'_> {
   pub fn new(
-    document: &Document,
+    output: &ParseOutput,
     use_color: bool,
     private: bool,
   ) -> DocPrinter<'_> {
     DocPrinter {
-      document,
+      output,
       use_color,
       private,
     }
   }
 
   pub fn format(&self, w: &mut Formatter<'_>) -> FmtResult {
     colors::set_use_color(self.use_color);
-    if !self.document.module_doc.is_empty() {
-      if let Some(doc) = &self.document.module_doc.doc {
-        render_markdown(w, doc, 0)?;
+    let multiple = self.output.len() > 1;
+    for (specifier, document) in self.output {
+      if multiple {
+        writeln!(w, "{}\n", colors::bold(specifier.as_str()))?;
       }
-      for tag in &self.document.module_doc.tags {
-        self.format_jsdoc_tag(w, tag, 0)?;
+      if !document.module_doc.is_empty() {
+        if let Some(doc) = &document.module_doc.doc {
+          render_markdown(w, doc, 0)?;
+        }
+        for tag in &document.module_doc.tags {
+          self.format_jsdoc_tag(w, tag, 0)?;
+        }
+        writeln!(w)?;
       }
-      writeln!(w)?;
-    }
 
-    self.format_with_indent(w, &self.document.symbols, 0)
+      self.format_with_indent(w, &document.symbols, 0)?;
+    }
+    Ok(())
   }
 
   fn format_with_indent(

src/tests.rs

@@ -224,18 +224,16 @@ export function fooFn(a: number) {
     ],
   )
   .await;
-  let document = DocParser::new(
+  let output = DocParser::new(
     &graph,
     &analyzer,
     &[specifier],
     DocParserOptions::default(),
   )
   .unwrap()
   .parse()
-  .unwrap()
-  .into_values()
-  .next()
   .unwrap();
+  let document = output.values().next().unwrap();
 
   let expected_symbols = json!([
     {
@@ -338,7 +336,7 @@ export function fooFn(a: number) {
   assert_eq!(actual, expected_imports);
 
   assert!(
-    DocPrinter::new(&document, false, false)
+    DocPrinter::new(&output, false, false)
       .to_string()
       .as_str()
       .contains("function fooFn(a: number)")
@@ -363,19 +361,16 @@ export { Hello } from "./reexport.ts";
     ],
   )
   .await;
-  let entries = DocParser::new(
+  let output = DocParser::new(
     &graph,
     &analyzer,
     &[specifier],
     DocParserOptions::default(),
   )
   .unwrap()
   .parse()
-  .unwrap()
-  .into_values()
-  .next()
-  .unwrap()
-  .symbols;
+  .unwrap();
+  let entries = &output.values().next().unwrap().symbols;
 
   let expected_json = json!([
     {
@@ -406,17 +401,12 @@ export { Hello } from "./reexport.ts";
       ]
     }
   ]);
-  let actual = serde_json::to_value(&entries).unwrap();
+  let actual = serde_json::to_value(entries).unwrap();
   assert_eq!(actual, expected_json);
 
-  let doc = crate::node::Document {
-    module_doc: Default::default(),
-    imports: vec![],
-    symbols: entries,
-  };
-  let output = DocPrinter::new(&doc, false, false).to_string();
-  assert!(output.contains("class Hello"));
-  assert!(output.contains("interface Hello"));
+  let text = DocPrinter::new(&output, false, false).to_string();
+  assert!(text.contains("class Hello"));
+  assert!(text.contains("interface Hello"));
 }
 
 #[tokio::test]
@@ -434,19 +424,16 @@ async fn deep_reexports() {
     ],
   )
   .await;
-  let entries = DocParser::new(
+  let output = DocParser::new(
     &graph,
     &analyzer,
     &[specifier],
     DocParserOptions::default(),
   )
   .unwrap()
   .parse()
-  .unwrap()
-  .into_values()
-  .next()
-  .unwrap()
-  .symbols;
+  .unwrap();
+  let entries = &output.values().next().unwrap().symbols;
 
   let expected_json = json!([
     {
@@ -471,16 +458,11 @@ async fn deep_reexports() {
       }]
     }
   ]);
-  let actual = serde_json::to_value(&entries).unwrap();
+  let actual = serde_json::to_value(entries).unwrap();
   assert_eq!(actual, expected_json);
 
-  let doc = crate::node::Document {
-    module_doc: Default::default(),
-    imports: vec![],
-    symbols: entries,
-  };
   assert!(
-    DocPrinter::new(&doc, false, false)
+    DocPrinter::new(&output, false, false)
       .to_string()
       .contains("const foo")
   );

tests/helpers/mod.rs

@@ -77,14 +77,15 @@ impl TestBuilder {
     )
     .unwrap();
 
-    let document = parser.parse().unwrap().into_values().next().unwrap();
+    let output = parser.parse().unwrap();
+    let document = output.values().next().unwrap();
 
-    let doc = DocPrinter::new(&document, false, self.private).to_string();
+    let doc = DocPrinter::new(&output, false, self.private).to_string();
     let diagnostics = parser.take_diagnostics();
 
     BuildResult {
       diagnostics,
-      json_output: serde_json::to_value(&document).unwrap(),
+      json_output: serde_json::to_value(document).unwrap(),
       text_output: doc,
     }
   }