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 heck::ToSnakeCase;
use serde::{Deserialize, Serialize};
use std::io;
use std::sync::Mutex;
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct DiFactroy {
pub notShowExist: bool,
pub template: String,
pub template_suite: String,
pub structs: Vec<didto::StructInfo>,
}
fn clone_mutex_string(m: &Mutex<String>) -> Mutex<String> {
Mutex::new(m.lock().unwrap().clone())
}
fn clone_mutex_vec(m: &Vec<didto::StructInfo>) -> Vec<didto::StructInfo> {
m.clone()
}
impl BaseEntitySingle for DiFactroy {}
impl DiFactroy {
pub fn new() -> DiFactroy {
DiFactroy {
..Default::default()
}
}
pub fn new_mutex() -> Mutex<DiFactroy> {
Mutex::new(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(&mut 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 = results;
}
pub fn fill_template(&mut self) {
if self.template.len() > 0 {
return;
}
let template = parse_template::ParseTemplate::parse_template_file();
self.template = String::from(template);
ru_log::info2("fill_template:\r\n", self.template.as_str());
}
pub fn fill_template_suite(&mut self) {
if self.template_suite.len() > 0 {
return;
}
let template = parse_template::ParseTemplate::parse_template_suite();
self.template_suite = template;
ru_log::info2("template_suite:\r\n", self.template_suite.as_str());
}
pub fn build_init(&self, stru: &didto::StructInfo) -> String {
let mut template_str = self.template.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().unwrap().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()
.lock()
.unwrap()
.read_clone()
.clone();
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 build_suite(&self, stru: &StructInfo) -> String {
self.template_suite.clone()
}
pub fn create_suite(&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(&mut 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.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(&mut 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.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(&mut self, struName: &str) {
self.make_di_one_force("./src", struName, false);
}
pub fn make_di_one_dir(&mut self, dir: &str, struName: &str) {
self.make_di_one_force(dir, struName, false);
}
pub fn make_di_pkg(&mut self, pkgName: &str) {
println!("pkgName: {}", pkgName);
self.make_di_all("./src");
}
pub fn make_di(&mut self) {
self.make_di_all("./src");
}
pub fn make_di_all(&mut self, dir: &str) {
self.make_di_if_force(dir, false)
}
pub fn make_di_force(&mut self, dir: &str) {
self.make_di_if_force(dir, true);
}
pub fn list_di_all(&mut self, dir: &str) {
let _retret = self.parse_all_files(dir);
for stru in self.structs.iter() {
ru_log::info2("struct name:===", stru.structName.as_str());
}
}
pub fn list_di(&mut self) {
self.list_di_all("./src");
}
pub fn list_di_pkg(&mut 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 edit_mod_suite(&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_suite(&content);
file_utils::write_file(mod_file.as_str(), content.as_str())
}
pub fn get_self(&self) -> &Self {
return self;
}
pub fn get_structs(&mut self) -> Vec<didto::StructInfo> {
return self.structs.clone();
}
pub fn get_template(&self) -> String {
return self.template.clone();
}
pub fn make_di_force_one(&mut self, struName: &str) {
self.make_di_one_force("./src", struName, true);
}
pub fn make_suite(&mut self, struName: &str) {
self.make_di_suite("./src", struName)
}
pub fn make_di_suite(&mut self, dir: &str, struName: &str) {
self.make_di_one_suite(dir, struName, false)
}
pub fn make_di_suites(&mut self, dir: &str) {
self.make_di_all_suite(dir, false)
}
pub fn make_suites(&mut self) {
self.make_di_suites("./src")
}
pub fn make_di_one_suite(&mut self, dir: &str, struName: &str, if_force: bool) {
self.fill_template_suite();
ru_log::info2("make_di_one_suite if_force:", if_force.to_string().as_str());
let _retret = self.parse_all_files(dir);
for mut stru in self.structs.iter() {
if !stru.structName.as_str().eq(struName) {
continue;
}
if stru.existSuiteFile && !if_force {
ru_log::info2(
"struct already existSuiteFile gen! structName: ",
stru.structName.as_str(),
);
continue;
}
let suite_file = stru.build_struct_suite_pathfile();
ru_log::info2("suite_file:===", suite_file.as_str());
let content = self.build_suite(&stru);
let ret = self.create_suite(&suite_file, content);
if ret.is_err() {
continue;
}
let mut stru = stru.clone();
let _ret = self.edit_mod_suite(&mut stru);
break;
}
}
pub fn make_di_all_suite(&mut self, dir: &str, if_force: bool) {
self.fill_template_suite();
let _retret = self.parse_all_files(dir);
for stru in self.structs.iter() {
if stru.existSuiteFile && !if_force {
ru_log::info2(
"struct already exist=> structName: ",
stru.structName.as_str(),
);
continue;
}
let suite_file = stru.build_struct_suite_pathfile();
let content = self.build_suite(&stru);
let ret = self.create_suite(&suite_file, content);
if ret.is_err() {
continue;
}
let _ret = self.edit_mod_suite(&mut stru.clone());
}
}
}