You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 lines
3.3 KiB
Rust
175 lines
3.3 KiB
Rust
use crate::igloo::{Igloo, IglooEnvInfo, IglooErrType};
|
|
use crate::igloo_manifest::IglooManifest;
|
|
use std::collections::HashMap;
|
|
// New Project
|
|
// --- Verify location
|
|
// --- Populate base folders
|
|
// --- create .igloo/<PrjName>.toml
|
|
// --- Create default target in ./igloo<PrjName>.toml
|
|
// --- Read Default Targets manifest toml
|
|
// --- generate projects core manifest toml
|
|
// --- Spawn user manifest config
|
|
pub struct IglooPrj
|
|
{
|
|
name: String,
|
|
target_bank: Vec<IglooTarget>,
|
|
env_info: IglooEnvInfo,
|
|
}
|
|
|
|
pub struct IglooTarget
|
|
{
|
|
name: String,
|
|
make_manifest: HashMap<String, config::Value>,
|
|
target_manifest: HashMap<String, config::Value>,
|
|
}
|
|
|
|
impl IglooPrj
|
|
{
|
|
pub fn default() -> IglooPrj
|
|
{
|
|
IglooPrj
|
|
{
|
|
name: String::from(""),
|
|
target_bank: Vec::default(),
|
|
env_info: IglooEnvInfo::info(),
|
|
}
|
|
}
|
|
|
|
pub fn new(inst: &Igloo, nameIn: &str, targetIn: &str)
|
|
-> Result<IglooPrj, IglooErrType>
|
|
{
|
|
let mut res_err = IglooErrType::IGLOO_ERR_NONE;
|
|
loop
|
|
{
|
|
if String::from(nameIn).is_empty()
|
|
{
|
|
res_err = IglooErrType::IGLOO_INVALID_PROJECT_NAME;
|
|
break;
|
|
}
|
|
|
|
|
|
break; }
|
|
|
|
if res_err != IglooErrType::IGLOO_ERR_NONE
|
|
{
|
|
return Err(res_err)
|
|
}
|
|
match IglooManifest::target_exists(inst, targetIn)
|
|
{
|
|
Ok(v) =>
|
|
{
|
|
if v
|
|
{
|
|
println!("Verified target exists {}", nameIn);
|
|
}
|
|
else
|
|
{
|
|
println!("Couldn't verify target exists {}", nameIn);
|
|
return Err(IglooErrType::IGLOO_INVALID_TARGET)
|
|
}
|
|
}
|
|
Err(e) =>
|
|
{
|
|
return Err(e)
|
|
}
|
|
}
|
|
|
|
|
|
Ok(IglooPrj
|
|
{
|
|
name: String::from(nameIn),
|
|
target_bank: Vec::new(),
|
|
env_info: IglooEnvInfo::info(),
|
|
})
|
|
}
|
|
|
|
pub fn populate(&self) -> IglooErrType
|
|
{
|
|
// Create new directory
|
|
let mut active_dir = IglooEnvInfo::info().cwd;
|
|
//println!("Active Directory: {:?}", active_dir.display());
|
|
println!("NAME: {}", self.name);
|
|
active_dir.push(&self.name);
|
|
match std::fs::create_dir(&active_dir)
|
|
{
|
|
Err(e) => println!("{:?}", e),
|
|
_ => (),
|
|
}
|
|
//println!("Active Directory: {:?}", active_dir.display());
|
|
println!("Creating .igloo dir...");
|
|
match std::fs::create_dir(
|
|
std::path::Path::new(&active_dir)
|
|
.join(".igloo"))
|
|
{
|
|
Err(e) => println!("{:?}", e),
|
|
_ => (),
|
|
}
|
|
match std::fs::create_dir(
|
|
std::path::Path::new(&active_dir)
|
|
.join("src"))
|
|
{
|
|
Err(e) => println!("{:?}", e),
|
|
_ => (),
|
|
}
|
|
match std::fs::create_dir(
|
|
std::path::Path::new(&active_dir)
|
|
.join("inc"))
|
|
{
|
|
Err(e) => println!("{:?}", e),
|
|
_ => (),
|
|
}
|
|
match std::fs::create_dir(
|
|
std::path::Path::new(&active_dir)
|
|
.join("cfg"))
|
|
{
|
|
Err(e) => println!("{:?}", e),
|
|
_ => (),
|
|
}
|
|
match std::fs::create_dir(
|
|
std::path::Path::new(&active_dir)
|
|
.join("ESF"))
|
|
{
|
|
Err(e) => println!("{:?}", e),
|
|
_ => (),
|
|
}
|
|
|
|
// load targets
|
|
//create symlinks in ESF
|
|
// match std::os::unix::fs::symlink("", "")
|
|
// {
|
|
// Err(e) => println!("{:?}", e),
|
|
// _ => (),
|
|
// }
|
|
println!("Displaying contents of {:?}", active_dir.display());
|
|
for entry in active_dir.read_dir()
|
|
.unwrap()
|
|
{
|
|
let dir = entry.unwrap();
|
|
println!("{:?}", dir.file_name());
|
|
}
|
|
|
|
IglooErrType::IGLOO_ERR_NONE
|
|
}
|
|
|
|
pub fn env(self) -> IglooEnvInfo
|
|
{
|
|
self.env_info.clone()
|
|
}
|
|
}
|
|
|
|
impl IglooTarget
|
|
{
|
|
pub fn default() -> IglooTarget
|
|
{
|
|
IglooTarget
|
|
{
|
|
name: String::from(""),
|
|
make_manifest: HashMap::default(),
|
|
target_manifest: HashMap::default(),
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|