mirror of
https://github.com/AppFlowy-IO/AppFlowy.git
synced 2024-08-30 18:12:39 +00:00
chore: add codegen crate
This commit is contained in:
nathan
@ -6,50 +6,10 @@ edition = "2018"
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
log = "0.4.14"
|
||||
chrono = "0.4.19"
|
||||
bytes = { version = "1.0" }
|
||||
pin-project = "1.0"
|
||||
futures-core = { version = "0.3" }
|
||||
tokio = { version = "1.0", features = ["time", "rt"] }
|
||||
rand = "0.8.5"
|
||||
serde = { version = "1.0", features = ["derive"]}
|
||||
serde_json = "1.0"
|
||||
|
||||
|
||||
cmd_lib = { version = "1", optional = true }
|
||||
protoc-rust = { version = "2", optional = true }
|
||||
walkdir = { version = "2", optional = true }
|
||||
|
||||
flowy-ast = { path = "../flowy-ast", optional = true}
|
||||
similar = { version = "1.2.2", optional = true }
|
||||
syn = { version = "1.0.60", features = ["extra-traits", "parsing", "derive", "full"], optional = true }
|
||||
fancy-regex = { version = "0.10.0", optional = true }
|
||||
lazy_static = { version = "1.4.0", optional = true }
|
||||
tera = { version = "1.5.0", optional = true}
|
||||
itertools = { version = "0.10", optional = true }
|
||||
phf = { version = "0.8.0", features = ["macros"], optional = true }
|
||||
console = {version = "0.14.0", optional = true}
|
||||
protoc-bin-vendored = { version = "3.0", optional = true }
|
||||
toml = {version = "0.5.8", optional = true}
|
||||
|
||||
[features]
|
||||
proto_gen = [
|
||||
"flowy-ast",
|
||||
"similar",
|
||||
"syn",
|
||||
"fancy-regex",
|
||||
"lazy_static",
|
||||
"tera",
|
||||
"itertools",
|
||||
"phf",
|
||||
"walkdir",
|
||||
"console",
|
||||
"toml",
|
||||
"cmd_lib",
|
||||
"protoc-rust",
|
||||
"walkdir",
|
||||
"protoc-bin-vendored",
|
||||
]
|
||||
dart_event = ["walkdir", "flowy-ast", "tera", "syn"]
|
||||
dart = ["proto_gen", "dart_event"]
|
||||
@ -1,162 +0,0 @@
|
||||
use super::event_template::*;
|
||||
use crate::code_gen::flowy_toml::{parse_crate_config_from, CrateConfig};
|
||||
use crate::code_gen::util::{is_crate_dir, is_hidden, path_string_with_component, read_file};
|
||||
use flowy_ast::{event_ast::*, *};
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
use syn::Item;
|
||||
use walkdir::WalkDir;
|
||||
|
||||
pub fn gen(crate_name: &str) {
|
||||
if std::env::var("CARGO_MAKE_WORKING_DIRECTORY").is_err() {
|
||||
log::warn!("CARGO_MAKE_WORKING_DIRECTORY was not set, skip generate dart pb");
|
||||
return;
|
||||
}
|
||||
|
||||
if std::env::var("FLUTTER_FLOWY_SDK_PATH").is_err() {
|
||||
log::warn!("FLUTTER_FLOWY_SDK_PATH was not set, skip generate dart pb");
|
||||
return;
|
||||
}
|
||||
|
||||
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());
|
||||
let mut render_result = DART_IMPORTED.to_owned();
|
||||
for (index, render_ctx) in event_render_ctx.into_iter().enumerate() {
|
||||
let mut event_template = EventTemplate::new();
|
||||
|
||||
if let Some(content) = event_template.render(render_ctx, index) {
|
||||
render_result.push_str(content.as_ref())
|
||||
}
|
||||
}
|
||||
|
||||
let dart_event_folder: PathBuf = [
|
||||
&std::env::var("CARGO_MAKE_WORKING_DIRECTORY").unwrap(),
|
||||
&std::env::var("FLUTTER_FLOWY_SDK_PATH").unwrap(),
|
||||
"lib",
|
||||
"dispatch",
|
||||
"dart_event",
|
||||
crate_name,
|
||||
]
|
||||
.iter()
|
||||
.collect();
|
||||
|
||||
if !dart_event_folder.as_path().exists() {
|
||||
std::fs::create_dir_all(dart_event_folder.as_path()).unwrap();
|
||||
}
|
||||
|
||||
let dart_event_file_path = path_string_with_component(&dart_event_folder, vec!["dart_event.dart"]);
|
||||
println!("cargo:rerun-if-changed={}", dart_event_file_path);
|
||||
|
||||
match std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.append(false)
|
||||
.truncate(true)
|
||||
.open(&dart_event_file_path)
|
||||
{
|
||||
Ok(ref mut file) => {
|
||||
file.write_all(render_result.as_bytes()).unwrap();
|
||||
File::flush(file).unwrap();
|
||||
}
|
||||
Err(err) => {
|
||||
panic!("Failed to open file: {}, {:?}", dart_event_file_path, err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const DART_IMPORTED: &str = r#"
|
||||
/// Auto generate. Do not edit
|
||||
part of '../../dispatch.dart';
|
||||
"#;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct DartEventCrate {
|
||||
crate_path: PathBuf,
|
||||
event_files: Vec<String>,
|
||||
}
|
||||
|
||||
impl DartEventCrate {
|
||||
pub fn from_config(config: &CrateConfig) -> Self {
|
||||
DartEventCrate {
|
||||
crate_path: config.crate_path.clone(),
|
||||
event_files: config.flowy_config.event_files.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_dart_event_files(crate_paths: Vec<String>) -> Vec<DartEventCrate> {
|
||||
let mut dart_event_crates: Vec<DartEventCrate> = vec![];
|
||||
crate_paths.iter().for_each(|path| {
|
||||
let crates = WalkDir::new(path)
|
||||
.into_iter()
|
||||
.filter_entry(|e| !is_hidden(e))
|
||||
.filter_map(|e| e.ok())
|
||||
.filter(is_crate_dir)
|
||||
.flat_map(|e| parse_crate_config_from(&e))
|
||||
.map(|crate_config| DartEventCrate::from_config(&crate_config))
|
||||
.collect::<Vec<DartEventCrate>>();
|
||||
dart_event_crates.extend(crates);
|
||||
});
|
||||
dart_event_crates
|
||||
}
|
||||
|
||||
pub fn parse_event_crate(event_crate: &DartEventCrate) -> Vec<EventASTContext> {
|
||||
event_crate
|
||||
.event_files
|
||||
.iter()
|
||||
.map(|event_file| {
|
||||
let file_path = path_string_with_component(&event_crate.crate_path, vec![event_file.as_str()]);
|
||||
|
||||
let file_content = read_file(file_path.as_ref()).unwrap();
|
||||
let ast = syn::parse_file(file_content.as_ref()).expect("Unable to parse file");
|
||||
ast.items
|
||||
.iter()
|
||||
.map(|item| match item {
|
||||
Item::Enum(item_enum) => {
|
||||
let ctxt = Ctxt::new();
|
||||
let attrs =
|
||||
flowy_ast::enum_from_ast(&ctxt, &item_enum.ident, &item_enum.variants, &item_enum.attrs);
|
||||
ctxt.check().unwrap();
|
||||
attrs
|
||||
.iter()
|
||||
.filter(|attr| !attr.attrs.event_attrs.ignore)
|
||||
.enumerate()
|
||||
.map(|(_index, attr)| EventASTContext::from(&attr.attrs))
|
||||
.collect::<Vec<_>>()
|
||||
}
|
||||
_ => vec![],
|
||||
})
|
||||
.flatten()
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.flatten()
|
||||
.collect::<Vec<EventASTContext>>()
|
||||
}
|
||||
|
||||
pub fn ast_to_event_render_ctx(ast: &[EventASTContext]) -> Vec<EventRenderContext> {
|
||||
ast.iter()
|
||||
.map(|event_ast| {
|
||||
let input_deserializer = event_ast
|
||||
.event_input
|
||||
.as_ref()
|
||||
.map(|event_input| event_input.get_ident().unwrap().to_string());
|
||||
|
||||
let output_deserializer = event_ast
|
||||
.event_output
|
||||
.as_ref()
|
||||
.map(|event_output| event_output.get_ident().unwrap().to_string());
|
||||
|
||||
EventRenderContext {
|
||||
input_deserializer,
|
||||
output_deserializer,
|
||||
error_deserializer: event_ast.event_error.clone(),
|
||||
event: event_ast.event.to_string(),
|
||||
event_ty: event_ast.event_ty.to_string(),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<EventRenderContext>>()
|
||||
}
|
||||
@ -1,61 +0,0 @@
|
||||
use crate::code_gen::util::get_tera;
|
||||
use tera::Context;
|
||||
|
||||
pub struct EventTemplate {
|
||||
tera_context: Context,
|
||||
}
|
||||
|
||||
pub struct EventRenderContext {
|
||||
pub input_deserializer: Option<String>,
|
||||
pub output_deserializer: Option<String>,
|
||||
pub error_deserializer: String,
|
||||
pub event: String,
|
||||
pub event_ty: String,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl EventTemplate {
|
||||
pub fn new() -> Self {
|
||||
EventTemplate {
|
||||
tera_context: Context::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render(&mut self, ctx: EventRenderContext, index: usize) -> Option<String> {
|
||||
self.tera_context.insert("index", &index);
|
||||
let dart_class_name = format!("{}{}", ctx.event_ty, ctx.event);
|
||||
let event = format!("{}.{}", ctx.event_ty, ctx.event);
|
||||
self.tera_context.insert("event_class", &dart_class_name);
|
||||
self.tera_context.insert("event", &event);
|
||||
|
||||
self.tera_context.insert("has_input", &ctx.input_deserializer.is_some());
|
||||
match ctx.input_deserializer {
|
||||
None => self.tera_context.insert("input_deserializer", "Unit"),
|
||||
Some(ref input) => self.tera_context.insert("input_deserializer", input),
|
||||
}
|
||||
|
||||
// eprintln!(
|
||||
// "😁 {:?} / {:?}",
|
||||
// &ctx.input_deserializer, &ctx.output_deserializer
|
||||
// );
|
||||
|
||||
let has_output = ctx.output_deserializer.is_some();
|
||||
self.tera_context.insert("has_output", &has_output);
|
||||
|
||||
match ctx.output_deserializer {
|
||||
None => self.tera_context.insert("output_deserializer", "Unit"),
|
||||
Some(ref output) => self.tera_context.insert("output_deserializer", output),
|
||||
}
|
||||
|
||||
self.tera_context.insert("error_deserializer", &ctx.error_deserializer);
|
||||
|
||||
let tera = get_tera("dart_event");
|
||||
match tera.render("event_template.tera", &self.tera_context) {
|
||||
Ok(r) => Some(r),
|
||||
Err(e) => {
|
||||
log::error!("{:?}", e);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,45 +0,0 @@
|
||||
class {{ event_class }} {
|
||||
{%- if has_input %}
|
||||
{{ input_deserializer }} request;
|
||||
{{ event_class }}(this.request);
|
||||
{%- else %}
|
||||
{{ event_class }}();
|
||||
{%- endif %}
|
||||
|
||||
Future<Either<{{ output_deserializer }}, {{ error_deserializer }}>> send() {
|
||||
|
||||
{%- if has_input %}
|
||||
final request = FFIRequest.create()
|
||||
..event = {{ event }}.toString()
|
||||
..payload = requestToBytes(this.request);
|
||||
|
||||
return Dispatch.asyncRequest(request)
|
||||
.then((bytesResult) => bytesResult.fold(
|
||||
|
||||
{%- if has_output %}
|
||||
(okBytes) => left({{ output_deserializer }}.fromBuffer(okBytes)),
|
||||
{%- else %}
|
||||
(bytes) => left(unit),
|
||||
{%- endif %}
|
||||
(errBytes) => right({{ error_deserializer }}.fromBuffer(errBytes)),
|
||||
));
|
||||
|
||||
{%- else %}
|
||||
final request = FFIRequest.create()
|
||||
..event = {{ event }}.toString();
|
||||
{%- if has_input %}
|
||||
..payload = bytes;
|
||||
{%- endif %}
|
||||
|
||||
return Dispatch.asyncRequest(request).then((bytesResult) => bytesResult.fold(
|
||||
{%- if has_output %}
|
||||
(okBytes) => left({{ output_deserializer }}.fromBuffer(okBytes)),
|
||||
{%- else %}
|
||||
(bytes) => left(unit),
|
||||
{%- endif %}
|
||||
(errBytes) => right({{ error_deserializer }}.fromBuffer(errBytes)),
|
||||
));
|
||||
{%- endif %}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
#![allow(clippy::module_inception)]
|
||||
mod dart_event;
|
||||
mod event_template;
|
||||
|
||||
pub use dart_event::*;
|
||||
@ -1,59 +0,0 @@
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[derive(serde::Deserialize, Clone, Debug)]
|
||||
pub struct FlowyConfig {
|
||||
#[serde(default)]
|
||||
pub event_files: Vec<String>,
|
||||
|
||||
// Collect AST from the file or directory specified by proto_input to generate the proto files.
|
||||
#[serde(default)]
|
||||
pub proto_input: Vec<String>,
|
||||
|
||||
// Output path for the generated proto files. The default value is default_proto_output()
|
||||
#[serde(default = "default_proto_output")]
|
||||
pub proto_output: String,
|
||||
|
||||
// Create a crate that stores the generated protobuf Rust structures. The default value is default_protobuf_crate()
|
||||
#[serde(default = "default_protobuf_crate")]
|
||||
pub protobuf_crate_path: String,
|
||||
}
|
||||
|
||||
fn default_proto_output() -> String {
|
||||
"resources/proto".to_owned()
|
||||
}
|
||||
|
||||
fn default_protobuf_crate() -> String {
|
||||
"src/protobuf".to_owned()
|
||||
}
|
||||
|
||||
impl FlowyConfig {
|
||||
pub fn from_toml_file(path: &Path) -> Self {
|
||||
let content = fs::read_to_string(path).unwrap();
|
||||
let config: FlowyConfig = toml::from_str(content.as_ref()).unwrap();
|
||||
config
|
||||
}
|
||||
}
|
||||
|
||||
pub struct CrateConfig {
|
||||
pub crate_path: PathBuf,
|
||||
pub crate_folder: String,
|
||||
pub flowy_config: FlowyConfig,
|
||||
}
|
||||
|
||||
pub fn parse_crate_config_from(entry: &walkdir::DirEntry) -> Option<CrateConfig> {
|
||||
let mut config_path = entry.path().parent().unwrap().to_path_buf();
|
||||
config_path.push("Flowy.toml");
|
||||
if !config_path.as_path().exists() {
|
||||
return None;
|
||||
}
|
||||
let crate_path = entry.path().parent().unwrap().to_path_buf();
|
||||
let flowy_config = FlowyConfig::from_toml_file(config_path.as_path());
|
||||
let crate_folder = crate_path.file_stem().unwrap().to_str().unwrap().to_string();
|
||||
|
||||
Some(CrateConfig {
|
||||
crate_path,
|
||||
crate_folder,
|
||||
flowy_config,
|
||||
})
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
#[cfg(feature = "proto_gen")]
|
||||
pub mod protobuf_file;
|
||||
|
||||
#[cfg(feature = "dart_event")]
|
||||
pub mod dart_event;
|
||||
|
||||
#[cfg(any(feature = "proto_gen", feature = "dart_event"))]
|
||||
mod flowy_toml;
|
||||
|
||||
#[cfg(any(feature = "proto_gen", feature = "dart_event"))]
|
||||
pub mod util;
|
||||
|
||||
#[derive(serde::Serialize, serde::Deserialize)]
|
||||
pub struct ProtoCache {
|
||||
pub structs: Vec<String>,
|
||||
pub enums: Vec<String>,
|
||||
}
|
||||
@ -1,193 +0,0 @@
|
||||
#![allow(unused_attributes)]
|
||||
#![allow(dead_code)]
|
||||
#![allow(unused_imports)]
|
||||
#![allow(unused_results)]
|
||||
use crate::code_gen::protobuf_file::template::{EnumTemplate, StructTemplate, RUST_TYPE_MAP};
|
||||
use crate::code_gen::protobuf_file::{parse_crate_info_from_path, ProtoFile, ProtobufCrateContext};
|
||||
use crate::code_gen::util::*;
|
||||
use fancy_regex::Regex;
|
||||
use flowy_ast::*;
|
||||
use lazy_static::lazy_static;
|
||||
use std::path::PathBuf;
|
||||
use std::{fs::File, io::Read, path::Path};
|
||||
use syn::Item;
|
||||
use walkdir::WalkDir;
|
||||
|
||||
pub fn parse_protobuf_context_from(crate_paths: Vec<String>) -> Vec<ProtobufCrateContext> {
|
||||
let crate_infos = parse_crate_info_from_path(crate_paths);
|
||||
crate_infos
|
||||
.into_iter()
|
||||
.map(|crate_info| {
|
||||
let proto_output_path = crate_info.proto_output_path();
|
||||
let files = crate_info
|
||||
.proto_input_paths()
|
||||
.iter()
|
||||
.flat_map(|proto_crate_path| parse_files_protobuf(proto_crate_path, &proto_output_path))
|
||||
.collect::<Vec<ProtoFile>>();
|
||||
|
||||
ProtobufCrateContext::from_crate_info(crate_info, files)
|
||||
})
|
||||
.collect::<Vec<ProtobufCrateContext>>()
|
||||
}
|
||||
|
||||
fn parse_files_protobuf(proto_crate_path: &Path, proto_output_path: &Path) -> Vec<ProtoFile> {
|
||||
let mut gen_proto_vec: Vec<ProtoFile> = vec![];
|
||||
// file_stem https://doc.rust-lang.org/std/path/struct.Path.html#method.file_stem
|
||||
for (path, file_name) in WalkDir::new(proto_crate_path)
|
||||
.into_iter()
|
||||
.filter_entry(|e| !is_hidden(e))
|
||||
.filter_map(|e| e.ok())
|
||||
.filter(|e| !e.file_type().is_dir())
|
||||
.map(|e| {
|
||||
let path = e.path().to_str().unwrap().to_string();
|
||||
let file_name = e.path().file_stem().unwrap().to_str().unwrap().to_string();
|
||||
(path, file_name)
|
||||
})
|
||||
{
|
||||
if file_name == "mod" {
|
||||
continue;
|
||||
}
|
||||
|
||||
// https://docs.rs/syn/1.0.54/syn/struct.File.html
|
||||
let ast = syn::parse_file(read_file(&path).unwrap().as_ref())
|
||||
.unwrap_or_else(|_| panic!("Unable to parse file at {}", path));
|
||||
let structs = get_ast_structs(&ast);
|
||||
let proto_file = format!("{}.proto", &file_name);
|
||||
let proto_file_path = path_string_with_component(proto_output_path, vec![&proto_file]);
|
||||
let proto_syntax = find_proto_syntax(proto_file_path.as_ref());
|
||||
|
||||
let mut proto_content = String::new();
|
||||
|
||||
// The types that are not defined in the current file.
|
||||
let mut ref_types: Vec<String> = vec![];
|
||||
structs.iter().for_each(|s| {
|
||||
let mut struct_template = StructTemplate::new();
|
||||
struct_template.set_message_struct_name(&s.name);
|
||||
|
||||
s.fields
|
||||
.iter()
|
||||
.filter(|field| field.attrs.pb_index().is_some())
|
||||
.for_each(|field| {
|
||||
ref_types.push(field.ty_as_str());
|
||||
struct_template.set_field(field);
|
||||
});
|
||||
|
||||
let s = struct_template.render().unwrap();
|
||||
|
||||
proto_content.push_str(s.as_ref());
|
||||
proto_content.push('\n');
|
||||
});
|
||||
|
||||
let enums = get_ast_enums(&ast);
|
||||
enums.iter().for_each(|e| {
|
||||
let mut enum_template = EnumTemplate::new();
|
||||
enum_template.set_message_enum(e);
|
||||
let s = enum_template.render().unwrap();
|
||||
proto_content.push_str(s.as_ref());
|
||||
ref_types.push(e.name.clone());
|
||||
|
||||
proto_content.push('\n');
|
||||
});
|
||||
|
||||
if !enums.is_empty() || !structs.is_empty() {
|
||||
let structs: Vec<String> = structs.iter().map(|s| s.name.clone()).collect();
|
||||
let enums: Vec<String> = enums.iter().map(|e| e.name.clone()).collect();
|
||||
ref_types.retain(|s| !structs.contains(s));
|
||||
ref_types.retain(|s| !enums.contains(s));
|
||||
|
||||
let info = ProtoFile {
|
||||
file_path: path.clone(),
|
||||
file_name: file_name.clone(),
|
||||
ref_types,
|
||||
structs,
|
||||
enums,
|
||||
syntax: proto_syntax,
|
||||
content: proto_content,
|
||||
};
|
||||
gen_proto_vec.push(info);
|
||||
}
|
||||
}
|
||||
|
||||
gen_proto_vec
|
||||
}
|
||||
|
||||
pub fn get_ast_structs(ast: &syn::File) -> Vec<Struct> {
|
||||
// let mut content = format!("{:#?}", &ast);
|
||||
// let mut file = File::create("./foo.txt").unwrap();
|
||||
// file.write_all(content.as_bytes()).unwrap();
|
||||
let ctxt = Ctxt::new();
|
||||
let mut proto_structs: Vec<Struct> = vec![];
|
||||
ast.items.iter().for_each(|item| {
|
||||
if let Item::Struct(item_struct) = item {
|
||||
let (_, fields) = struct_from_ast(&ctxt, &item_struct.fields);
|
||||
|
||||
if fields.iter().filter(|f| f.attrs.pb_index().is_some()).count() > 0 {
|
||||
proto_structs.push(Struct {
|
||||
name: item_struct.ident.to_string(),
|
||||
fields,
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
ctxt.check().unwrap();
|
||||
proto_structs
|
||||
}
|
||||
|
||||
pub fn get_ast_enums(ast: &syn::File) -> Vec<FlowyEnum> {
|
||||
let mut flowy_enums: Vec<FlowyEnum> = vec![];
|
||||
let ctxt = Ctxt::new();
|
||||
|
||||
ast.items.iter().for_each(|item| {
|
||||
// https://docs.rs/syn/1.0.54/syn/enum.Item.html
|
||||
if let Item::Enum(item_enum) = item {
|
||||
let attrs = flowy_ast::enum_from_ast(&ctxt, &item_enum.ident, &item_enum.variants, &ast.attrs);
|
||||
flowy_enums.push(FlowyEnum {
|
||||
name: item_enum.ident.to_string(),
|
||||
attrs,
|
||||
});
|
||||
}
|
||||
});
|
||||
ctxt.check().unwrap();
|
||||
flowy_enums
|
||||
}
|
||||
|
||||
pub struct FlowyEnum<'a> {
|
||||
pub name: String,
|
||||
pub attrs: Vec<ASTEnumVariant<'a>>,
|
||||
}
|
||||
|
||||
pub struct Struct<'a> {
|
||||
pub name: String,
|
||||
pub fields: Vec<ASTField<'a>>,
|
||||
}
|
||||
|
||||
lazy_static! {
|
||||
static ref SYNTAX_REGEX: Regex = Regex::new("syntax.*;").unwrap();
|
||||
// static ref IMPORT_REGEX: Regex = Regex::new("(import\\s).*;").unwrap();
|
||||
}
|
||||
|
||||
fn find_proto_syntax(path: &str) -> String {
|
||||
if !Path::new(path).exists() {
|
||||
return String::from("syntax = \"proto3\";\n");
|
||||
}
|
||||
|
||||
let mut result = String::new();
|
||||
let mut file = File::open(path).unwrap();
|
||||
let mut content = String::new();
|
||||
file.read_to_string(&mut content).unwrap();
|
||||
|
||||
content.lines().for_each(|line| {
|
||||
////Result<Option<Match<'t>>>
|
||||
if let Ok(Some(m)) = SYNTAX_REGEX.find(line) {
|
||||
result.push_str(m.as_str());
|
||||
}
|
||||
|
||||
// if let Ok(Some(m)) = IMPORT_REGEX.find(line) {
|
||||
// result.push_str(m.as_str());
|
||||
// result.push('\n');
|
||||
// }
|
||||
});
|
||||
|
||||
result.push('\n');
|
||||
result
|
||||
}
|
||||
@ -1,206 +0,0 @@
|
||||
#![allow(unused_imports)]
|
||||
#![allow(unused_attributes)]
|
||||
#![allow(dead_code)]
|
||||
mod ast;
|
||||
mod proto_gen;
|
||||
mod proto_info;
|
||||
mod template;
|
||||
|
||||
use crate::code_gen::util::path_string_with_component;
|
||||
use itertools::Itertools;
|
||||
use log::info;
|
||||
pub use proto_gen::*;
|
||||
pub use proto_info::*;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
use walkdir::WalkDir;
|
||||
|
||||
pub fn gen(crate_name: &str) {
|
||||
let crate_path = std::fs::canonicalize(".").unwrap().as_path().display().to_string();
|
||||
|
||||
// 1. generate the proto files to proto_file_dir
|
||||
#[cfg(feature = "proto_gen")]
|
||||
let proto_crates = gen_proto_files(crate_name, &crate_path);
|
||||
|
||||
for proto_crate in proto_crates {
|
||||
let mut proto_file_paths = vec![];
|
||||
let mut file_names = vec![];
|
||||
let proto_file_output_path = proto_crate.proto_output_path().to_str().unwrap().to_string();
|
||||
let protobuf_output_path = proto_crate.protobuf_crate_path().to_str().unwrap().to_string();
|
||||
|
||||
for (path, file_name) in WalkDir::new(&proto_file_output_path)
|
||||
.into_iter()
|
||||
.filter_map(|e| e.ok())
|
||||
.map(|e| {
|
||||
let path = e.path().to_str().unwrap().to_string();
|
||||
let file_name = e.path().file_stem().unwrap().to_str().unwrap().to_string();
|
||||
(path, file_name)
|
||||
})
|
||||
{
|
||||
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);
|
||||
proto_file_paths.push(path);
|
||||
file_names.push(file_name);
|
||||
}
|
||||
}
|
||||
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_output_path,
|
||||
&proto_file_paths,
|
||||
&file_names,
|
||||
&protoc_bin_path,
|
||||
);
|
||||
|
||||
// 3. generate the protobuf files(Rust)
|
||||
generate_rust_protobuf_files(
|
||||
&protoc_bin_path,
|
||||
&proto_file_paths,
|
||||
&proto_file_output_path,
|
||||
&protobuf_output_path,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn generate_rust_protobuf_files(
|
||||
protoc_bin_path: &Path,
|
||||
proto_file_paths: &[String],
|
||||
proto_file_output_path: &str,
|
||||
protobuf_output_path: &str,
|
||||
) {
|
||||
protoc_rust::Codegen::new()
|
||||
.out_dir(protobuf_output_path)
|
||||
.protoc_path(protoc_bin_path)
|
||||
.inputs(proto_file_paths)
|
||||
.include(proto_file_output_path)
|
||||
.run()
|
||||
.expect("Running rust protoc failed.");
|
||||
}
|
||||
|
||||
#[cfg(feature = "dart")]
|
||||
fn generate_dart_protobuf_files(
|
||||
name: &str,
|
||||
proto_file_output_path: &str,
|
||||
paths: &Vec<String>,
|
||||
file_names: &Vec<String>,
|
||||
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");
|
||||
return;
|
||||
}
|
||||
|
||||
if std::env::var("FLUTTER_FLOWY_SDK_PATH").is_err() {
|
||||
log::warn!("FLUTTER_FLOWY_SDK_PATH was not set, skip generate dart pb");
|
||||
return;
|
||||
}
|
||||
|
||||
let mut output = PathBuf::new();
|
||||
output.push(std::env::var("CARGO_MAKE_WORKING_DIRECTORY").unwrap());
|
||||
output.push(std::env::var("FLUTTER_FLOWY_SDK_PATH").unwrap());
|
||||
output.push("lib");
|
||||
output.push("protobuf");
|
||||
output.push(name);
|
||||
|
||||
if !output.as_path().exists() {
|
||||
std::fs::create_dir_all(&output).unwrap();
|
||||
}
|
||||
check_pb_dart_plugin();
|
||||
let protoc_bin_path = protoc_bin_path.to_str().unwrap().to_owned();
|
||||
paths.iter().for_each(|path| {
|
||||
let result = cmd_lib::run_cmd! {
|
||||
${protoc_bin_path} --dart_out=${output} --proto_path=${proto_file_output_path} ${path}
|
||||
};
|
||||
|
||||
if result.is_err() {
|
||||
panic!("Generate dart pb file failed with: {}, {:?}", path, result)
|
||||
};
|
||||
});
|
||||
|
||||
let protobuf_dart = path_string_with_component(&output, vec!["protobuf.dart"]);
|
||||
|
||||
match std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.append(false)
|
||||
.truncate(true)
|
||||
.open(&protobuf_dart)
|
||||
{
|
||||
Ok(ref mut file) => {
|
||||
let mut export = String::new();
|
||||
export.push_str("// Auto-generated, do not edit \n");
|
||||
for file_name in file_names {
|
||||
let c = format!("export './{}.pb.dart';\n", file_name);
|
||||
export.push_str(c.as_ref());
|
||||
}
|
||||
|
||||
file.write_all(export.as_bytes()).unwrap();
|
||||
File::flush(file).unwrap();
|
||||
}
|
||||
Err(err) => {
|
||||
panic!("Failed to open file: {}", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn check_pb_dart_plugin() {
|
||||
if cfg!(target_os = "windows") {
|
||||
//Command::new("cmd")
|
||||
// .arg("/C")
|
||||
// .arg(cmd)
|
||||
// .status()
|
||||
// .expect("failed to execute process");
|
||||
//panic!("{}", format!("\n❌ The protoc-gen-dart was not installed correctly."))
|
||||
} else {
|
||||
let exit_result = Command::new("sh")
|
||||
.arg("-c")
|
||||
.arg("command -v protoc-gen-dart")
|
||||
.status()
|
||||
.expect("failed to execute process");
|
||||
|
||||
if !exit_result.success() {
|
||||
let mut msg = "\n❌ Can't find protoc-gen-dart in $PATH:\n".to_string();
|
||||
let output = Command::new("sh").arg("-c").arg("echo $PATH").output();
|
||||
let paths = String::from_utf8(output.unwrap().stdout)
|
||||
.unwrap()
|
||||
.split(':')
|
||||
.map(|s| s.to_string())
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
paths.iter().for_each(|s| msg.push_str(&format!("{}\n", s)));
|
||||
|
||||
if let Ok(output) = Command::new("sh").arg("-c").arg("which protoc-gen-dart").output() {
|
||||
msg.push_str(&format!(
|
||||
"Installed protoc-gen-dart path: {:?}\n",
|
||||
String::from_utf8(output.stdout).unwrap()
|
||||
));
|
||||
}
|
||||
|
||||
msg.push_str("✅ You can fix that by adding:");
|
||||
msg.push_str("\n\texport PATH=\"$PATH\":\"$HOME/.pub-cache/bin\"\n");
|
||||
msg.push_str("to your shell's config file.(.bashrc, .bash, .profile, .zshrc etc.)");
|
||||
panic!("{}", msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "proto_gen")]
|
||||
fn gen_proto_files(crate_name: &str, crate_path: &str) -> Vec<ProtobufCrate> {
|
||||
let crate_context = ProtoGenerator::gen(crate_name, crate_path);
|
||||
let proto_crates = crate_context
|
||||
.iter()
|
||||
.map(|info| info.protobuf_crate.clone())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
crate_context.into_iter().flat_map(|info| info.files).for_each(|file| {
|
||||
println!("cargo:rerun-if-changed={}", file.file_path);
|
||||
});
|
||||
|
||||
proto_crates
|
||||
}
|
||||
@ -1,161 +0,0 @@
|
||||
#![allow(unused_attributes)]
|
||||
#![allow(dead_code)]
|
||||
#![allow(unused_imports)]
|
||||
#![allow(unused_results)]
|
||||
use crate::code_gen::protobuf_file::ast::parse_protobuf_context_from;
|
||||
use crate::code_gen::protobuf_file::proto_info::ProtobufCrateContext;
|
||||
use crate::code_gen::protobuf_file::ProtoFile;
|
||||
use crate::code_gen::util::*;
|
||||
use crate::code_gen::ProtoCache;
|
||||
use std::collections::HashMap;
|
||||
use std::fs::File;
|
||||
use std::path::Path;
|
||||
use std::{fs::OpenOptions, io::Write};
|
||||
|
||||
pub struct ProtoGenerator();
|
||||
impl ProtoGenerator {
|
||||
pub fn gen(crate_name: &str, crate_path: &str) -> Vec<ProtobufCrateContext> {
|
||||
let crate_contexts = parse_protobuf_context_from(vec![crate_path.to_owned()]);
|
||||
write_proto_files(&crate_contexts);
|
||||
write_rust_crate_mod_file(&crate_contexts);
|
||||
|
||||
let proto_cache = ProtoCache::from_crate_contexts(&crate_contexts);
|
||||
let proto_cache_str = serde_json::to_string(&proto_cache).unwrap();
|
||||
|
||||
let crate_cache_dir = path_buf_with_component(&cache_dir(), vec![crate_name]);
|
||||
if !crate_cache_dir.as_path().exists() {
|
||||
std::fs::create_dir_all(&crate_cache_dir).unwrap();
|
||||
}
|
||||
|
||||
let protobuf_cache_path = path_string_with_component(&crate_cache_dir, vec!["proto_cache"]);
|
||||
|
||||
match std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.append(false)
|
||||
.truncate(true)
|
||||
.open(&protobuf_cache_path)
|
||||
{
|
||||
Ok(ref mut file) => {
|
||||
file.write_all(proto_cache_str.as_bytes()).unwrap();
|
||||
File::flush(file).unwrap();
|
||||
}
|
||||
Err(_err) => {
|
||||
panic!("Failed to open file: {}", protobuf_cache_path);
|
||||
}
|
||||
}
|
||||
|
||||
crate_contexts
|
||||
}
|
||||
}
|
||||
|
||||
fn write_proto_files(crate_contexts: &[ProtobufCrateContext]) {
|
||||
let file_path_content_map = crate_contexts
|
||||
.iter()
|
||||
.flat_map(|ctx| {
|
||||
ctx.files
|
||||
.iter()
|
||||
.map(|file| {
|
||||
(
|
||||
file.file_path.clone(),
|
||||
ProtoFileSymbol {
|
||||
file_name: file.file_name.clone(),
|
||||
symbols: file.symbols(),
|
||||
},
|
||||
)
|
||||
})
|
||||
.collect::<HashMap<String, ProtoFileSymbol>>()
|
||||
})
|
||||
.collect::<HashMap<String, ProtoFileSymbol>>();
|
||||
|
||||
for context in crate_contexts {
|
||||
let dir = context.protobuf_crate.proto_output_path();
|
||||
context.files.iter().for_each(|file| {
|
||||
// syntax
|
||||
let mut file_content = file.syntax.clone();
|
||||
|
||||
// import
|
||||
file_content.push_str(&gen_import_content(file, &file_path_content_map));
|
||||
|
||||
// content
|
||||
file_content.push_str(&file.content);
|
||||
|
||||
let proto_file = format!("{}.proto", &file.file_name);
|
||||
let proto_file_path = path_string_with_component(&dir, vec![&proto_file]);
|
||||
save_content_to_file_with_diff_prompt(&file_content, proto_file_path.as_ref());
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn gen_import_content(current_file: &ProtoFile, file_path_symbols_map: &HashMap<String, ProtoFileSymbol>) -> String {
|
||||
let mut import_files: Vec<String> = vec![];
|
||||
file_path_symbols_map
|
||||
.iter()
|
||||
.for_each(|(file_path, proto_file_symbols)| {
|
||||
if file_path != ¤t_file.file_path {
|
||||
current_file.ref_types.iter().for_each(|ref_type| {
|
||||
if proto_file_symbols.symbols.contains(ref_type) {
|
||||
let import_file = format!("import \"{}.proto\";", proto_file_symbols.file_name);
|
||||
if !import_files.contains(&import_file) {
|
||||
import_files.push(import_file);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
if import_files.len() == 1 {
|
||||
format!("{}\n", import_files.pop().unwrap())
|
||||
} else {
|
||||
import_files.join("\n")
|
||||
}
|
||||
}
|
||||
|
||||
struct ProtoFileSymbol {
|
||||
file_name: String,
|
||||
symbols: Vec<String>,
|
||||
}
|
||||
|
||||
fn write_rust_crate_mod_file(crate_contexts: &[ProtobufCrateContext]) {
|
||||
for context in crate_contexts {
|
||||
let mod_path = context.protobuf_crate.proto_model_mod_file();
|
||||
match OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.append(false)
|
||||
.truncate(true)
|
||||
.open(&mod_path)
|
||||
{
|
||||
Ok(ref mut file) => {
|
||||
let mut mod_file_content = String::new();
|
||||
|
||||
mod_file_content.push_str("#![cfg_attr(rustfmt, rustfmt::skip)]\n");
|
||||
mod_file_content.push_str("// Auto-generated, do not edit\n");
|
||||
walk_dir(
|
||||
context.protobuf_crate.proto_output_path(),
|
||||
|e| !e.file_type().is_dir(),
|
||||
|_, name| {
|
||||
let c = format!("\nmod {};\npub use {}::*;\n", &name, &name);
|
||||
mod_file_content.push_str(c.as_ref());
|
||||
},
|
||||
);
|
||||
file.write_all(mod_file_content.as_bytes()).unwrap();
|
||||
}
|
||||
Err(err) => {
|
||||
panic!("Failed to open file: {}", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ProtoCache {
|
||||
fn from_crate_contexts(crate_contexts: &[ProtobufCrateContext]) -> Self {
|
||||
let proto_files = crate_contexts
|
||||
.iter()
|
||||
.flat_map(|crate_info| &crate_info.files)
|
||||
.collect::<Vec<&ProtoFile>>();
|
||||
|
||||
let structs: Vec<String> = proto_files.iter().flat_map(|info| info.structs.clone()).collect();
|
||||
let enums: Vec<String> = proto_files.iter().flat_map(|info| info.enums.clone()).collect();
|
||||
Self { structs, enums }
|
||||
}
|
||||
}
|
||||
@ -1,143 +0,0 @@
|
||||
#![allow(dead_code)]
|
||||
use crate::code_gen::flowy_toml::{parse_crate_config_from, CrateConfig, FlowyConfig};
|
||||
use crate::code_gen::util::*;
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
use std::str::FromStr;
|
||||
use walkdir::WalkDir;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ProtobufCrateContext {
|
||||
pub files: Vec<ProtoFile>,
|
||||
pub protobuf_crate: ProtobufCrate,
|
||||
}
|
||||
|
||||
impl ProtobufCrateContext {
|
||||
pub fn from_crate_info(inner: ProtobufCrate, files: Vec<ProtoFile>) -> Self {
|
||||
Self {
|
||||
files,
|
||||
protobuf_crate: inner,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_crate_mod_file(&self) {
|
||||
// mod model;
|
||||
// pub use model::*;
|
||||
let mod_file_path = path_string_with_component(&self.protobuf_crate.protobuf_crate_path(), vec!["mod.rs"]);
|
||||
let mut content = "#![cfg_attr(rustfmt, rustfmt::skip)]\n".to_owned();
|
||||
content.push_str("// Auto-generated, do not edit\n");
|
||||
content.push_str("mod model;\npub use model::*;");
|
||||
match OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.append(false)
|
||||
.truncate(true)
|
||||
.open(&mod_file_path)
|
||||
{
|
||||
Ok(ref mut file) => {
|
||||
file.write_all(content.as_bytes()).unwrap();
|
||||
}
|
||||
Err(err) => {
|
||||
panic!("Failed to open protobuf mod file: {}", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn flutter_mod_dir(&self, root: &str) -> String {
|
||||
let crate_module_dir = format!("{}/{}", root, self.protobuf_crate.crate_folder);
|
||||
crate_module_dir
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn flutter_mod_file(&self, root: &str) -> String {
|
||||
let crate_module_dir = format!("{}/{}/protobuf.dart", root, self.protobuf_crate.crate_folder);
|
||||
crate_module_dir
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ProtobufCrate {
|
||||
pub crate_folder: String,
|
||||
pub crate_path: PathBuf,
|
||||
flowy_config: FlowyConfig,
|
||||
}
|
||||
|
||||
impl ProtobufCrate {
|
||||
pub fn from_config(config: CrateConfig) -> Self {
|
||||
ProtobufCrate {
|
||||
crate_path: config.crate_path,
|
||||
crate_folder: config.crate_folder,
|
||||
flowy_config: config.flowy_config,
|
||||
}
|
||||
}
|
||||
|
||||
// Return the file paths for each rust file that used to generate the proto file.
|
||||
pub fn proto_input_paths(&self) -> Vec<PathBuf> {
|
||||
self.flowy_config
|
||||
.proto_input
|
||||
.iter()
|
||||
.map(|name| path_buf_with_component(&self.crate_path, vec![name]))
|
||||
.collect::<Vec<PathBuf>>()
|
||||
}
|
||||
|
||||
// The protobuf_crate_path is used to store the generated protobuf Rust structures.
|
||||
pub fn protobuf_crate_path(&self) -> PathBuf {
|
||||
let crate_path = PathBuf::from(&self.flowy_config.protobuf_crate_path);
|
||||
create_dir_if_not_exist(&crate_path);
|
||||
crate_path
|
||||
}
|
||||
|
||||
// The proto_output_path is used to store the proto files
|
||||
pub fn proto_output_path(&self) -> PathBuf {
|
||||
let output_dir = PathBuf::from(&self.flowy_config.proto_output);
|
||||
create_dir_if_not_exist(&output_dir);
|
||||
output_dir
|
||||
}
|
||||
|
||||
pub fn proto_model_mod_file(&self) -> String {
|
||||
path_string_with_component(&self.protobuf_crate_path(), vec!["mod.rs"])
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ProtoFile {
|
||||
pub file_path: String,
|
||||
pub file_name: String,
|
||||
pub structs: Vec<String>,
|
||||
// store the type of current file using
|
||||
pub ref_types: Vec<String>,
|
||||
|
||||
pub enums: Vec<String>,
|
||||
// proto syntax. "proto3" or "proto2"
|
||||
pub syntax: String,
|
||||
|
||||
// proto message content
|
||||
pub content: String,
|
||||
}
|
||||
|
||||
impl ProtoFile {
|
||||
pub fn symbols(&self) -> Vec<String> {
|
||||
let mut symbols = self.structs.clone();
|
||||
let mut enum_symbols = self.enums.clone();
|
||||
symbols.append(&mut enum_symbols);
|
||||
symbols
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_crate_info_from_path(roots: Vec<String>) -> Vec<ProtobufCrate> {
|
||||
let mut protobuf_crates: Vec<ProtobufCrate> = vec![];
|
||||
roots.iter().for_each(|root| {
|
||||
let crates = WalkDir::new(root)
|
||||
.into_iter()
|
||||
.filter_entry(|e| !is_hidden(e))
|
||||
.filter_map(|e| e.ok())
|
||||
.filter(is_crate_dir)
|
||||
.flat_map(|e| parse_crate_config_from(&e))
|
||||
.map(ProtobufCrate::from_config)
|
||||
.collect::<Vec<ProtobufCrate>>();
|
||||
protobuf_crates.extend(crates);
|
||||
});
|
||||
protobuf_crates
|
||||
}
|
||||
@ -1,35 +0,0 @@
|
||||
use crate::code_gen::util::get_tera;
|
||||
use itertools::Itertools;
|
||||
use tera::Context;
|
||||
|
||||
pub struct ProtobufDeriveMeta {
|
||||
context: Context,
|
||||
structs: Vec<String>,
|
||||
enums: Vec<String>,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl ProtobufDeriveMeta {
|
||||
pub fn new(structs: Vec<String>, enums: Vec<String>) -> Self {
|
||||
let enums: Vec<_> = enums.into_iter().unique().collect();
|
||||
ProtobufDeriveMeta {
|
||||
context: Context::new(),
|
||||
structs,
|
||||
enums,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render(&mut self) -> Option<String> {
|
||||
self.context.insert("names", &self.structs);
|
||||
self.context.insert("enums", &self.enums);
|
||||
|
||||
let tera = get_tera("protobuf_file/template/derive_meta");
|
||||
match tera.render("derive_meta.tera", &self.context) {
|
||||
Ok(r) => Some(r),
|
||||
Err(e) => {
|
||||
log::error!("{:?}", e);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,45 +0,0 @@
|
||||
#![cfg_attr(rustfmt, rustfmt::skip)]
|
||||
pub enum TypeCategory {
|
||||
Array,
|
||||
Map,
|
||||
Str,
|
||||
Protobuf,
|
||||
Bytes,
|
||||
Enum,
|
||||
Opt,
|
||||
Primitive,
|
||||
}
|
||||
// auto generate, do not edit
|
||||
pub fn category_from_str(type_str: &str) -> TypeCategory {
|
||||
match type_str {
|
||||
"Vec" => TypeCategory::Array,
|
||||
"HashMap" => TypeCategory::Map,
|
||||
"u8" => TypeCategory::Bytes,
|
||||
"String" => TypeCategory::Str,
|
||||
{%- for name in names -%}
|
||||
{%- if loop.first %}
|
||||
"{{ name }}"
|
||||
{%- else %}
|
||||
| "{{ name }}"
|
||||
{%- endif -%}
|
||||
{%- if loop.last %}
|
||||
=> TypeCategory::Protobuf,
|
||||
{%- endif %}
|
||||
|
||||
{%- endfor %}
|
||||
|
||||
{%- for enum in enums -%}
|
||||
{%- if loop.first %}
|
||||
"{{ enum }}"
|
||||
{%- else %}
|
||||
| "{{ enum }}"
|
||||
{%- endif -%}
|
||||
{%- if loop.last %}
|
||||
=> TypeCategory::Enum,
|
||||
{%- endif %}
|
||||
{%- endfor %}
|
||||
|
||||
"Option" => TypeCategory::Opt,
|
||||
_ => TypeCategory::Primitive,
|
||||
}
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
#![allow(clippy::module_inception)]
|
||||
mod derive_meta;
|
||||
|
||||
pub use derive_meta::*;
|
||||
@ -1,5 +0,0 @@
|
||||
mod derive_meta;
|
||||
mod proto_file;
|
||||
|
||||
pub use derive_meta::*;
|
||||
pub use proto_file::*;
|
||||
@ -1,5 +0,0 @@
|
||||
enum {{ enum_name }} {
|
||||
{%- for item in items %}
|
||||
{{ item }}
|
||||
{%- endfor %}
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
use crate::code_gen::protobuf_file::ast::FlowyEnum;
|
||||
use crate::code_gen::util::get_tera;
|
||||
use tera::Context;
|
||||
|
||||
pub struct EnumTemplate {
|
||||
context: Context,
|
||||
items: Vec<String>,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl EnumTemplate {
|
||||
pub fn new() -> Self {
|
||||
EnumTemplate {
|
||||
context: Context::new(),
|
||||
items: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_message_enum(&mut self, flowy_enum: &FlowyEnum) {
|
||||
self.context.insert("enum_name", &flowy_enum.name);
|
||||
flowy_enum.attrs.iter().for_each(|item| {
|
||||
self.items
|
||||
.push(format!("{} = {};", item.attrs.enum_item_name, item.attrs.value))
|
||||
})
|
||||
}
|
||||
|
||||
pub fn render(&mut self) -> Option<String> {
|
||||
self.context.insert("items", &self.items);
|
||||
let tera = get_tera("protobuf_file/template/proto_file");
|
||||
match tera.render("enum.tera", &self.context) {
|
||||
Ok(r) => Some(r),
|
||||
Err(e) => {
|
||||
log::error!("{:?}", e);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,5 +0,0 @@
|
||||
mod enum_template;
|
||||
mod struct_template;
|
||||
|
||||
pub use enum_template::*;
|
||||
pub use struct_template::*;
|
||||
@ -1,5 +0,0 @@
|
||||
message {{ struct_name }} {
|
||||
{%- for field in fields %}
|
||||
{{ field }}
|
||||
{%- endfor %}
|
||||
}
|
||||
@ -1,106 +0,0 @@
|
||||
use crate::code_gen::util::get_tera;
|
||||
use flowy_ast::*;
|
||||
use phf::phf_map;
|
||||
use tera::Context;
|
||||
|
||||
// Protobuf data type : https://developers.google.com/protocol-buffers/docs/proto3
|
||||
pub static RUST_TYPE_MAP: phf::Map<&'static str, &'static str> = phf_map! {
|
||||
"String" => "string",
|
||||
"i64" => "int64",
|
||||
"i32" => "int32",
|
||||
"u64" => "uint64",
|
||||
"u32" => "uint32",
|
||||
"Vec" => "repeated",
|
||||
"f64" => "double",
|
||||
"HashMap" => "map",
|
||||
};
|
||||
|
||||
pub struct StructTemplate {
|
||||
context: Context,
|
||||
fields: Vec<String>,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl StructTemplate {
|
||||
pub fn new() -> Self {
|
||||
StructTemplate {
|
||||
context: Context::new(),
|
||||
fields: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_message_struct_name(&mut self, name: &str) {
|
||||
self.context.insert("struct_name", name);
|
||||
}
|
||||
|
||||
pub fn set_field(&mut self, field: &ASTField) {
|
||||
// {{ field_type }} {{ field_name }} = {{index}};
|
||||
let name = field.name().unwrap().to_string();
|
||||
let index = field.attrs.pb_index().unwrap();
|
||||
|
||||
let ty: &str = &field.ty_as_str();
|
||||
let mut mapped_ty: &str = ty;
|
||||
|
||||
if RUST_TYPE_MAP.contains_key(ty) {
|
||||
mapped_ty = RUST_TYPE_MAP[ty];
|
||||
}
|
||||
|
||||
if let Some(ref category) = field.bracket_category {
|
||||
match category {
|
||||
BracketCategory::Opt => match &field.bracket_inner_ty {
|
||||
None => {}
|
||||
Some(inner_ty) => match inner_ty.to_string().as_str() {
|
||||
//TODO: support hashmap or something else wrapped by Option
|
||||
"Vec" => {
|
||||
self.fields
|
||||
.push(format!("oneof one_of_{} {{ bytes {} = {}; }};", name, name, index));
|
||||
}
|
||||
_ => {
|
||||
self.fields.push(format!(
|
||||
"oneof one_of_{} {{ {} {} = {}; }};",
|
||||
name, mapped_ty, name, index
|
||||
));
|
||||
}
|
||||
},
|
||||
},
|
||||
BracketCategory::Map((k, v)) => {
|
||||
let key: &str = k;
|
||||
let value: &str = v;
|
||||
self.fields.push(format!(
|
||||
// map<string, string> attrs = 1;
|
||||
"map<{}, {}> {} = {};",
|
||||
RUST_TYPE_MAP.get(key).unwrap_or(&key),
|
||||
RUST_TYPE_MAP.get(value).unwrap_or(&value),
|
||||
name,
|
||||
index
|
||||
));
|
||||
}
|
||||
BracketCategory::Vec => {
|
||||
let bracket_ty: &str = &field.bracket_ty.as_ref().unwrap().to_string();
|
||||
// Vec<u8>
|
||||
if mapped_ty == "u8" && bracket_ty == "Vec" {
|
||||
self.fields.push(format!("bytes {} = {};", name, index))
|
||||
} else {
|
||||
self.fields.push(format!(
|
||||
"{} {} {} = {};",
|
||||
RUST_TYPE_MAP[bracket_ty], mapped_ty, name, index
|
||||
))
|
||||
}
|
||||
}
|
||||
BracketCategory::Other => self.fields.push(format!("{} {} = {};", mapped_ty, name, index)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render(&mut self) -> Option<String> {
|
||||
self.context.insert("fields", &self.fields);
|
||||
let tera = get_tera("protobuf_file/template/proto_file");
|
||||
match tera.render("struct.tera", &self.context) {
|
||||
Ok(r) => Some(r),
|
||||
Err(e) => {
|
||||
log::error!("{:?}", e);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,174 +0,0 @@
|
||||
use console::Style;
|
||||
use similar::{ChangeTag, TextDiff};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::str::FromStr;
|
||||
use std::{
|
||||
fs::{File, OpenOptions},
|
||||
io::{Read, Write},
|
||||
};
|
||||
use tera::Tera;
|
||||
use walkdir::WalkDir;
|
||||
|
||||
pub fn read_file(path: &str) -> Option<String> {
|
||||
let mut file = File::open(path).unwrap_or_else(|_| panic!("Unable to open file at {}", path));
|
||||
let mut content = String::new();
|
||||
match file.read_to_string(&mut content) {
|
||||
Ok(_) => Some(content),
|
||||
Err(e) => {
|
||||
log::error!("{}, with error: {:?}", path, e);
|
||||
Some("".to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save_content_to_file_with_diff_prompt(content: &str, output_file: &str) {
|
||||
if Path::new(output_file).exists() {
|
||||
let old_content = read_file(output_file).unwrap();
|
||||
let new_content = content.to_owned();
|
||||
let write_to_file = || match OpenOptions::new()
|
||||
.create(true)
|
||||
.write(true)
|
||||
.append(false)
|
||||
.truncate(true)
|
||||
.open(output_file)
|
||||
{
|
||||
Ok(ref mut file) => {
|
||||
file.write_all(new_content.as_bytes()).unwrap();
|
||||
}
|
||||
Err(err) => {
|
||||
panic!("Failed to open log file: {}", err);
|
||||
}
|
||||
};
|
||||
if new_content != old_content {
|
||||
print_diff(old_content, new_content.clone());
|
||||
write_to_file()
|
||||
}
|
||||
} else {
|
||||
match OpenOptions::new().create(true).write(true).open(output_file) {
|
||||
Ok(ref mut file) => file.write_all(content.as_bytes()).unwrap(),
|
||||
Err(err) => panic!("Open or create to {} fail: {}", output_file, err),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn print_diff(old_content: String, new_content: String) {
|
||||
let diff = TextDiff::from_lines(&old_content, &new_content);
|
||||
for op in diff.ops() {
|
||||
for change in diff.iter_changes(op) {
|
||||
let (sign, style) = match change.tag() {
|
||||
ChangeTag::Delete => ("-", Style::new().red()),
|
||||
ChangeTag::Insert => ("+", Style::new().green()),
|
||||
ChangeTag::Equal => (" ", Style::new()),
|
||||
};
|
||||
|
||||
match change.tag() {
|
||||
ChangeTag::Delete => {
|
||||
print!("{}{}", style.apply_to(sign).bold(), style.apply_to(change));
|
||||
}
|
||||
ChangeTag::Insert => {
|
||||
print!("{}{}", style.apply_to(sign).bold(), style.apply_to(change));
|
||||
}
|
||||
ChangeTag::Equal => {}
|
||||
};
|
||||
}
|
||||
println!("---------------------------------------------------");
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn is_crate_dir(e: &walkdir::DirEntry) -> bool {
|
||||
let cargo = e.path().file_stem().unwrap().to_str().unwrap().to_string();
|
||||
cargo == *"Cargo"
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn is_proto_file(e: &walkdir::DirEntry) -> bool {
|
||||
if e.path().extension().is_none() {
|
||||
return false;
|
||||
}
|
||||
let ext = e.path().extension().unwrap().to_str().unwrap().to_string();
|
||||
ext == *"proto"
|
||||
}
|
||||
|
||||
pub fn is_hidden(entry: &walkdir::DirEntry) -> bool {
|
||||
entry.file_name().to_str().map(|s| s.starts_with('.')).unwrap_or(false)
|
||||
}
|
||||
|
||||
pub fn create_dir_if_not_exist(dir: &Path) {
|
||||
if !dir.exists() {
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn path_string_with_component(path: &Path, components: Vec<&str>) -> String {
|
||||
path_buf_with_component(path, components).to_str().unwrap().to_string()
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn path_buf_with_component(path: &Path, components: Vec<&str>) -> PathBuf {
|
||||
let mut path_buf = path.to_path_buf();
|
||||
for component in components {
|
||||
path_buf.push(component);
|
||||
}
|
||||
path_buf
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn walk_dir<P: AsRef<Path>, F1, F2>(dir: P, filter: F2, mut path_and_name: F1)
|
||||
where
|
||||
F1: FnMut(String, String),
|
||||
F2: Fn(&walkdir::DirEntry) -> bool,
|
||||
{
|
||||
for (path, name) in WalkDir::new(dir)
|
||||
.into_iter()
|
||||
.filter_map(|e| e.ok())
|
||||
.filter(|e| filter(e))
|
||||
.map(|e| {
|
||||
(
|
||||
e.path().to_str().unwrap().to_string(),
|
||||
e.path().file_stem().unwrap().to_str().unwrap().to_string(),
|
||||
)
|
||||
})
|
||||
{
|
||||
path_and_name(path, name);
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn suffix_relative_to_path(path: &str, base: &str) -> String {
|
||||
let base = Path::new(base);
|
||||
let path = Path::new(path);
|
||||
path.strip_prefix(base).unwrap().to_str().unwrap().to_owned()
|
||||
}
|
||||
|
||||
pub fn get_tera(directory: &str) -> Tera {
|
||||
let mut root = format!("{}/src/code_gen/", env!("CARGO_MANIFEST_DIR"));
|
||||
root.push_str(directory);
|
||||
|
||||
let root_absolute_path = match std::fs::canonicalize(&root) {
|
||||
Ok(p) => p.as_path().display().to_string(),
|
||||
Err(e) => {
|
||||
panic!("❌ Canonicalize file path {} failed {:?}", root, e);
|
||||
}
|
||||
};
|
||||
|
||||
let mut template_path = format!("{}/**/*.tera", root_absolute_path);
|
||||
if cfg!(windows) {
|
||||
// remove "\\?\" prefix on windows
|
||||
template_path = format!("{}/**/*.tera", &root_absolute_path[4..]);
|
||||
}
|
||||
|
||||
match Tera::new(template_path.as_ref()) {
|
||||
Ok(t) => t,
|
||||
Err(e) => {
|
||||
log::error!("Parsing error(s): {}", e);
|
||||
::std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cache_dir() -> PathBuf {
|
||||
let mut path_buf = PathBuf::from_str(env!("CARGO_MANIFEST_DIR")).unwrap();
|
||||
path_buf.push(".cache");
|
||||
path_buf
|
||||
}
|
||||
@ -1,4 +1,3 @@
|
||||
pub mod code_gen;
|
||||
pub mod future;
|
||||
pub mod ref_map;
|
||||
pub mod retry;
|
||||
|
||||
Reference in New Issue
Block a user