use anyhow::Result;
use std::fs;
use std::path::PathBuf;
pub async fn run(project_path: PathBuf, fix: bool) -> Result<()> {
log::info!("Validating project at: {}", project_path.display());
let mut issues = Vec::new();
let mut warnings = Vec::new();
println!("đ Validating RustF project structure...");
let cargo_toml = project_path.join("Cargo.toml");
if !cargo_toml.exists() {
issues.push("â Missing Cargo.toml file".to_string());
} else {
if let Ok(content) = fs::read_to_string(&cargo_toml) {
if !content.contains("rustf") {
warnings.push("â ī¸ RustF dependency not found in Cargo.toml".to_string());
} else {
println!("â
Found RustF dependency in Cargo.toml");
}
}
}
let src_dir = project_path.join("src");
if !src_dir.exists() {
issues.push("â Missing src/ directory".to_string());
} else {
println!("â
Found src/ directory");
let main_rs = src_dir.join("main.rs");
if !main_rs.exists() {
warnings.push("â ī¸ Missing src/main.rs file".to_string());
} else {
println!("â
Found src/main.rs");
}
}
println!("\nđ Validating directory structure...");
let expected_dirs = [
("src/controllers", "Controllers directory"),
("src/models", "Models directory"),
("src/middleware", "Middleware directory"),
("views", "Views directory"),
("public", "Public assets directory"),
("schemas", "Schema definitions directory"),
];
for (dir_path, description) in expected_dirs {
let full_path = project_path.join(dir_path);
if full_path.exists() {
println!("â
Found {}: {}", description, dir_path);
} else {
warnings.push(format!("â ī¸ Missing {}: {}", description, dir_path));
}
}
println!("\nâī¸ Validating configuration...");
let config_toml = project_path.join("config.toml");
if config_toml.exists() {
println!("â
Found config.toml");
if let Ok(content) = fs::read_to_string(&config_toml) {
match toml::from_str::<toml::Value>(&content) {
Ok(_) => println!("â
config.toml is valid TOML"),
Err(e) => issues.push(format!("â Invalid config.toml: {}", e)),
}
}
} else {
warnings.push("â ī¸ No config.toml found (will use defaults)".to_string());
}
let dev_config_toml = project_path.join("config.dev.toml");
if dev_config_toml.exists() {
println!("â
Found config.dev.toml");
if let Ok(content) = fs::read_to_string(&dev_config_toml) {
match toml::from_str::<toml::Value>(&content) {
Ok(_) => println!("â
config.dev.toml is valid TOML"),
Err(e) => issues.push(format!("â Invalid config.dev.toml: {}", e)),
}
}
} else {
println!("âšī¸ No config.dev.toml found (optional, but recommended for CLI usage)");
}
println!("\nđ Validating schema files...");
let schemas_dir = project_path.join("schemas");
if schemas_dir.exists() {
match fs::read_dir(&schemas_dir) {
Ok(entries) => {
let mut schema_count = 0;
for entry in entries.flatten() {
let path = entry.path();
if path.extension().and_then(|s| s.to_str()) == Some("yaml") {
schema_count += 1;
if let Ok(content) = fs::read_to_string(&path) {
match serde_yaml::from_str::<serde_yaml::Value>(&content) {
Ok(_) => {
if let Some(file_name) =
path.file_name().and_then(|n| n.to_str())
{
println!("â
Valid schema: {}", file_name);
}
}
Err(e) => {
if let Some(file_name) =
path.file_name().and_then(|n| n.to_str())
{
issues.push(format!(
"â Invalid schema {}: {}",
file_name, e
));
}
}
}
}
}
}
if schema_count == 0 {
warnings.push("â ī¸ No YAML schema files found in schemas/".to_string());
} else {
println!("â
Found {} schema file(s)", schema_count);
}
}
Err(_) => {
warnings.push("â ī¸ Cannot read schemas directory".to_string());
}
}
}
println!("\nđ§ Validating build configuration...");
let output = std::process::Command::new("cargo")
.arg("check")
.current_dir(&project_path)
.output();
match output {
Ok(result) => {
if result.status.success() {
println!("â
Project compiles successfully");
} else {
let stderr = String::from_utf8_lossy(&result.stderr);
issues.push(format!("â Build check failed:\n{}", stderr));
}
}
Err(_) => {
warnings.push("â ī¸ Could not run cargo check (cargo not found?)".to_string());
}
}
println!("\nđ Validation Summary");
println!("=====================");
if issues.is_empty() && warnings.is_empty() {
println!("đ Project validation passed with no issues!");
return Ok(());
}
if !warnings.is_empty() {
println!("\nâ ī¸ Warnings ({}):", warnings.len());
for warning in &warnings {
println!(" {}", warning);
}
}
if !issues.is_empty() {
println!("\nâ Issues ({}):", issues.len());
for issue in &issues {
println!(" {}", issue);
}
if fix {
println!("\nđ§ Auto-fix is not yet implemented, but these issues were found:");
println!(" - Consider running 'rustf new' to create missing structure");
println!(" - Check the RustF documentation for proper project setup");
}
return Err(anyhow::anyhow!("{} validation issues found", issues.len()));
}
println!(
"\nâ
Validation completed with {} warning(s)",
warnings.len()
);
Ok(())
}