chore: write dart_event file

shared-lib/lib-infra/Cargo.toml

@@ -49,4 +49,4 @@ proto_gen = [
 ]
 pb_gen = ["cmd_lib", "protoc-rust", "walkdir", "protoc-bin-vendored",]
 dart_event = ["walkdir", "flowy-ast", "tera", "syn"]
-dart = ["proto_gen"]
+dart = ["proto_gen", "dart_event"]

shared-lib/lib-infra/src/code_gen/dart_event/dart_event.rs

@@ -1,6 +1,6 @@
 use super::event_template::*;
 use crate::code_gen::flowy_toml::{parse_crate_config_from, CrateConfig};
-use crate::code_gen::util::{cache_dir, is_crate_dir, is_hidden, read_file, save_content_to_file_with_diff_prompt};
+use crate::code_gen::util::{cache_dir, is_crate_dir, is_hidden, read_file};
 use flowy_ast::{event_ast::*, *};
 use std::fs::File;
 use std::io::Write;
@@ -8,7 +8,8 @@ use syn::Item;
 use walkdir::WalkDir;
 
 pub fn gen(crate_name: &str) {
-    let event_crates = parse_dart_event_files(vec![".".to_owned()]);
+    let crate_path = std::fs::canonicalize(".").unwrap().as_path().display().to_string();
+    let event_crates = parse_dart_event_files(vec![crate_path]);
     let event_ast = event_crates.iter().map(parse_event_crate).flatten().collect::<Vec<_>>();
 
     let event_render_ctx = ast_to_event_render_ctx(event_ast.as_ref());
@@ -23,6 +24,7 @@ pub fn gen(crate_name: &str) {
 
     let cache_dir = format!("{}/{}", cache_dir(), crate_name);
     let dart_event_file_path = format!("{}/dart_event.dart", cache_dir);
+
     match std::fs::OpenOptions::new()
         .create(true)
         .write(true)
@@ -34,16 +36,50 @@ pub fn gen(crate_name: &str) {
             file.write_all(render_result.as_bytes()).unwrap();
             File::flush(file).unwrap();
         }
-        Err(_err) => {
-            panic!("Failed to open file: {}", dart_event_file_path);
+        Err(err) => {
+            panic!("Failed to open file: {}, {:?}", dart_event_file_path, err);
         }
     }
 }
 
+const DART_IMPORTED: &str = r#"
+/// Auto gen code from rust ast, do not edit
+part of 'dispatch.dart';
+"#;
+
+pub fn write_dart_event_file(file_path: &str) {
+    let cache_dir = cache_dir();
+    let mut content = DART_IMPORTED.to_owned();
+    for path in WalkDir::new(cache_dir)
+        .into_iter()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().file_stem().unwrap().to_str().unwrap() == "dart_event")
+        .map(|e| e.path().to_str().unwrap().to_string())
+    {
+        let file_content = read_file(path.as_ref()).unwrap();
+        content.push_str(&file_content);
+    }
+
+    match std::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .append(false)
+        .truncate(true)
+        .open(&file_path)
+    {
+        Ok(ref mut file) => {
+            file.write_all(content.as_bytes()).unwrap();
+            File::flush(file).unwrap();
+        }
+        Err(err) => {
+            panic!("Failed to write dart event file: {}", err);
+        }
+    }
+}
+
+#[derive(Debug)]
 pub struct DartEventCrate {
     crate_path: String,
-    #[allow(dead_code)]
-    crate_name: String,
     event_files: Vec<String>,
 }
 
