Merge pull request madonoharu#4 from sisou/sisou/comments

Copy rustdoc comments over to TS output
carlsverre · Jan 13, 2024 · 8d83bbb · 8d83bbb
2 parents 605aa84 + e36e55b
commit 8d83bbb
Show file tree

Hide file tree

Showing 16 changed files with 848 additions and 27 deletions.
diff --git a/tests/enum.rs b/tests/enum.rs
diff --git a/tests/flatten.rs b/tests/flatten.rs
@@ -6,23 +6,35 @@ use tsify::Tsify;
 
 #[test]
 fn test_flatten() {
+    /// Comment for A
     #[derive(Tsify)]
     struct A {
+        /// Comment for a
         a: i32,
+        /// Comment for b
         b: String,
     }
 
+    /// Comment for B
     #[derive(Tsify)]
     struct B {
+        /// Comment for extra
         #[serde(flatten)]
         extra: A,
+        /// Comment for c
         c: i32,
     }
 
     assert_eq!(
         B::DECL,
         indoc! {"
+            /**
+             * Comment for B
+             */
             export interface B extends A {
+                /**
+                 * Comment for c
+                 */
                 c: number;
             }"
         }
@@ -31,22 +43,31 @@ fn test_flatten() {
 
 #[test]
 fn test_flatten_option() {
+    /// Comment for A
     #[derive(Tsify)]
     struct A {
+        /// Comment for a
         a: i32,
+        /// Comment for b
         b: String,
     }
 
+    /// Comment for B
     #[derive(Tsify)]
     struct B {
+        /// Comment for extra
         #[serde(flatten)]
         extra: Option<A>,
+        /// Comment for c
         c: i32,
     }
 
     assert_eq!(
         B::DECL,
         indoc! {"
+            /**
+             * Comment for B
+             */
             export type B = { c: number } & (A | {});"
         }
     );

diff --git a/tests/generics.rs b/tests/generics.rs
@@ -6,45 +6,75 @@ use tsify::Tsify;
 
 #[test]
 fn test_generic_struct() {
+    /// Comment for GenericStruct
     #[derive(Tsify)]
     pub struct GenericStruct<'a, A, B, C, D> {
+        /// Comment for a
         a: A,
+        /// Comment for b
         b: B,
+        /// Comment for c
         #[serde(skip)]
         c: &'a C,
+        /// Comment for d
         d: D,
     }
 
     assert_eq!(
         GenericStruct::<(), (), (), ()>::DECL,
         indoc! {"
+            /**
+             * Comment for GenericStruct
+             */
             export interface GenericStruct<A, B, D> {
+                /**
+                 * Comment for a
+                 */
                 a: A;
+                /**
+                 * Comment for b
+                 */
                 b: B;
+                /**
+                 * Comment for d
+                 */
                 d: D;
             }"
         }
     );
 
+    /// Comment for GenericNewtype
     #[derive(Tsify)]
     pub struct GenericNewtype<T>(T);
 
     assert_eq!(
         GenericNewtype::<()>::DECL,
-        "export type GenericNewtype<T> = T;"
+        indoc! {"
+            /**
+             * Comment for GenericNewtype
+             */
+            export type GenericNewtype<T> = T;"
+        },
     );
 
+    /// Comment for GenericTuple
     #[derive(Tsify)]
     pub struct GenericTuple<'a, A, B, C, D>(A, #[serde(skip)] &'a B, C, D);
 
     assert_eq!(
         GenericTuple::<(), (), (), ()>::DECL,
-        "export type GenericTuple<A, C, D> = [A, C, D];"
+        indoc! {"
+            /**
+             * Comment for GenericTuple
+             */
+            export type GenericTuple<A, C, D> = [A, C, D];"
+        ,}
     );
 }
 
 #[test]
 fn test_generic_enum() {
+    /// Comment for GenericEnum
     #[derive(Tsify)]
     pub enum GenericEnum<T, U> {
         Unit,
@@ -54,6 +84,9 @@ fn test_generic_enum() {
     }
 
     let expected = indoc! {r#"
+        /**
+         * Comment for GenericEnum
+         */
         export type GenericEnum<T, U> = "Unit" | { NewType: T } | { Seq: [T, U] } | { Map: { x: T; y: U } };"#
     };
 
@@ -62,23 +95,46 @@ fn test_generic_enum() {
 
 #[test]
 fn test_generic_enum_with_namespace() {
+    /// Comment for GenericEnum
     #[derive(Tsify)]
     #[tsify(namespace)]
     pub enum GenericEnum<T, U> {
+        /// Comment for Unit
         Unit,
+        /// Comment for NewType
         NewType(T),
+        /// Comment for Seq
         Seq(T, U),
+        /// Comment for Map
         Map { x: T, y: U },
     }
 
     let expected = indoc! {r#"
+        /**
+         * Comment for GenericEnum
+         */
         declare namespace GenericEnum {
+            /**
+             * Comment for Unit
+             */
             export type Unit = "Unit";
+            /**
+             * Comment for NewType
+             */
             export type NewType<T> = { NewType: T };
+            /**
+             * Comment for Seq
+             */
             export type Seq<T, U> = { Seq: [T, U] };
+            /**
+             * Comment for Map
+             */
             export type Map<T, U> = { Map: { x: T; y: U } };
         }
-        
+
+        /**
+         * Comment for GenericEnum
+         */
         export type GenericEnum<T, U> = "Unit" | { NewType: T } | { Seq: [T, U] } | { Map: { x: T; y: U } };"#
     };
 

diff --git a/tests/optional.rs b/tests/optional.rs
@@ -6,44 +6,80 @@ use tsify::Tsify;
 
 #[test]
 fn test_optional() {
+    /// Comment for Optional
     #[derive(Tsify)]
     struct Optional {
+        /// Comment for a
         #[tsify(optional)]
         a: Option<i32>,
+        /// Comment for b
         #[serde(skip_serializing_if = "Option::is_none")]
         b: Option<String>,
+        /// Comment for c
         #[serde(default)]
         c: i32,
+        /// Comment for d
         #[serde(default)]
         d: Option<String>,
     }
 
+    /// Comment for OptionalAll
     #[derive(Tsify)]
     #[serde(default)]
     struct OptionalAll {
+        /// Comment for a
         a: i32,
+        /// Comment for b
         b: i32,
+        /// Comment for c
         c: Option<i32>,
     }
 
     if cfg!(feature = "js") {
         assert_eq!(
             Optional::DECL,
             indoc! {"
+            /**
+             * Comment for Optional
+             */
             export interface Optional {
+                /**
+                 * Comment for a
+                 */
                 a?: number;
+                /**
+                 * Comment for b
+                 */
                 b?: string;
+                /**
+                 * Comment for c
+                 */
                 c?: number;
+                /**
+                 * Comment for d
+                 */
                 d?: string | undefined;
             }"
             }
         );
         assert_eq!(
             OptionalAll::DECL,
             indoc! {"
+                /**
+                 * Comment for OptionalAll
+                 */
                 export interface OptionalAll {
+                    /**
+                     * Comment for a
+                     */
                     a?: number;
+                    /**
+                     * Comment for b
+                     */
                     b?: number;
+                    /**
+                     * Comment for c
+                     */
                     c?: number | undefined;
                 }"
             }
@@ -52,20 +88,47 @@ fn test_optional() {
         assert_eq!(
             Optional::DECL,
             indoc! {"
+                /**
+                 * Comment for Optional
+                 */
                 export interface Optional {
+                    /**
+                     * Comment for a
+                     */
                     a?: number;
+                    /**
+                     * Comment for b
+                     */
                     b?: string;
+                    /**
+                     * Comment for c
+                     */
                     c?: number;
+                    /**
+                     * Comment for d
+                     */
                     d?: string | null;
                 }"
             }
         );
         assert_eq!(
             OptionalAll::DECL,
             indoc! {"
+                /**
+                 * Comment for OptionalAll
+                 */
                 export interface OptionalAll {
+                    /**
+                     * Comment for a
+                     */
                     a?: number;
+                    /**
+                     * Comment for b
+                     */
                     b?: number;
+                    /**
+                     * Comment for c
+                     */
                     c?: number | null;
                 }"
             }