stash some doc gen

Author: CppCXY

Cargo.lock

@@ -30,4 +30,5 @@ percent-encoding = "2.3"
 flagset = "0.4.6"
 encoding_rs = "0.8"
 url = "2.5.2"
-smol_str = "0.3.2"
+smol_str = "0.3.2"
+tera = "1.20.0"

Cargo.toml

@@ -11,4 +11,5 @@ serde_json.workspace = true
 lsp-types.workspace = true
 rowan.workspace = true
 walkdir.workspace = true
-structopt.workspace = true
+structopt.workspace = true
+tera.workspace = true

crates/emmylua_doc_cli/Cargo.toml

@@ -0,0 +1,22 @@
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+pub struct CmdArgs {
+    /// The path of the lua file
+    #[structopt(
+        parse(from_os_str),
+        long = "input",
+        short = "i",
+        help = "The path of the lua project"
+    )]
+    pub input: std::path::PathBuf,
+    /// The output path of the markdown file
+    #[structopt(
+        parse(from_os_str),
+        default_value = "./output",
+        long = "output",
+        short = "o",
+        help = "The output path of the markdown file"
+    )]
+    pub output: std::path::PathBuf,
+}

crates/emmylua_doc_cli/src/cmd_args.rs

@@ -1,3 +1,4 @@
+mod cmd_args;
 mod init;
 mod markdown_generator;
 

crates/emmylua_doc_cli/src/main.rs

@@ -1,6 +1,31 @@
+mod mod_gen;
+mod render;
+mod typ_gen;
+
+use std::path::PathBuf;
+
 use code_analysis::EmmyLuaAnalysis;
+use tera::Tera;
 
 #[allow(unused)]
-pub fn generate_markdown(analysis: &mut EmmyLuaAnalysis, output: &str) {
-    
-}
+pub fn generate_markdown(analysis: &mut EmmyLuaAnalysis, output: &PathBuf) -> Option<()> {
+    let types_out = output.join("types");
+    let module_out = output.join("modules");
+    let resources = analysis.get_resource_dir()?;
+    let tl_template = resources.join("template/**/*.tl");
+    let tl = match Tera::new(tl_template.to_string_lossy().as_ref()) {
+        Ok(tl) => tl,
+        Err(e) => {
+            eprintln!("Failed to load template: {}", e);
+            return None;
+        }
+    };
+    let db = analysis.compilation.get_db();
+    let type_index = db.get_type_index();
+    let types = type_index.get_all_types();
+    for type_decl in types {
+        typ_gen::generate_type_markdown(db, &tl, type_decl, &types_out);
+    }
+
+    Some(())
+}

crates/emmylua_doc_cli/src/markdown_generator/mod.rs

