support sublists & sentences splitted into multiple lines

benches/transforming-benchmark.rs

@@ -1,18 +1,13 @@
-use doxygen_rs::{transform};
-use criterion::{
-    criterion_group,
-    criterion_main,
-    Criterion,
-};
+use criterion::{criterion_group, criterion_main, Criterion};
+use doxygen_rs::transform;
 
 const CTRU_SYS_BINDINGS: &str = include_str!("../assets/tests/ctru-sys-bindings.rs");
 
 fn transform_bindgen_benchmark(c: &mut Criterion) {
-    c.bench_function(
-        "bindgen transform",
-        |b| b.iter(|| transform(CTRU_SYS_BINDINGS))
-    );
+    c.bench_function("bindgen transform", |b| {
+        b.iter(|| transform(CTRU_SYS_BINDINGS))
+    });
 }
 
 criterion_group!(benches, transform_bindgen_benchmark);
-criterion_main!(benches);
+criterion_main!(benches);

src/generator/mod.rs

@@ -33,42 +33,47 @@ pub fn generate_rustdoc(doxygen: ParsedDoxygen) -> String {
     }
 
     if let Some(brief) = doxygen.brief {
-        rustdoc += brief.as_str();
+        rustdoc += &brief.to_string();
         rustdoc += "\n\n";
     }
 
     if let Some(description) = doxygen.description {
-        rustdoc += description.replace("< ", "").as_str();
-        rustdoc += "\n\n";
+        for desc in description {
+            rustdoc += format!("{}\n", desc).as_str();
+        }
+        rustdoc += "\n";
     }
 
     if let Some(warnings) = doxygen.warnings {
         rustdoc += "**Warning!**\n\n";
         for warning in warnings {
-            rustdoc += format!("* {}\n", warning.0).as_str();
+            rustdoc += format!("{:1}\n", warning.0).as_str();
         }
         rustdoc += "\n"
     }
 
     if let Some(returns) = doxygen.returns {
         rustdoc += "Returns:\n\n";
         for return_val in returns {
-            rustdoc += format!("* {}\n", return_val.0).as_str()
+            rustdoc += format!("{:1}\n", return_val.0).as_str()
         }
         rustdoc += "\n";
     }
 
     if let Some(params) = doxygen.params {
         rustdoc += "# Arguments\n\n";
         for param in params {
-            if let Some(description) = param.description {
-                rustdoc += format!("* `{}` - {}", param.arg_name, description).as_str();
+            let mut dir = String::new();
+            if let Some(direction) = param.direction {
+                dir += format!(" [Direction: {}] ", direction.clone()).as_str()
             } else {
-                rustdoc += format!("* `{}`", param.arg_name).as_str();
-            }
+                dir += " "
+            };
 
-            if let Some(direction) = param.direction {
-                rustdoc += format!(" [Direction: {}]", direction).as_str();
+            if let Some(description) = param.description {
+                rustdoc += format!("* `{}` -{}{:#1}", param.arg_name, dir, description).as_str();
+            } else {
+                rustdoc += format!("* `{}` -{}", param.arg_name, dir).as_str();
             }
 
             rustdoc += "\n";
@@ -80,27 +85,27 @@ pub fn generate_rustdoc(doxygen: ParsedDoxygen) -> String {
     if let Some(return_values) = doxygen.return_values {
         rustdoc += "# Return values\n";
         for return_val in return_values {
-            rustdoc += format!("* {}\n", return_val.0).as_str();
+            rustdoc += format!("{:1}\n", return_val.0).as_str();
         }
         rustdoc += "\n"
     }
 
     if let Some(notes) = doxygen.notes {
         rustdoc += "# Notes\n\n";
         for note in notes {
-            rustdoc += format!("* {}\n", note.0).as_str();
+            rustdoc += format!("{:1}\n", note.0).as_str();
         }
         rustdoc += "\n"
     }
 
     if let Some(todos) = doxygen.todos {
         rustdoc += "# To Do\n\n";
         for todo in todos {
-            rustdoc += format!("* {}", todo).as_str();
+            rustdoc += format!("{:1}", todo).as_str();
         }
 
         rustdoc += "\n";
     }
 
     rustdoc
-}
+}

src/lib.rs

@@ -34,9 +34,9 @@
 
 use crate::parser::StringType;
 
-pub mod parser;
 pub mod ast;
 pub mod generator;
+pub mod parser;
 mod utils;
 
 /// Transforms raw Doxygen comments to raw Rustdoc comments
@@ -64,9 +64,12 @@ pub fn transform_bindgen(input: &str) -> String {
             StringType::Parsed(data) => {
                 let ast = ast::generate_ast(data);
                 let rustdoc = generator::generate_rustdoc(ast);
-                let bindgen_doc = rustdoc.lines().map(|v| format!("#[doc = \"{}\"]\n", v.trim())).collect::<String>();
+                let bindgen_doc = rustdoc
+                    .lines()
+                    .map(|v| format!("#[doc = \"{}\"]\n", v.trim()))
+                    .collect::<String>();
                 file_data.push(bindgen_doc);
-            },
+            }
             StringType::Raw(raw) => file_data.push(raw),
         }
     }
@@ -84,10 +87,18 @@ mod tests {
         const INPUT: &str = r#"
 @brief Creates a new dog.
 
-Creates a new Dog named `_name` with half of its maximum energy.
+Creates a new Dog named `_name` with half
+    of its maximum
+    energy.
 
-@param _name The dog's name.
-@param[in] _test Test for In
+
+@param _name The dog's name. Ignored when:
+    - _test input null
+    - random_dog cfg option set 
+@param[in] _test Test for In,
+    also testing longer param description
+    - also param sublist
+      - and nested sublist
 
 @deprecated
 
@@ -106,14 +117,15 @@ Returns:
 
 # Arguments
 
-* `_name` - The dog's name.
-* `_test` - Test for In [Direction: In]
+* `_name` - The dog's name. Ignored when:
+  * _test input null
+  * random_dog cfg option set 
+* `_test` - [Direction: In] Test for In, also testing longer param description
+  * also param sublist
+    * and nested sublist
 
 "#;
-        assert_eq!(
-            EXPECTED,
-            transform(INPUT).as_str(),
-        );
+        assert_eq!(EXPECTED, transform(INPUT).as_str(),);
     }
 
     #[test]
@@ -131,4 +143,4 @@ Returns:
         let _ = fs::remove_file("assets/tests/ctru-sys-bindings-transformed.rs");
         fs::write("assets/tests/ctru-sys-bindings-transformed.rs", result).unwrap();
     }
-}
+}