better-js-doc

src/lang/js_doc.rs

@@ -1,3 +1,5 @@
+use std::borrow::Borrow;
+
 use crate::*;
 
 pub use super::ts::*;
@@ -32,13 +34,92 @@ fn format_comment_inner(
 
     let inline_ts = datatype_inner(ctx.clone(), &typ.inner, type_map)?;
 
-    Ok(comments::js_doc_internal(
+    let mut builder = ts::comments::js_doc_builder(CommentFormatterArgs {
         docs,
-        deprecated.as_ref(),
-        item.generics()
-            .into_iter()
-            .flatten()
-            .map(|generic| format!("@template {}", generic))
-            .chain([format!(r#"@typedef {{ {inline_ts} }} {name}"#).into()]),
-    ))
+        deprecated: deprecated.as_ref(),
+    });
+
+    item.generics()
+        .into_iter()
+        .flatten()
+        .for_each(|generic| builder.push_generic(generic));
+
+    builder.push_internal(["@typedef { ", &inline_ts, " } ", &name]);
+
+    Ok(builder.build())
+}
+
+const START: &str = "/**\n";
+
+pub struct Builder {
+    value: String,
+}
+
+impl Builder {
+    pub fn push(&mut self, line: &str) {
+        self.push_internal([line.trim()]);
+    }
+
+    pub(crate) fn push_internal<'a>(&mut self, parts: impl IntoIterator<Item = &'a str>) {
+        self.value.push_str(" * ");
+
+        for part in parts.into_iter() {
+            self.value.push_str(part);
+        }
+
+        self.value.push_str("\n");
+    }
+
+    pub fn push_deprecated(&mut self, typ: &DeprecatedType) {
+        self.push_internal(
+            ["@deprecated"].into_iter().chain(
+                match typ {
+                    DeprecatedType::DeprecatedWithSince {
+                        note: message,
+                        since,
+                    } => Some((since.as_ref(), message)),
+                    _ => None,
+                }
+                .map(|(since, message)| {
+                    [" ", message.trim()].into_iter().chain(
+                        since
+                            .map(|since| [" since ", since.trim()])
+                            .into_iter()
+                            .flatten(),
+                    )
+                })
+                .into_iter()
+                .flatten(),
+            ),
+        );
+    }
+
+    pub fn push_generic(&mut self, generic: &GenericType) {
+        self.push_internal(["@template ", generic.borrow()])
+    }
+
+    pub fn build(mut self) -> String {
+        if self.value == START {
+            return String::new();
+        }
+
+        self.value.push_str(" */\n");
+        self.value
+    }
+}
+
+impl Default for Builder {
+    fn default() -> Self {
+        Self {
+            value: START.to_string(),
+        }
+    }
+}
+
+impl<T: AsRef<str>> Extend<T> for Builder {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        for item in iter {
+            self.push(item.as_ref());
+        }
+    }
 }

src/lang/ts/comments.rs

@@ -1,6 +1,4 @@
-use std::{borrow::Cow, iter};
-
-use crate::DeprecatedType;
+use crate::js_doc;
 
 use super::{CommentFormatterArgs, CommentFormatterFn};
 
@@ -9,47 +7,19 @@ const _: CommentFormatterFn = js_doc;
 
 /// Converts Typescript comments into JSDoc comments.
 pub fn js_doc(arg: CommentFormatterArgs) -> String {
-    js_doc_internal(arg.docs, arg.deprecated, iter::empty())
+    js_doc_builder(arg).build()
 }
 
-pub(crate) fn js_doc_internal(
-    docs: &Cow<'static, str>,
-    deprecated: Option<&DeprecatedType>,
-    extra_lines: impl Iterator<Item = String>,
-) -> String {
-    if docs.is_empty() && deprecated.is_none() {
-        return "".into();
-    }
+pub(crate) fn js_doc_builder(arg: CommentFormatterArgs) -> js_doc::Builder {
+    let mut builder = js_doc::Builder::default();
 
-    let mut comment = String::with_capacity(docs.len());
-    comment.push_str("/**\n");
-    if !docs.is_empty() {
-        for line in docs.split('\n') {
-            comment.push_str(" * ");
-            comment.push_str(line.trim());
-            comment.push('\n');
-        }
+    if !arg.docs.is_empty() {
+        builder.extend(arg.docs.split('\n'));
     }
 
-    if let Some(deprecated) = deprecated {
-        comment.push_str(" * @deprecated");
-        if let DeprecatedType::DeprecatedWithSince {
-            since,
-            note: message,
-        } = deprecated
-        {
-            comment.push_str(" ");
-            comment.push_str(message);
-            if let Some(since) = since {
-                comment.push_str(" since ");
-                comment.push_str(since);
-            }
-        }
-        comment.push('\n');
+    if let Some(deprecated) = arg.deprecated {
+        builder.push_deprecated(&deprecated);
     }
 
-    comment.extend(extra_lines);
-    comment.push_str(" */\n");
-
-    comment
+    builder
 }