use crate::rubase::rutils::fileutils;
use crate::rubase::{BaseEntity, ruentity, rutils};
use crate::rucfg;
use crate::rudi::didto;
use crate::rudi::difactroy::ruast;
use crate::rudi::ditemplate::parsetemplate;
use crate::rulog::rulog;
use serde::{Deserialize, Serialize};
use std::cell::RefCell;
use std::io;
use std::sync::{Arc, Mutex};
#[derive(Debug, Default, Serialize, Deserialize)]
pub struct DiFactroy {
pub notShowExist: bool,
pub template: Mutex<String>,
pub structs: Mutex<Vec<didto::StructInfo>>,
}
impl ruentity::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::structinfo::StructInfo {
let ret = fileutils::read_file(filePath.as_str());
let ifSingle = false;
for line in ret.unwrap().as_str().split("\n") {}
didto::structinfo::StructInfo::default("".into(), "".into(), filePath, true)
}
pub fn CreateInit() -> String {
return String::new();
}
pub fn CreateInitForce() -> String {
return String::new();
}
pub fn list_all_files(dir: &str) -> Vec<String> {
fileutils::list_all_files_rs(dir)
}
pub fn read_file(file_name: &str) -> Result<String, io::Error> {
fileutils::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 fileutils::list_all_files_rs(dir) {
let content = fileutils::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 mut template = parsetemplate::ParseTemplate::parse_template_file();
*self.template.lock().unwrap() = template;
rulog::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_lowercase().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_ruconfig().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");
}
rulog::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 = fileutils::write_file(initFile, content.as_str());
rulog::info2("create_init:===", initFile);
ret
}
pub fn make_di_if_force(&self, dir: &str, if_force: bool) {
self.fill_template();
rulog::info2("make_di_all if_force:", if_force.to_string().as_str());
let mut ret = self.parse_all_files(dir);
for stru in self.structs.lock().unwrap().iter() {
if stru.existIniFile && !if_force {
rulog::info2(
"struct already existIniFile gen! structName: ",
stru.structName.as_str(),
);
continue;
}
if stru.existIniFile && if_force {
rulog::info2(
"struct already existIniFile gegen force! : ",
stru.structName.as_str(),
);
}
rulog::info2("struct file:===", stru.to_json().as_str());
let ini_pathfile = stru.build_struct_ini_pathfile();
rulog::info2("ini_pathfile:===", ini_pathfile.as_str());
let content = self.build_init(stru);
self.create_init(&ini_pathfile, content);
let mut stru = stru.clone();
self.edit_mod(&mut stru);
}
}
pub fn make_di_one_force(&self, dir: &str, struName: &str, if_force: bool) {
self.fill_template();
rulog::info2("make_di_all if_force:", if_force.to_string().as_str());
let mut ret = self.parse_all_files(dir);
for stru in self.structs.lock().unwrap().iter() {
if self.notShowExist && stru.existIniFile && !if_force {
continue;
}
if !stru.structName.as_str().eq(struName) {
continue;
}
let ini_pathfile = stru.build_struct_ini_pathfile();
rulog::info2("ini_pathfile:===", ini_pathfile.as_str());
let content = self.build_init(stru);
self.create_init(&ini_pathfile, content);
let mut stru = stru.clone();
self.edit_mod(&mut stru);
break;
}
}
pub fn make_di_one(&self, dir: &str, struName: &str) {
self.make_di_one_force(dir, struName, false);
}
pub fn make_di_pkg(&self, pkgName: &str) {
self.make_di_all( "./src");
}
pub fn make_di(&self ) {
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 ret = self.parse_all_files(dir);
for stru in self.structs.lock().unwrap().iter() {
rulog::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) {
self.list_di_all("./src");
}
pub fn unmake_di_one(&self, dir: &str, struName: &str) {
}
pub fn edit_mod(&self, stru: &mut didto::StructInfo) {
let mod_file = stru.build_struct_mod_file();
let content = fileutils::read_file(mod_file.as_str()).unwrap();
rulog::info2("mod_file:===", mod_file.as_str());
let content = stru.parse_mod_content(&content);
fileutils::write_file(mod_file.as_str(), content.as_str());
}
}