@@ -0,0 +1,175 @@
+use code_analysis::{humanize_type, DbIndex, LuaPropertyOwnerId, LuaSignatureId, LuaType};
+
+pub fn render_const_type(db: &DbIndex, typ: &LuaType) -> String {
+    let const_value = humanize_type(db, typ);
+
+    match typ {
+        LuaType::IntegerConst(_) | LuaType::DocIntergerConst(_) => {
+            format!("integer = {}", const_value)
+        }
+        LuaType::FloatConst(_) => format!("number = {}", const_value),
+        LuaType::StringConst(_) | LuaType::DocStringConst(_) => format!("string = {}", const_value),
+        _ => const_value,
+    }
+}
+
+pub fn render_function_type(db: &DbIndex, typ: &LuaType, func_name: &str, is_local: bool) -> String {
+    match typ {
+        LuaType::Function => {
+            format!(
+                "{}function {}()",
+                if is_local { "local " } else { "" },
+                func_name
+            )
+        }
+        LuaType::DocFunction(lua_func) => {
+            let async_prev = if lua_func.is_async() { "async " } else { "" };
+            let local_prev = if is_local { "local " } else { "" };
+            let params = lua_func
+                .get_params()
+                .iter()
+                .map(|param| {
+                    let name = param.0.clone();
+                    if let Some(ty) = &param.1 {
+                        format!("{}: {}", name, humanize_type(db, ty))
+                    } else {
+                        name.to_string()
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            let rets = lua_func.get_ret();
+
+            let ret_strs = rets
+                .iter()
+                .map(|ty| humanize_type(db, ty))
+                .collect::<Vec<_>>()
+                .join(",");
+
+            let mut result = String::new();
+            result.push_str(async_prev);
+            result.push_str(local_prev);
+            result.push_str("function ");
+            result.push_str(func_name);
+            result.push_str("(");
+            if params.len() > 1 {
+                result.push_str("\n");
+                for param in &params {
+                    result.push_str("  ");
+                    result.push_str(param);
+                    result.push_str(",\n");
+                }
+                result.pop(); // Remove the last comma
+                result.pop(); // Remove the last newline
+                result.push_str("\n");
+            } else {
+                result.push_str(&params.join(", "));
+            }
+            result.push_str(")");
+            if ret_strs.len() > 15 {
+                result.push_str("\n");
+            }
+
+            if !ret_strs.is_empty() {
+                result.push_str("-> ");
+                result.push_str(&ret_strs);
+            }
+
+            result
+        }
+        LuaType::Signature(signature_id) => {
+            render_signature_type(db, signature_id.clone(), func_name, is_local).unwrap_or(format!(
+                "{}function {}",
+                if is_local { "local " } else { "" },
+                func_name
+            ))
+        }
+        _ => format!(
+            "{}function {}",
+            if is_local { "local " } else { "" },
+            func_name
+        ),
+    }
+}
+
+fn render_signature_type(
+    db: &DbIndex,
+    signature_id: LuaSignatureId,
+    func_name: &str,
+    is_local: bool,
+) -> Option<String> {
+    let signature = db.get_signature_index().get(&signature_id)?;
+    let mut async_prev = "";
+    if let Some(property) = db
+        .get_property_index()
+        .get_property(LuaPropertyOwnerId::Signature(signature_id))
+    {
+        async_prev = if property.is_async { "async " } else { "" };
+    }
+
+    let local_prev = if is_local { "local " } else { "" };
+    let params = signature
+        .get_type_params()
+        .iter()
+        .map(|param| {
+            let name = param.0.clone();
+            if let Some(ty) = &param.1 {
+                format!("{}: {}", name, humanize_type(db, ty))
+            } else {
+                name.to_string()
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let rets = &signature.return_docs;
+
+    let mut result = String::new();
+    result.push_str(async_prev);
+    result.push_str(local_prev);
+    result.push_str("function ");
+    result.push_str(func_name);
+    result.push_str("(");
+    if params.len() > 1 {
+        result.push_str("\n");
+        for param in &params {
+            result.push_str("  ");
+            result.push_str(param);
+            result.push_str(",\n");
+        }
+        result.pop(); // Remove the last comma
+        result.pop(); // Remove the last newline
+        result.push_str("\n");
+    } else {
+        result.push_str(&params.join(", "));
+    }
+    result.push_str(")");
+    match rets.len() {
+        0 => {}
+        1 => {
+            result.push_str(" -> ");
+            let type_text = humanize_type(db, &rets[0].type_ref);
+            let name = rets[0].name.clone().unwrap_or("".to_string());
+            let detail = if rets[0].description.is_some() {
+                format!(" -- {}", rets[0].description.as_ref().unwrap())
+            } else {
+                "".to_string()
+            };
+            result.push_str(format!("{}{}{}", name, type_text, detail).as_str());
+        }
+        _ => {
+            result.push_str("\n");
+            for ret in rets {
+                let type_text = humanize_type(db, &ret.type_ref);
+                let name = ret.name.clone().unwrap_or("".to_string());
+                let detail = if ret.description.is_some() {
+                    format!(" -- {}", ret.description.as_ref().unwrap())
+                } else {
+                    "".to_string()
+                };
+                result.push_str(format!(" -> {}{}{}\n", name, type_text, detail).as_str());
+            }
+        }
+    }
+
+    Some(result)
+}

crates/emmylua_doc_cli/src/markdown_generator/mod_gen.rs

@@ -0,0 +1,69 @@
+use std::path::Path;
+
+use code_analysis::{humanize_type, DbIndex, LuaMemberOwner, LuaPropertyOwnerId, LuaTypeDecl};
+use serde::{Deserialize, Serialize};
+use tera::Tera;
+
+pub fn generate_type_markdown(
+    db: &DbIndex,
+    tl: &Tera,
+    typ: &LuaTypeDecl,
+    output: &Path,
+) -> Option<()> {
+    let mut context = tera::Context::new();
+    let typ_name = typ.get_name();
+    context.insert("type_name", &typ_name);
+
+    let typ_id = typ.get_id();
+    let namespace = typ.get_namespace();
+    context.insert("namespace", &namespace);
+
+    let type_property_id = LuaPropertyOwnerId::TypeDecl(typ_id.clone());
+    let typ_property = db.get_property_index().get_property(type_property_id);
+    if let Some(typ_property) = typ_property {
+        if let Some(property_text) = &typ_property.description {
+            context.insert("description", &property_text);
+        }
+    }
+
+    let supers = db.get_type_index().get_super_types(&typ_id);
+    if let Some(supers) = supers {
+        let mut super_type_texts = Vec::new();
+        for super_typ in supers {
+            let super_type_text = humanize_type(db, &super_typ);
+            super_type_texts.push(super_type_text);
+        }
+        context.insert("super_types", &super_type_texts.join(", "));
+    }
+
+    let member_owner = LuaMemberOwner::Type(typ_id);
+    let member_map = db.get_member_index().get_member_map(member_owner);
+    let mut method_members: Vec<MethodMember> = Vec::new();
+    let mut field_members: Vec<FieldMember> = Vec::new();
+    if let Some(member_map) = member_map {
+        for (member_name, member_id) in member_map {
+            let member = db.get_member_index().get_member(member_id)?;
+            let member_typ = member.get_decl_type();
+        }
+    }
+    context.insert("methods", &method_members);
+    context.insert("fields", &field_members);
+    // let markdown
+
+    let render_text = tl.render("lua_type_template.tl", &context).ok()?;
+    let outpath = output.join(format!("{}.md", typ.get_full_name()));
+    std::fs::write(outpath, render_text).ok()?;
+    Some(())
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct MethodMember {
+    pub display_name: String,
+    pub description: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct FieldMember {
+    pub display_name: String,
+    pub description: String,
+}

crates/emmylua_doc_cli/src/markdown_generator/render.rs

@@ -0,0 +1,26 @@
+# {{ type_name }}
+
+- supers: {{ super_types }}
+- namespace: {{ namespace }}
+
+{% if description %}
+{{ description }}
+{% endif %}
+
+## methods
+{% for method in methods %}
+<span style="font-family: monospace;">`{{ method.display }}`</span>
+
+{% if method.description %}
+<span style="margin-left: 20px; font-size: 0.9em;">{{ method.description }}</span>
+{% endif %}
+{% endfor %}
+
+## fields
+{% for field in fields %}
+<span style="font-family: monospace;">`{{ field.display }}`</span>
+
+{% if field.description %}
+<span style="margin-left: 20px; font-size: 0.9em;">{{ field.description }}</span>
+{% endif %}
+{% endfor %}