feat: handle enums, functions and implementation blocks & improve html output(#2)

* remove doc asset

* feat: Enhance CLI and add support for test functions

- Updated CLI to accept a path to the crate root and added an option to include test functions in the diagram.
- Introduced new modules for handling enums, functions, and implementation blocks, each with HTML rendering capabilities.
- Refactored logic to parse Rust files recursively, organizing items by type and allowing for the inclusion/exclusion of test items.
- Improved HTML templates and CSS styles for better presentation of Rust structures, enums, functions, and implementation blocks.
- Added responsive design improvements to the generated HTML output.

Author: bircni

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
           lfs: true
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.85
+          toolchain: stable
       - uses: Swatinem/rust-cache@v2
 
       - name: cargo build
@@ -37,7 +37,7 @@ jobs:
           lfs: true
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.85
+          toolchain: stable
           components: rustfmt, clippy
       - uses: Swatinem/rust-cache@v2
 
@@ -56,7 +56,7 @@ jobs:
     steps:
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.85
+          toolchain: stable
       - uses: actions/checkout@v4
       - uses: Swatinem/rust-cache@v2
       - run: cargo fetch
@@ -75,7 +75,7 @@ jobs:
     steps:
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.85
+          toolchain: stable
       - uses: Swatinem/rust-cache@v2
       - uses: actions/checkout@v4
       - name: Machete

docs/assets/example.png

@@ -7,7 +7,7 @@ use log::LevelFilter;
 #[command(author, version, about)]
 /// Generate a diagram from Rust source code
 pub struct Cli {
-    /// Path to main.rs or lib.rs
+    /// Path to main.rs or lib.rs or the root of the crate
     #[clap(short, long)]
     pub path: Option<PathBuf>,
     /// Path to output the diagram
@@ -19,4 +19,7 @@ pub struct Cli {
     /// Name of the Diagram
     #[clap(short, long, default_value = "Diagram")]
     pub name: String,
+    /// Include test functions in the diagram (excluded by default)
+    #[clap(short = 't', long, default_value = "false")]
+    pub include_tests: bool,
 }

src/cli.rs

@@ -0,0 +1,45 @@
+use anyhow::Context as _;
+use serde::Serialize;
+use tinytemplate::TinyTemplate;
+
+use super::ToHtml;
+
+const ENUM_TEMPLATE: &str = r#"
+    <div class="enum">
+        <div class="enum-name">{name}</div>
+        <div class="enum-variants">
+            {{ for variant in variants }}
+                <div class="enum-variant">
+                    <div class="enum-variant-name">{variant.name}</div>
+                    {{ if variant.data }}
+                        <div class="enum-variant-data">{variant.data}</div>
+                    {{ endif }}
+                </div>
+            {{ endfor }}
+        </div>
+    </div>
+"#;
+
+#[derive(Serialize)]
+pub struct EnumContext {
+    pub name: String,
+    pub variants: Vec<EnumVariantContext>,
+}
+
+#[derive(Serialize)]
+pub struct EnumVariantContext {
+    pub name: String,
+    pub data: Option<String>,
+}
+
+impl ToHtml for EnumContext {
+    fn to_html(&self) -> anyhow::Result<String> {
+        let mut tt = TinyTemplate::new();
+        tt.set_default_formatter(&tinytemplate::format_unescaped);
+
+        tt.add_template("enum", ENUM_TEMPLATE)
+            .context("Failed to add template")?;
+
+        tt.render("enum", self).context("Failed to render template")
+    }
+}

src/items/enums.rs

@@ -0,0 +1,92 @@
+use anyhow::Context as _;
+use itertools::Itertools as _;
+use serde::Serialize;
+use syn::{Visibility, spanned::Spanned as _};
+use tinytemplate::TinyTemplate;
+
+use super::ToHtml;
+
+const FUNCTION_TEMPLATE: &str = r#"
+    <div class="function">
+        <div class="function-signature">
+            {{ if visibility }}<span class="function-visibility">{visibility}</span> {{ endif }}
+            {{ if modifiers }}<span class="function-modifiers">{modifiers}</span> {{ endif }}
+            <span class="function-name">{name}</span>
+            <span class="function-params">({params})</span>
+            {{ if return_type }}<span class="function-return"> -> {return_type}</span>{{ endif }}
+        </div>
+    </div>
+"#;
+
+#[derive(Serialize)]
+pub struct FunctionContext {
+    pub name: String,
+    pub params: String,
+    pub return_type: Option<String>,
+    pub visibility: Option<String>,
+    pub modifiers: Option<String>,
+}
+
+impl FunctionContext {
+    /// Create a `FunctionContext` from a `syn::Signature` and attributes
+    pub fn new(sig: &syn::Signature, vis: &Visibility) -> Self {
+        let visibility = match vis {
+            Visibility::Public(_) => Some("pub".to_owned()),
+            Visibility::Restricted(_) | Visibility::Inherited => None,
+        };
+
+        let mut modifiers = Vec::new();
+        if sig.asyncness.is_some() {
+            modifiers.push("async".to_owned());
+        }
+        if sig.constness.is_some() {
+            modifiers.push("const".to_owned());
+        }
+        if sig.unsafety.is_some() {
+            modifiers.push("unsafe".to_owned());
+        }
+
+        let params = sig
+            .inputs
+            .iter()
+            .map(|param| match param {
+                syn::FnArg::Receiver(r) => {
+                    r.span().source_text().expect("Could not get source_text")
+                }
+                syn::FnArg::Typed(t) => t.span().source_text().expect("Could not get source_text"),
+            })
+            .join(", ");
+
+        let return_type = match &sig.output {
+            syn::ReturnType::Default => None,
+            syn::ReturnType::Type(_, ty) => {
+                Some(ty.span().source_text().expect("Could not get source_text"))
+            }
+        };
+
+        Self {
+            name: sig.ident.to_string(),
+            params,
+            return_type,
+            visibility,
+            modifiers: if modifiers.is_empty() {
+                None
+            } else {
+                Some(modifiers.join(" "))
+            },
+        }
+    }
+}
+
+impl ToHtml for FunctionContext {
+    fn to_html(&self) -> anyhow::Result<String> {
+        let mut tt = TinyTemplate::new();
+        tt.set_default_formatter(&tinytemplate::format_unescaped);
+
+        tt.add_template("function", FUNCTION_TEMPLATE)
+            .context("Failed to add template")?;
+
+        tt.render("function", self)
+            .context("Failed to render template")
+    }
+}

src/items/functions.rs

@@ -0,0 +1,41 @@
+use anyhow::Context;
+use serde::Serialize;
+use tinytemplate::TinyTemplate;
+
+use super::ToHtml;
+
+const IMPL_TEMPLATE: &str = r#"
+    <div class="impl-block">
+        <div class="impl-header">
+            <span class="impl-type">impl</span>
+            {{ if generics }}<span class="impl-generics">{generics}</span>{{ endif }}
+            {{ if trait_name }}<span class="impl-trait">{trait_name}</span>{{ endif }}
+            <span class="impl-target"> for {target_type}</span>
+        </div>
+        <div class="impl-content">
+            {{ for function in functions }}
+                {function}
+            {{ endfor }}
+        </div>
+    </div>
+"#;
+
+#[derive(Serialize)]
+pub struct ImplContext {
+    pub target_type: String,
+    pub trait_name: Option<String>,
+    pub generics: Option<String>,
+    pub functions: Vec<String>,
+}
+
+impl ToHtml for ImplContext {
+    fn to_html(&self) -> anyhow::Result<String> {
+        let mut tt = TinyTemplate::new();
+        tt.set_default_formatter(&tinytemplate::format_unescaped);
+
+        tt.add_template("impl", IMPL_TEMPLATE)
+            .context("Failed to add template")?;
+
+        tt.render("impl", self).context("Failed to render template")
+    }
+}

src/items/impl_blocks.rs

@@ -1,6 +1,9 @@
+pub mod enums;
+pub mod functions;
+pub mod impl_blocks;
 pub mod module;
 pub mod structs;
 
 pub trait ToHtml {
-    fn to_html(&self) -> String;
+    fn to_html(&self) -> anyhow::Result<String>;
 }

src/items/mod.rs

@@ -1,13 +1,18 @@
+use anyhow::Context;
 use serde::Serialize;
 use tinytemplate::TinyTemplate;
 
 use super::ToHtml;
 
 const MODULE_TEMPLATE: &str = r#"
     <div class="module">
-        <div class="module-name">{name}</div>
+        <input type="checkbox" id="module-{name}" class="module-toggle" checked>
+        <label for="module-{name}" class="module-header">
+            <span class="toggle-icon">▼</span>
+            <span class="module-name">{name}</span>
+        </label>
         <div class="module-contents">
-            {contents}
+{contents}
         </div>
     </div>
 "#;
@@ -19,14 +24,14 @@ pub struct ModContext {
 }
 
 impl ToHtml for ModContext {
-    fn to_html(&self) -> String {
+    fn to_html(&self) -> anyhow::Result<String> {
         let mut tt = TinyTemplate::new();
         tt.set_default_formatter(&tinytemplate::format_unescaped);
 
         tt.add_template("module", MODULE_TEMPLATE)
-            .expect("Failed to add template");
+            .context("Failed to add template")?;
 
         tt.render("module", self)
-            .expect("Failed to render template")
+            .context("Failed to render template")
     }
 }

src/items/module.rs

@@ -1,6 +1,9 @@
+use anyhow::Context as _;
 use serde::Serialize;
 use tinytemplate::TinyTemplate;
 
+use crate::items::ToHtml;
+
 const STRUCT_TEMPLATE: &str = r#"
     <div class="struct">
         <div class="struct-name">{name}</div>
@@ -36,14 +39,14 @@ pub struct StructFieldContext {
     pub type_: String,
 }
 
-impl StructContext {
-    pub fn to_html(&self) -> String {
+impl ToHtml for StructContext {
+    fn to_html(&self) -> anyhow::Result<String> {
         let mut tt = TinyTemplate::new();
 
         tt.add_template("struct", STRUCT_TEMPLATE)
-            .expect("Failed to add template");
+            .context("Failed to add template")?;
 
         tt.render("struct", self)
-            .expect("Failed to render template")
+            .context("Failed to render template")
     }
 }