add basic doc generate

Author: CppCXY

crates/code_analysis/src/db_index/type/type_decl.rs

@@ -215,6 +215,17 @@ impl LuaTypeDeclId {
     pub fn get_name(&self) -> &str {
         &self.id
     }
+
+    pub fn get_simple_name(&self) -> &str {
+        let basic_name = self.get_name();
+        let just_name = if let Some(i) = basic_name.rfind('.') {
+            &basic_name[i + 1..]
+        } else {
+            &basic_name
+        };
+
+        &just_name
+    }
 }
 
 impl Serialize for LuaTypeDeclId {

crates/code_analysis/src/vfs/loader.rs

@@ -6,7 +6,7 @@ use std::{
 };
 use wax::Pattern;
 
-use log::error;
+use log::{error, info};
 use walkdir::WalkDir;
 
 #[derive(Debug)]
@@ -85,13 +85,23 @@ pub fn load_workspace_files(
 }
 
 pub fn read_file_with_encoding(path: &Path, encoding: &str) -> Option<String> {
-    let content = fs::read(path).ok()?;
+    let origin_content = fs::read(path).ok()?;
     let encoding = Encoding::for_label(encoding.as_bytes()).unwrap_or(UTF_8);
-
-    let (content, has_error) = encoding.decode_with_bom_removal(&content);
+    let (content, has_error) = encoding.decode_with_bom_removal(&origin_content);
     if has_error {
         error!("Error decoding file: {:?}", path);
-        return None;
+        if encoding == UTF_8 {
+            return None;
+        }
+
+        info!("Try utf-8 encoding");
+        let (content, _, hash_error) = UTF_8.decode(&origin_content);
+        if hash_error {
+            error!("Try utf8 fail, error decoding file: {:?}", path);
+            return None;
+        }
+
+        return Some(content.to_string());
     }
 
     Some(content.to_string())

crates/emmylua_doc_cli/src/cmd_args.rs

@@ -16,7 +16,7 @@ pub struct CmdArgs {
         default_value = "./output",
         long = "output",
         short = "o",
-        help = "The output path of the markdown file"
+        help = "The output path of the docs file"
     )]
     pub output: std::path::PathBuf,
 }

crates/emmylua_doc_cli/src/init.rs

