use crate::rubase::rutils::file_utils;
use crate::rubase::{BaseEntity, BaseEntitySingle, rutils};
use crate::rucfg;
use crate::rudi::didto;
use crate::rudi::didto::StructInfo;
use crate::rudi::difactroy::ruast;
use crate::rudi::ditemplate::parse_template;
use crate::rulog::ru_log;
use serde::{Deserialize, Serialize};
use std::io;
use std::sync::Mutex;
use heck::ToSnakeCase;
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct DiFactroy {
pub notShowExist: bool,
pub template: Mutex<String>,
pub structs: Mutex<Vec<didto::StructInfo>>,
}
fn clone_mutex_string(m: &Mutex<String>) -> Mutex<String> {
Mutex::new(m.lock().unwrap().clone())
}
fn clone_mutex_vec(m: &Mutex<Vec<didto::StructInfo>>) -> Mutex<Vec<didto::StructInfo>> {
Mutex::new(m.lock().unwrap().clone())
}
impl BaseEntitySingle for DiFactroy {}
impl DiFactroy {
pub fn new() -> DiFactroy {
DiFactroy {
..Default::default()
}
}
pub fn FindBasePkg() -> String {
return String::new();
}
pub fn FindFileStruct(filePath: String) -> didto::struct_info::StructInfo {
let ret = file_utils::read_file(filePath.as_str());
let _ifSingle = false;
for _line in ret.unwrap().as_str().split("\n") {}
StructInfo::default()
}
pub fn CreateInit() -> String {
return String::new();
}
pub fn CreateInitForce() -> String {
return String::new();
}
pub fn list_all_files(dir: &str) -> Vec<String> {
file_utils::list_rs_files(dir)
}
pub fn read_file(file_name: &str) -> Result<String, io::Error> {
file_utils::read_file(file_name)
}
pub fn parse_all_files(&self, dir: &str) {
let ua = ruast::RuAst::new();
let mut results = Vec::<didto::StructInfo>::new();
for f in file_utils::list_rs_files(dir) {
let content = file_utils::read_file(f.as_str()).unwrap();
let v = ua.find_entity_all(f.as_str(), content.as_str());
results.extend(v);
}
*self.structs.lock().unwrap() = results;
}
pub fn fill_template(&self) {
if self.template.lock().unwrap().len() > 0 {
return;
}
let template = parse_template::ParseTemplate::parse_template_file();
*self.template.lock().unwrap() = template;
ru_log::info2("fill_template:\r\n", self.template.lock().unwrap().as_str());
}
pub fn build_init(&self, stru: &didto::StructInfo) -> String {
let mut template_str = self.template.lock().unwrap().clone();
if stru.ifSingle {
template_str = template_str.replace("{{register_singleton}}", "register_singleton");
} else {
template_str = template_str.replace("{{register_singleton}}", "register");
}
template_str = template_str.replace("{{StructInfo}}", stru.to_json().as_str());
template_str = template_str.replace("{{RuSingle}}", stru.structName.as_str());
template_str =
template_str.replace("{{rusingle}}", stru.structName.to_snake_case().as_str());
template_str = template_str.replace(
"｛{SINGLE_BEAN_NAME}",
stru.build_single_bean_name().as_str(),
);
template_str = template_str.replace("{{StructPkg}}", stru.structPkg.as_str());
let cfg = rucfg::find_bean_ru_config().unwrap().read();
template_str = template_str.replace("{{Corp}}", cfg.software.corp.as_str());
template_str = template_str.replace("{{Author}}", cfg.software.author.as_str());
template_str = template_str.replace("{{Now}}", rutils::local_now2str().as_str());
if stru.ifDefault {
template_str = template_str.replace("::new", "::default");
}
ru_log::info2("build_init template_str:\r\n", template_str.as_str());
template_str
}
pub fn create_init(&self, initFile: &str, content: String) -> Result<String, io::Error> {
let ret = file_utils::write_file(initFile, content.as_str());
ru_log::info2("create_init:===", initFile);
ret
}
pub fn make_di_if_force(&self, dir: &str, if_force: bool) {
self.fill_template();
ru_log::info2("make_di_if_force:", if_force.to_string() );
let _retret = self.parse_all_files(dir);
for stru in self.structs.lock().unwrap().iter() {
if stru.existIniFile && !if_force {
ru_log::info2(
"struct already existIniFile gen! structName: ",
stru.structName.as_str(),
);
continue;
}
if stru.existIniFile && if_force {
ru_log::info2(
"struct already existIniFile gegen force! : ",
stru.structName.as_str(),
);
}
let ini_pathfile = stru.build_struct_ini_pathfile();
let content = self.build_init(stru);
let ret = self.create_init(&ini_pathfile, content);
if ret.is_err() {
continue;
}
let mut stru = stru.clone();
let ret = self.edit_mod(&mut stru);
if ret.is_err() {
println!("{}", ret.err().unwrap());
}
}
}
pub fn make_di_one_force(&self, dir: &str, struName: &str, if_force: bool) {
self.fill_template();
ru_log::info2("make_di_all if_force:", if_force.to_string().as_str());
let _retret = self.parse_all_files(dir);
for stru in self.structs.lock().unwrap().iter() {
if !stru.structName.as_str().eq(struName) {
continue;
}
if stru.existIniFile && !if_force {
ru_log::info2(
"struct already existIniFile gen! structName: ",
stru.structName.as_str(),
);
continue;
}
let ini_pathfile = stru.build_struct_ini_pathfile();
ru_log::info2("ini_pathfile:===", ini_pathfile.as_str());
let content = self.build_init(stru);
let ret = self.create_init(&ini_pathfile, content);
if ret.is_err() {
continue;
}
let mut stru = stru.clone();
let _ret = self.edit_mod(&mut stru);
break;
}
}
pub fn make_di_one(&self, struName: &str) {
self.make_di_one_force("./src", struName, false);
}
pub fn make_di_one_dir(&self, dir: &str, struName: &str) {
self.make_di_one_force(dir, struName, false);
}
pub fn make_di_pkg(&self, pkgName: &str) {
println!("pkgName: {}", pkgName);
self.make_di_all("./src");
}
pub fn make_di(&self) {
println!(
"make_di_all:*** current_dir *** {}",
file_utils::current_dir().unwrap().to_str().unwrap()
);
ru_log::info2(
"current_dir:",
file_utils::current_dir().unwrap().to_str().unwrap(),
);
self.make_di_all("./src");
}
pub fn make_di_all(&self, dir: &str) {
self.make_di_if_force(dir, false);
}
pub fn make_di_force(&self, dir: &str) {
self.make_di_if_force(dir, true);
}
pub fn list_di_all(&self, dir: &str) {
let _retret = self.parse_all_files(dir);
for stru in self.structs.lock().unwrap().iter() {
ru_log::info2("struct name:===", stru.structName.as_str());
}
}
pub fn list_di(&self) {
self.list_di_all("./src");
}
pub fn list_di_pkg(&self, pkgName: &str) {
println!("pkgName: {}", pkgName);
self.list_di_all("./src");
}
pub fn edit_mod(&self, stru: &mut didto::StructInfo) -> Result<String, io::Error> {
let mod_file = stru.build_struct_mod_file();
let content = file_utils::read_file(mod_file.as_str()).unwrap();
ru_log::info2("mod_file:===", mod_file.as_str());
let content = stru.parse_mod_content(&content);
file_utils::write_file(mod_file.as_str(), content.as_str())
}
pub fn get_self(&self) -> &Self {
return self;
}
pub fn get_structs(&self) -> Vec<didto::StructInfo> {
return self.structs.lock().unwrap().clone();
}
pub fn get_template(&self) -> String {
return self.template.lock().unwrap() .to_string();
}
pub fn make_di_force_one(&self, struName: &str ) {
self.make_di_one_force("./src", struName, true);
}}