@@ -51,7 +87,6 @@ impl DartEventCrate {
     pub fn from_config(config: &CrateConfig) -> Self {
         DartEventCrate {
             crate_path: config.crate_path.clone(),
-            crate_name: config.folder_name.clone(),
             event_files: config.flowy_config.event_files.clone(),
         }
     }
@@ -117,10 +152,6 @@ pub fn ast_to_event_render_ctx(ast: &[EventASTContext]) -> Vec<EventRenderContex
                 .event_output
                 .as_ref()
                 .map(|event_output| event_output.get_ident().unwrap().to_string());
-            // eprintln!(
-            //     "😁 {:?} / {:?}",
-            //     event_ast.event_input, event_ast.event_output
-            // );
 
             EventRenderContext {
                 input_deserializer,

shared-lib/lib-infra/src/code_gen/dart_event/event_template.rs

@@ -5,11 +5,6 @@ pub struct EventTemplate {
     tera_context: Context,
 }
 
-pub const DART_IMPORTED: &str = r#"
-/// Auto gen code from rust ast, do not edit
-part of 'dispatch.dart';
-"#;
-
 pub struct EventRenderContext {
     pub input_deserializer: Option<String>,
     pub output_deserializer: Option<String>,
@@ -27,9 +22,6 @@ impl EventTemplate {
     }
 
     pub fn render(&mut self, ctx: EventRenderContext, index: usize) -> Option<String> {
-        if index == 0 {
-            self.tera_context.insert("imported_dart_files", DART_IMPORTED)
-        }
         self.tera_context.insert("index", &index);
         let dart_class_name = format!("{}{}", ctx.event_ty, ctx.event);
         let event = format!("{}.{}", ctx.event_ty, ctx.event);

shared-lib/lib-infra/src/code_gen/dart_event/event_template.tera

@@ -1,7 +1,3 @@
-{%- if index == 0 %}
-{{ imported_dart_files }}
-{%- endif -%}
-
 class {{ event_class }} {
 {%- if has_input  %}
      {{ input_deserializer }} request;

shared-lib/lib-infra/src/code_gen/mod.rs

@@ -8,4 +8,4 @@ pub mod dart_event;
 mod flowy_toml;
 
 #[cfg(any(feature = "pb_gen", feature = "dart_event"))]
-mod util;
+pub mod util;

shared-lib/lib-infra/src/code_gen/protobuf_file/mod.rs

@@ -22,7 +22,7 @@ pub fn gen(crate_name: &str, proto_file_dir: &str) {
     #[cfg(feature = "proto_gen")]
     let _ = gen_protos(crate_name);
 
-    let mut paths = vec![];
+    let mut proto_file_paths = vec![];
     let mut file_names = vec![];
 
     for (path, file_name) in WalkDir::new(proto_file_dir)
@@ -37,26 +37,31 @@ pub fn gen(crate_name: &str, proto_file_dir: &str) {
         if path.ends_with(".proto") {
             // https://stackoverflow.com/questions/49077147/how-can-i-force-build-rs-to-run-again-without-cleaning-my-whole-project
             println!("cargo:rerun-if-changed={}", path);
-            paths.push(path);
+            proto_file_paths.push(path);
             file_names.push(file_name);
         }
     }
-    println!("cargo:rerun-if-changed=build.rs");
     let protoc_bin_path = protoc_bin_vendored::protoc_bin_path().unwrap();
 
     // 2. generate the protobuf files(Dart)
     #[cfg(feature = "dart")]
-    generate_dart_protobuf_files(crate_name, proto_file_dir, &paths, &file_names, &protoc_bin_path);
+    generate_dart_protobuf_files(
+        crate_name,
+        proto_file_dir,
+        &proto_file_paths,
+        &file_names,
+        &protoc_bin_path,
+    );
 
     // 3. generate the protobuf files(Rust)
-    generate_rust_protobuf_files(&protoc_bin_path, &paths, proto_file_dir);
+    generate_rust_protobuf_files(&protoc_bin_path, &proto_file_paths, proto_file_dir);
 }
 
-fn generate_rust_protobuf_files(protoc_bin_path: &PathBuf, input_paths: &Vec<String>, proto_file_dir: &str) {
+fn generate_rust_protobuf_files(protoc_bin_path: &PathBuf, proto_file_paths: &Vec<String>, proto_file_dir: &str) {
     protoc_rust::Codegen::new()
         .out_dir("./src/protobuf/model")
         .protoc_path(protoc_bin_path)
-        .inputs(input_paths)
+        .inputs(proto_file_paths)
         .include(proto_file_dir)
         .run()
         .expect("Running protoc failed.");
@@ -68,7 +73,7 @@ fn generate_dart_protobuf_files(
     root: &str,
     paths: &Vec<String>,
     file_names: &Vec<String>,
-    proto_path: &PathBuf,
+    protoc_bin_path: &PathBuf,
 ) {
     if std::env::var("CARGO_MAKE_WORKING_DIRECTORY").is_err() {
         log::warn!("CARGO_MAKE_WORKING_DIRECTORY was not set, skip generate dart pb");
@@ -82,15 +87,15 @@ fn generate_dart_protobuf_files(
 
     let workspace_dir = std::env::var("CARGO_MAKE_WORKING_DIRECTORY").unwrap();
     let flutter_sdk_path = std::env::var("FLUTTER_FLOWY_SDK_PATH").unwrap();
-    let output = format!("{}/{}/{}", workspace_dir, flutter_sdk_path, name);
+    let output = format!("{}/{}/lib/protobuf/{}", workspace_dir, flutter_sdk_path, name);
     if !std::path::Path::new(&output).exists() {
         std::fs::create_dir_all(&output).unwrap();
     }
     check_pb_dart_plugin();
-    let proto_path = proto_path.to_str().unwrap().to_owned();
+    let protoc_bin_path = protoc_bin_path.to_str().unwrap().to_owned();
     paths.iter().for_each(|path| {
         if cmd_lib::run_cmd! {
-            ${proto_path} --dart_out=${output} --proto_path=${root} ${path}
+            ${protoc_bin_path} --dart_out=${output} --proto_path=${root} ${path}
         }
         .is_err()
         {