@@ -11,6 +11,10 @@ pub fn load_workspace(workspace_folders: Vec<&str>) -> Option<EmmyLuaAnalysis> {
         .iter()
         .map(|s| PathBuf::from(s))
         .collect::<Vec<_>>();
+    for path in &paths {
+        analysis.add_workspace_root(path.clone());
+    }
+
     let main_path = paths.get(0)?.clone();
     let config_files = vec![
         main_path.join(".luarc.json"),

crates/emmylua_doc_cli/src/main.rs

@@ -1,7 +1,14 @@
+use cmd_args::CmdArgs;
+use structopt::StructOpt;
+
 mod cmd_args;
 mod init;
 mod markdown_generator;
 
 fn main() {
-    println!("Hello, world!");
+    let args = CmdArgs::from_args();
+    let analysis = init::load_workspace(vec![args.input.to_str().unwrap()]);
+    if let Some(mut analysis) = analysis {
+        markdown_generator::generate_markdown(&mut analysis, &args.input, &args.output);
+    }
 }

crates/emmylua_doc_cli/src/markdown_generator/index_gen.rs

@@ -0,0 +1,36 @@
+use tera::Tera;
+
+use super::MkdocsIndex;
+
+pub fn generate_index(tl: &Tera, mkdocs: &MkdocsIndex, output: &std::path::PathBuf) -> Option<()> {
+    let mut context = tera::Context::new();
+    if !mkdocs.types.is_empty() {
+        context.insert("types", &mkdocs.types);
+    }
+    if !mkdocs.modules.is_empty() {
+        context.insert("modules", &mkdocs.modules);
+    }
+    let index_path = output.join("docs/index.md");
+    let index_text = match tl.render("index_template.tl", &context) {
+        Ok(text) => text,
+        Err(e) => {
+            eprintln!("Failed to render index: {}", e);
+            return None;
+        }
+    };
+
+    std::fs::write(index_path, index_text).ok()?;
+
+    let mkdocs_yml_path = output.join("mkdocs.yml");
+    let mkdocs_yml_text = match tl.render("mkdocs_template.tl", &context) {
+        Ok(text) => text,
+        Err(e) => {
+            eprintln!("Failed to render mkdocs.yml: {}", e);
+            return None;
+        }
+    };
+
+    std::fs::write(mkdocs_yml_path, mkdocs_yml_text).ok()?;
+
+    Some(())
+}

crates/emmylua_doc_cli/src/markdown_generator/mod.rs

@@ -1,16 +1,42 @@
+mod index_gen;
 mod mod_gen;
 mod render;
 mod typ_gen;
 
 use std::path::PathBuf;
 
 use code_analysis::EmmyLuaAnalysis;
+use serde::{Deserialize, Serialize};
 use tera::Tera;
 
 #[allow(unused)]
-pub fn generate_markdown(analysis: &mut EmmyLuaAnalysis, output: &PathBuf) -> Option<()> {
-    let types_out = output.join("types");
-    let module_out = output.join("modules");
+pub fn generate_markdown(
+    analysis: &mut EmmyLuaAnalysis,
+    input: &PathBuf,
+    output: &PathBuf,
+) -> Option<()> {
+    let docs_dir = output.join("docs");
+    let types_out = docs_dir.join("types");
+    if !types_out.exists() {
+        println!("Creating types directory: {:?}", types_out);
+        std::fs::create_dir_all(&types_out).ok()?;
+    } else {
+        println!("Clearing types directory: {:?}", types_out);
+        std::fs::remove_dir_all(&types_out).ok()?;
+        std::fs::create_dir_all(&types_out).ok()?;
+    }
+
+    let module_out = docs_dir.join("modules");
+    if !module_out.exists() {
+        println!("Creating modules directory: {:?}", module_out);
+        std::fs::create_dir_all(&module_out).ok()?;
+    } else {
+        println!("Clearing modules directory: {:?}", module_out);
+        std::fs::remove_dir_all(&module_out).ok()?;
+        std::fs::create_dir_all(&module_out).ok()?;
+    }
+
+    let mut mkdocs_index = MkdocsIndex::default();
     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()) {
@@ -24,8 +50,47 @@ pub fn generate_markdown(analysis: &mut EmmyLuaAnalysis, output: &PathBuf) -> Op
     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);
+        typ_gen::generate_type_markdown(db, &tl, type_decl, &input, &types_out, &mut mkdocs_index);
     }
 
+    let module_index = db.get_module_index();
+    let modules = module_index.get_module_infos();
+    for module in modules {
+        mod_gen::generate_module_markdown(db, &tl, module, &input, &module_out, &mut mkdocs_index);
+    }
+
+    index_gen::generate_index(&tl, &mkdocs_index, output);
     Some(())
 }
+
+#[derive(Debug, Serialize, Deserialize)]
+struct MemberDisplay {
+    pub name: String,
+    pub display: String,
+    pub description: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+struct MkdocsIndex {
+    pub types: Vec<IndexStruct>,
+    pub modules: Vec<IndexStruct>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct IndexStruct {
+    pub name: String,
+    pub file: String,
+}
+
+fn escape_type_name(name: &str) -> String {
+    name.chars()
+        .map(|c| {
+            // Windows 无效文件名字符
+            if "<>:\"/\\|?*".contains(c) {
+                '_'
+            } else {
+                c
+            }
+        })
+        .collect()
+}

crates/emmylua_doc_cli/src/markdown_generator/mod_gen.rs

@@ -0,0 +1,154 @@
+use std::path::Path;
+
+use code_analysis::{
+    humanize_type, DbIndex, FileId, LuaMemberKey, LuaMemberOwner, LuaPropertyOwnerId, LuaType,
+    ModuleInfo,
+};
+use emmylua_parser::VisibilityKind;
+use tera::{Context, Tera};
+
+use crate::markdown_generator::{escape_type_name, IndexStruct, MemberDisplay};
+
+use super::{
+    render::{render_const_type, render_function_type},
+    MkdocsIndex,
+};
+
+pub fn generate_module_markdown(
+    db: &DbIndex,
+    tl: &Tera,
+    module: &ModuleInfo,
+    input: &Path,
+    output: &Path,
+    mkdocs_index: &mut MkdocsIndex,
+) -> Option<()> {
+    check_filter(db, module.file_id, input)?;
+
+    let mut context = tera::Context::new();
+    context.insert("module_name", &module.name);
+
+    let export_typ = module.export_type.clone()?;
+    match &export_typ {
+        LuaType::Def(type_id) => {
+            let member_owner = LuaMemberOwner::Type(type_id.clone());
+            let type_simple_name = type_id.get_simple_name();
+            generate_member_owner_module(db, member_owner, type_simple_name, &mut context);
+        }
+        LuaType::TableConst(t) => {
+            let member_owner = LuaMemberOwner::Element(t.clone());
+            generate_member_owner_module(db, member_owner, "M", &mut context);
+        }
+        LuaType::Instance(i) => {
+            let member_owner = LuaMemberOwner::Element(i.get_range().clone());
+            generate_member_owner_module(db, member_owner, "M", &mut context);
+        }
+        _ => {}
+    }
+
+    let render_text = match tl.render("lua_module_template.tl", &context) {
+        Ok(text) => text,
+        Err(e) => {
+            eprintln!("Failed to render template: {}", e);
+            return None;
+        }
+    };
+
+    let file_name = format!("{}.md", escape_type_name(&module.full_module_name));
+    mkdocs_index.modules.push(IndexStruct {
+        name: module.full_module_name.clone(),
+        file: format!("modules/{}", file_name.clone()),
+    });
+
+    let outpath = output.join(file_name);
+    println!("output module file: {}", outpath.display());
+    match std::fs::write(outpath, render_text) {
+        Ok(_) => {}
+        Err(e) => {
+            eprintln!("Failed to write file: {}", e);
+            return None;
+        }
+    }
+    Some(())
+}
+
+fn check_filter(db: &DbIndex, file_id: FileId, workspace: &Path) -> Option<()> {
+    let file_path = db.get_vfs().get_file_path(&file_id)?;
+    if !file_path.starts_with(workspace) {
+        return None;
+    }
+    Some(())
+}
+
+fn generate_member_owner_module(
+    db: &DbIndex,
+    member_owner: LuaMemberOwner,
+    owner_name: &str,
+    context: &mut Context,
+) -> Option<()> {
+    let member_map = db.get_member_index().get_member_map(member_owner);
+    let mut method_members: Vec<MemberDisplay> = Vec::new();
+    let mut field_members: Vec<MemberDisplay> = 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();
+            let member_property_id = LuaPropertyOwnerId::Member(member_id.clone());
+            let member_property = db.get_property_index().get_property(member_property_id);
+            if let Some(member_property) = member_property {
+                if member_property.visibility.unwrap_or(VisibilityKind::Public)
+                    != VisibilityKind::Public
+                {
+                    continue;
+                }
+            }
+
+            let description = if let Some(member_property) = member_property {
+                *member_property
+                    .description
+                    .clone()
+                    .unwrap_or("".to_string().into())
+            } else {
+                "".to_string()
+            };
+
+            let name = match member_name {
+                LuaMemberKey::Name(name) => name,
+                _ => continue,
+            };
+
+            let title_name = format!("{}.{}", owner_name, name);
+            if member_typ.is_function() {
+                let func_name = format!("{}.{}", owner_name, name);
+                let display = render_function_type(db, member_typ, &func_name, false);
+                method_members.push(MemberDisplay {
+                    name: title_name,
+                    display,
+                    description,
+                });
+            } else if member_typ.is_const() {
+                let display = render_const_type(db, &member_typ);
+                field_members.push(MemberDisplay {
+                    name: title_name,
+                    display: format!("{}.{}: {}", owner_name, name, display),
+                    description,
+                });
+            } else {
+                let typ_display = humanize_type(db, &member_typ);
+                field_members.push(MemberDisplay {
+                    name: title_name,
+                    display: format!("{}.{} : {}", owner_name, name, typ_display),
+                    description,
+                });
+            }
+        }
+    }
+    if !method_members.is_empty() {
+        context.insert("methods", &method_members);
+    }
+
+    if !field_members.is_empty() {
+        context.insert("fields", &field_members);
+    }
+
+    Some(())
+}