use proc_macro::TokenStream;
use quote::quote;
use std::path::PathBuf;
use syn::{parse_macro_input, parse_quote, ItemFn};
use walkdir::WalkDir;
#[proc_macro]
pub fn auto_controllers(_input: TokenStream) -> TokenStream {
generate_auto_discovery("controllers", "install").into()
}
#[proc_macro]
pub fn auto_models(_input: TokenStream) -> TokenStream {
generate_auto_discovery("models", "register").into()
}
#[proc_macro]
pub fn auto_middleware(_input: TokenStream) -> TokenStream {
generate_auto_discovery("middleware", "install").into()
}
#[proc_macro]
pub fn auto_definitions(_input: TokenStream) -> TokenStream {
generate_auto_discovery("definitions", "install").into()
}
#[proc_macro]
pub fn auto_modules(_input: TokenStream) -> TokenStream {
generate_auto_discovery("modules", "install").into()
}
#[proc_macro]
pub fn auto_events(_input: TokenStream) -> TokenStream {
generate_auto_discovery("events", "install").into()
}
#[proc_macro]
pub fn auto_workers(_input: TokenStream) -> TokenStream {
generate_worker_discovery().into()
}
fn generate_auto_discovery(dir_name: &str, fn_name: &str) -> proc_macro2::TokenStream {
let manifest_dir =
std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR should be set during build");
let src_dir = PathBuf::from(&manifest_dir).join("src").join(dir_name);
let cargo_toml_path = PathBuf::from(&manifest_dir).join("Cargo.toml");
let is_rustf_framework = if cargo_toml_path.exists() {
if let Ok(contents) = std::fs::read_to_string(&cargo_toml_path) {
contents.contains("name = \"rustf\"") && !contents.contains("name = \"rustf-")
} else {
false
}
} else {
false
};
let should_skip = is_rustf_framework
&& matches!(
dir_name,
"models" | "workers" | "definitions" | "middleware" | "events"
);
if should_skip || !src_dir.exists() {
let path_prefix = if is_rustf_framework {
quote! { crate }
} else {
quote! { rustf }
};
return match dir_name {
"controllers" => quote! {
{
Vec::new()
}
},
"models" => quote! {
{
|_registry: &mut #path_prefix::models::ModelRegistry| {
}
}
},
"middleware" => quote! {
{
|_registry: &mut #path_prefix::middleware::MiddlewareRegistry| {
}
}
},
"events" => quote! {
{
|_emitter: &mut #path_prefix::events::EventEmitter| {
}
}
},
"definitions" => quote! {
{
|_defs: &mut #path_prefix::definitions::Definitions| {
}
}
},
_ => quote! { compile_error!("Unknown directory type"); },
};
}
let mut modules = Vec::new();
let mut function_calls = Vec::new();
for entry in WalkDir::new(&src_dir)
.min_depth(1)
.max_depth(3) .into_iter()
.filter_map(|e| e.ok())
{
let path = entry.path();
if path.is_dir() {
continue;
}
if path.extension().and_then(|s| s.to_str()) != Some("rs") {
continue;
}
if path.file_name().and_then(|s| s.to_str()) == Some("mod.rs") {
continue;
}
if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
if file_name.ends_with(".inc.rs") {
continue;
}
if file_name.starts_with("_") {
continue;
}
}
let relative_to_target = path
.strip_prefix(&src_dir)
.expect("Path should be under target directory");
let mut path_components = Vec::new();
for component in relative_to_target.components() {
if let std::path::Component::Normal(name) = component {
if let Some(name_str) = name.to_str() {
if name_str.ends_with(".rs") {
path_components.push(name_str.trim_end_matches(".rs"));
} else {
path_components.push(name_str);
}
}
}
}
let _module_path = path_components.join("::");
let module_ident_str = path_components.join("_");
let module_ident = syn::Ident::new(&module_ident_str, proc_macro2::Span::call_site());
let src_dir_base = PathBuf::from(&manifest_dir).join("src");
let relative_path = path
.strip_prefix(&src_dir_base)
.expect("Path should be under src directory")
.to_string_lossy()
.replace('\\', "/");
if path_components.len() == 1 {
let module_name = path_components[0];
let module_ident = syn::Ident::new(module_name, proc_macro2::Span::call_site());
modules.push(quote! {
#[path = #relative_path]
pub mod #module_ident;
});
match dir_name {
"controllers" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
routes.extend(#module_ident::#fn_ident());
});
}
"models" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(registry);
});
}
"middleware" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(registry);
});
}
"modules" => {
}
"events" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(emitter);
});
}
"definitions" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(defs);
});
}
"workers" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident().await?;
});
}
_ => {}
}
} else {
modules.push(quote! {
#[path = #relative_path]
pub mod #module_ident;
});
match dir_name {
"controllers" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
routes.extend(#module_ident::#fn_ident());
});
}
"models" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(registry);
});
}
"middleware" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(registry);
});
}
"modules" => {
}
"events" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(emitter);
});
}
"definitions" => {
let fn_ident = syn::Ident::new(fn_name, proc_macro2::Span::call_site());
function_calls.push(quote! {
#module_ident::#fn_ident(defs);
});
}
_ => {}
}
}
}
let path_prefix = if is_rustf_framework {
quote! { crate }
} else {
quote! { rustf }
};
match dir_name {
"controllers" => {
let controller_count = function_calls.len();
quote! {
{
#(#modules)*
log::info!("Auto-discovery: Loading {} controller(s)", #controller_count);
let mut routes = Vec::new();
#(#function_calls)*
routes
}
}
}
"models" => {
let model_count = function_calls.len();
quote! {
{
#(#modules)*
|registry: &mut #path_prefix::models::ModelRegistry| {
log::info!("Auto-discovery: Registering {} model(s)", #model_count);
#(#function_calls)*
}
}
}
}
"middleware" => {
let middleware_count = function_calls.len();
quote! {
{
#(#modules)*
|registry: &mut #path_prefix::middleware::MiddlewareRegistry| {
log::info!("Auto-discovery: Registering {} middleware", #middleware_count);
#(#function_calls)*
}
}
}
}
"modules" => {
quote! {
{
#(#modules)*
log::info!("Auto-discovery: Found module(s) - explicit MODULE::register() required for registration");
}
}
}
"events" => {
let event_count = function_calls.len();
quote! {
{
#(#modules)*
|emitter: &mut #path_prefix::events::EventEmitter| {
log::info!("Auto-discovery: Registering {} event handler(s)", #event_count);
#(#function_calls)*
}
}
}
}
"definitions" => {
let definitions_count = function_calls.len();
quote! {
{
#(#modules)*
|defs: &mut #path_prefix::definitions::Definitions| {
log::info!("Auto-discovery: Registering {} definition(s)", #definitions_count);
#(#function_calls)*
}
}
}
}
_ => quote! { compile_error!("Unknown directory type"); },
}
}
#[proc_macro_attribute]
pub fn auto_discover(_args: TokenStream, input: TokenStream) -> TokenStream {
let mut input_fn = parse_macro_input!(input as ItemFn);
let manifest_dir =
std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR should be set during build");
let src_dir = PathBuf::from(&manifest_dir).join("src");
let modules_mod = generate_mod_declarations(&src_dir, "modules");
let controllers_mod = generate_mod_declarations(&src_dir, "controllers");
let models_mod = generate_mod_declarations(&src_dir, "models");
let middleware_mod = generate_mod_declarations(&src_dir, "middleware");
let events_mod = generate_mod_declarations(&src_dir, "events");
let definitions_mod = generate_mod_declarations(&src_dir, "definitions");
#[cfg(feature = "embedded-views")]
let is_rustf_framework = {
let cargo_toml_path = PathBuf::from(&manifest_dir).join("Cargo.toml");
if cargo_toml_path.exists() {
if let Ok(contents) = std::fs::read_to_string(&cargo_toml_path) {
contents.contains("name = \"rustf\"") && !contents.contains("name = \"rustf-")
} else {
false
}
} else {
false
}
};
#[cfg(feature = "embedded-views")]
let embedded_structs = if !is_rustf_framework {
let views_folder = format!("{}/views/", manifest_dir);
let assets_folder = format!("{}/public/", manifest_dir);
quote! {
#[derive(rustf::rust_embed::RustEmbed)]
#[folder = #views_folder]
#[allow(dead_code)]
struct __RustfAppViews;
#[derive(rustf::rust_embed::RustEmbed)]
#[folder = #assets_folder]
#[allow(dead_code)]
struct __RustfAppAssets;
impl rustf::EmbeddedFileProvider for __RustfAppViews {
fn get(&self, path: &str) -> Option<Vec<u8>> {
<__RustfAppViews as rustf::rust_embed::RustEmbed>::get(path)
.map(|f| f.data.into_owned())
}
fn files(&self) -> Vec<String> {
<__RustfAppViews as rustf::rust_embed::RustEmbed>::iter()
.map(|p| p.to_string())
.collect()
}
}
impl rustf::EmbeddedFileProvider for __RustfAppAssets {
fn get(&self, path: &str) -> Option<Vec<u8>> {
<__RustfAppAssets as rustf::rust_embed::RustEmbed>::get(path)
.map(|f| f.data.into_owned())
}
fn files(&self) -> Vec<String> {
<__RustfAppAssets as rustf::rust_embed::RustEmbed>::iter()
.map(|p| p.to_string())
.collect()
}
}
}
} else {
quote! {}
};
#[cfg(not(feature = "embedded-views"))]
let embedded_structs = quote! {};
#[cfg(feature = "embedded-views")]
let embed_register_stmt: syn::Stmt = if !is_rustf_framework {
parse_quote! {
{
rustf::register_views_provider(Box::new(__RustfAppViews));
rustf::register_assets_provider(Box::new(__RustfAppAssets));
}
}
} else {
parse_quote! { {} }
};
#[cfg(not(feature = "embedded-views"))]
let embed_register_stmt: syn::Stmt = parse_quote! { {} };
let register_stmt = parse_quote! {
rustf::auto::register_hooks(rustf::auto::AutoDiscoveryHooks {
controllers: Some(|| controllers::collect_routes()),
models: Some(|registry: &mut rustf::models::ModelRegistry| {
models::register_all(registry);
}),
shared: None, middleware: Some(|registry: &mut rustf::middleware::MiddlewareRegistry| {
middleware::register_all(registry);
}),
events: Some(|emitter: &mut rustf::events::EventEmitter| {
events::register_all(emitter);
}),
definitions: Some(|defs: &mut rustf::definitions::Definitions| {
definitions::register_all(defs);
}),
workers: Some(auto_workers!()),
});
};
let mut fn_block = (*input_fn.block).clone();
fn_block.stmts.insert(0, embed_register_stmt);
fn_block.stmts.insert(0, register_stmt);
input_fn.block = Box::new(fn_block);
let expanded = quote! {
#modules_mod
#controllers_mod
#models_mod
#middleware_mod
#events_mod
#definitions_mod
#embedded_structs
#input_fn
};
expanded.into()
}
fn generate_mod_declarations(src_dir: &PathBuf, dir_name: &str) -> proc_macro2::TokenStream {
let target_dir = src_dir.join(dir_name);
if !target_dir.exists() {
return fallback_module(dir_name);
}
let mut generated_module_declarations = Vec::new();
let mut generated_mod_content = String::new();
generated_mod_content
.push_str("// Auto-generated by RustF #[auto_discover] macro - DO NOT EDIT\n");
generated_mod_content.push_str("// This file is framework-owned and may be overwritten.\n");
generated_mod_content.push_str(&format!(
"// Generated module declarations for src/{}/\n\n",
dir_name
));
let mut aggregator_calls = String::new();
for entry in WalkDir::new(&target_dir)
.min_depth(1)
.max_depth(3) .into_iter()
.filter_map(|e| e.ok())
{
let path = entry.path();
if path.is_dir() {
continue;
}
if path.extension().and_then(|s| s.to_str()) != Some("rs") {
continue;
}
if let Some(filename) = path.file_name().and_then(|s| s.to_str()) {
if filename == "mod.rs" || filename.starts_with("_") || filename.ends_with(".inc.rs") {
continue;
}
}
let relative_to_target = path
.strip_prefix(&target_dir)
.expect("Path should be under target directory");
let mut path_components = Vec::new();
for component in relative_to_target.components() {
if let std::path::Component::Normal(name) = component {
if let Some(name_str) = name.to_str() {
if name_str.ends_with(".rs") {
path_components.push(name_str.trim_end_matches(".rs"));
} else {
path_components.push(name_str);
}
}
}
}
if path_components.is_empty() {
continue;
}
if dir_name == "models" {
let module_name = path_components.last().unwrap();
if module_name == &"MODELS_README" || module_name.contains("_generated") {
continue;
}
}
let module_ident_str = path_components.join("_");
let module_ident = syn::Ident::new(&module_ident_str, proc_macro2::Span::call_site());
if path_components.len() == 1 {
generated_module_declarations.push(quote! {
pub mod #module_ident;
});
} else {
let relative_path = relative_to_target.to_string_lossy().replace('\\', "/");
generated_module_declarations.push(quote! {
#[path = #relative_path]
pub mod #module_ident;
});
}
let relative_path = relative_to_target.to_string_lossy().replace('\\', "/");
generated_mod_content.push_str(&format!(
"#[path = \"../{}/{}\"]\n",
dir_name, relative_path
));
generated_mod_content.push_str(&format!("pub mod {};\n", module_ident_str));
match dir_name {
"controllers" => aggregator_calls.push_str(&format!(
" routes.extend({}::install());\n",
module_ident_str
)),
"models" => aggregator_calls.push_str(&format!(
" {}::register(registry);\n",
module_ident_str
)),
"middleware" => aggregator_calls.push_str(&format!(
" {}::install(registry);\n",
module_ident_str
)),
"events" => aggregator_calls.push_str(&format!(
" {}::install(emitter);\n",
module_ident_str
)),
"definitions" => aggregator_calls.push_str(&format!(
" {}::install(defs);\n",
module_ident_str
)),
_ => {}
}
}
if dir_name == "models" {
let base_dir = target_dir.join("base");
if base_dir.exists() {
let mut base_declarations = Vec::new();
let mut base_content = String::new();
for entry in WalkDir::new(&base_dir)
.min_depth(1)
.max_depth(1)
.into_iter()
.filter_map(|e| e.ok())
{
let path = entry.path();
if path.extension().and_then(|s| s.to_str()) == Some("rs") {
if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
if file_name.ends_with(".inc.rs") {
continue;
}
}
if let Some(module_name) = path.file_stem().and_then(|s| s.to_str()) {
let module_ident =
syn::Ident::new(module_name, proc_macro2::Span::call_site());
base_declarations.push(quote! {
pub mod #module_ident;
});
base_content
.push_str(&format!(" #[path = \"base/{}.rs\"]\n", module_name));
base_content.push_str(&format!(" pub mod {};\n", module_name));
}
}
}
if !base_declarations.is_empty() {
generated_module_declarations.push(quote! {
pub mod base {
#(#base_declarations)*
}
});
generated_mod_content.push_str("\npub mod base {\n");
generated_mod_content.push_str(&base_content);
generated_mod_content.push_str("}\n");
}
}
}
match dir_name {
"controllers" => generated_mod_content.push_str(
"\npub fn collect_routes() -> Vec<rustf::routing::Route> {\n let mut routes = Vec::new();\n",
),
"models" => generated_mod_content.push_str(
"\npub fn register_all(registry: &mut rustf::models::ModelRegistry) {\n",
),
"middleware" => generated_mod_content.push_str(
"\npub fn register_all(registry: &mut rustf::middleware::MiddlewareRegistry) {\n",
),
"events" => generated_mod_content
.push_str("\npub fn register_all(emitter: &mut rustf::events::EventEmitter) {\n"),
"definitions" => generated_mod_content.push_str(
"\npub fn register_all(defs: &mut rustf::definitions::Definitions) {\n",
),
_ => {}
}
if !aggregator_calls.is_empty() {
generated_mod_content.push_str(&aggregator_calls);
}
match dir_name {
"controllers" => generated_mod_content.push_str(" routes\n}\n"),
"models" | "middleware" | "events" | "definitions" => {
generated_mod_content.push_str("}\n");
}
_ => {}
}
if !generated_module_declarations.is_empty() {
let legacy_ide_file_path = src_dir.join(format!("_{}.rs", dir_name));
if legacy_ide_file_path.exists() {
if let Err(e) = std::fs::remove_file(&legacy_ide_file_path) {
let message = format!(
"RustF auto-discovery failed to remove legacy IDE file '{}': {}",
legacy_ide_file_path.display(),
e
);
return quote! { compile_error!(#message); };
}
}
let generated_dir = src_dir.join(".rustf");
if let Err(e) = std::fs::create_dir_all(&generated_dir) {
let message = format!(
"RustF auto-discovery failed to create '{}': {}",
generated_dir.display(),
e
);
return quote! { compile_error!(#message); };
}
let generated_file_path = generated_dir.join(format!("{}_gen.rs", dir_name));
if let Err(e) = std::fs::write(&generated_file_path, &generated_mod_content) {
let message = format!(
"RustF auto-discovery failed to write '{}': {}",
generated_file_path.display(),
e
);
return quote! { compile_error!(#message); };
}
if let Err(message) = ensure_wrapper_module(src_dir, dir_name) {
return quote! { compile_error!(#message); };
}
}
if generated_module_declarations.is_empty() {
return fallback_module(dir_name);
}
let dir_ident = syn::Ident::new(dir_name, proc_macro2::Span::call_site());
let wrapper_relative_path = format!("{}/mod.rs", dir_name);
quote! {
#[path = #wrapper_relative_path]
mod #dir_ident;
}
}
fn fallback_module(dir_name: &str) -> proc_macro2::TokenStream {
let dir_ident = syn::Ident::new(dir_name, proc_macro2::Span::call_site());
match dir_name {
"controllers" => quote! {
mod #dir_ident {
pub fn collect_routes() -> Vec<rustf::routing::Route> {
Vec::new()
}
}
},
"models" => quote! {
mod #dir_ident {
pub fn register_all(_registry: &mut rustf::models::ModelRegistry) {}
}
},
"middleware" => quote! {
mod #dir_ident {
pub fn register_all(_registry: &mut rustf::middleware::MiddlewareRegistry) {}
}
},
"events" => quote! {
mod #dir_ident {
pub fn register_all(_emitter: &mut rustf::events::EventEmitter) {}
}
},
"definitions" => quote! {
mod #dir_ident {
pub fn register_all(_defs: &mut rustf::definitions::Definitions) {}
}
},
_ => quote! {
mod #dir_ident {}
},
}
}
fn ensure_wrapper_module(src_dir: &PathBuf, dir_name: &str) -> Result<(), String> {
let wrapper_path = src_dir.join(dir_name).join("mod.rs");
if !wrapper_path.exists() {
if let Some(parent) = wrapper_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| {
format!(
"RustF auto-discovery failed to create '{}': {}",
parent.display(),
e
)
})?;
}
std::fs::write(&wrapper_path, wrapper_template(dir_name)).map_err(|e| {
format!(
"RustF auto-discovery failed to write '{}': {}",
wrapper_path.display(),
e
)
})?;
return Ok(());
}
validate_wrapper_module(&wrapper_path, dir_name)
}
fn wrapper_template(dir_name: &str) -> String {
format!(
"// Auto-generated scaffold for RustF auto-discovery.\n\
// You may add custom code here, but keep the generated import and re-export intact.\n\
#[path = \"../.rustf/{dir_name}_gen.rs\"]\n\
mod generated;\n\n\
pub use generated::*;\n"
)
}
fn validate_wrapper_module(wrapper_path: &std::path::Path, dir_name: &str) -> Result<(), String> {
let expected_path = format!("../.rustf/{}_gen.rs", dir_name);
let contents = std::fs::read_to_string(wrapper_path).map_err(|e| {
format!(
"RustF auto-discovery failed to read '{}': {}",
wrapper_path.display(),
e
)
})?;
let parsed = syn::parse_file(&contents).map_err(|e| {
format!(
"RustF auto-discovery found invalid Rust in '{}': {}",
wrapper_path.display(),
e
)
})?;
let mut has_generated_mod = false;
let mut has_generated_reexport = false;
for item in parsed.items {
match item {
syn::Item::Mod(item_mod) if item_mod.ident == "generated" => {
if item_mod.content.is_some() {
return Err(format!(
"RustF auto-discovery rejected '{}': `mod generated` must stay external and point to '{}'",
wrapper_path.display(),
expected_path
));
}
let mut matches_expected_path = false;
for attr in item_mod.attrs {
if attr.path().is_ident("path") {
if let syn::Meta::NameValue(name_value) = &attr.meta {
if let syn::Expr::Lit(expr_lit) = &name_value.value {
if let syn::Lit::Str(lit) = &expr_lit.lit {
matches_expected_path = lit.value() == expected_path;
}
}
}
}
}
if !matches_expected_path {
return Err(format!(
"RustF auto-discovery rejected '{}': `mod generated` must use #[path = \"{}\"]",
wrapper_path.display(),
expected_path
));
}
has_generated_mod = true;
}
syn::Item::Use(item_use) if is_generated_glob_reexport(&item_use) => {
has_generated_reexport = true;
}
_ => {}
}
}
if !has_generated_mod {
return Err(format!(
"RustF auto-discovery rejected '{}': missing required generated module import `#[path = \"{}\"] mod generated;`",
wrapper_path.display(),
expected_path
));
}
if !has_generated_reexport {
return Err(format!(
"RustF auto-discovery rejected '{}': missing required `pub use generated::*;` re-export",
wrapper_path.display()
));
}
Ok(())
}
fn is_generated_glob_reexport(item_use: &syn::ItemUse) -> bool {
if !matches!(item_use.vis, syn::Visibility::Public(_)) {
return false;
}
match &item_use.tree {
syn::UseTree::Path(path) if path.ident == "generated" => {
matches!(&*path.tree, syn::UseTree::Glob(_))
}
_ => false,
}
}
#[proc_macro]
pub fn include_dir_as_modules(_input: TokenStream) -> TokenStream {
quote! {
compile_error!("include_dir_as_modules! is not yet implemented. Use auto_controllers! or auto_models! instead.");
}.into()
}
fn generate_worker_discovery() -> proc_macro2::TokenStream {
let manifest_dir =
std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR should be set during build");
let src_dir = PathBuf::from(&manifest_dir).join("src").join("workers");
let cargo_toml_path = PathBuf::from(&manifest_dir).join("Cargo.toml");
let is_rustf_framework = if cargo_toml_path.exists() {
if let Ok(contents) = std::fs::read_to_string(&cargo_toml_path) {
contents.contains("name = \"rustf\"") && !contents.contains("name = \"rustf-")
} else {
false
}
} else {
false
};
let path_prefix = if is_rustf_framework {
quote! { crate }
} else {
quote! { rustf }
};
if is_rustf_framework || !src_dir.exists() {
return quote! {
{
|_manager: std::sync::Arc<#path_prefix::workers::WorkerManager>| {
Box::pin(async move {
Ok(())
})
}
}
};
}
let mut modules = Vec::new();
let mut function_calls = Vec::new();
for entry in WalkDir::new(&src_dir)
.min_depth(1)
.max_depth(3)
.into_iter()
.filter_map(|e| e.ok())
{
let path = entry.path();
if path.is_dir() {
continue;
}
if path.extension().and_then(|s| s.to_str()) != Some("rs") {
continue;
}
if path.file_name().and_then(|s| s.to_str()) == Some("mod.rs") {
continue;
}
if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
if file_name.ends_with(".inc.rs") || file_name.starts_with("_") {
continue;
}
}
let relative_to_workers = path
.strip_prefix(&src_dir)
.expect("Path should be under workers directory");
let mut path_components = Vec::new();
for component in relative_to_workers.components() {
if let std::path::Component::Normal(name) = component {
if let Some(name_str) = name.to_str() {
if name_str.ends_with(".rs") {
path_components.push(name_str.trim_end_matches(".rs"));
} else {
path_components.push(name_str);
}
}
}
}
if path_components.is_empty() {
continue;
}
let module_ident_str = path_components.join("_");
let module_ident = syn::Ident::new(&module_ident_str, proc_macro2::Span::call_site());
let src_dir_base = PathBuf::from(&manifest_dir).join("src");
let relative_path = path
.strip_prefix(&src_dir_base)
.expect("Path should be under src directory")
.to_string_lossy()
.replace('\\', "/");
modules.push(quote! {
#[path = #relative_path]
pub mod #module_ident;
});
function_calls.push(quote! {
#module_ident::install().await?;
});
}
let worker_count = function_calls.len();
quote! {
{
#(#modules)*
|_manager: std::sync::Arc<#path_prefix::workers::WorkerManager>| {
Box::pin(async move {
log::info!("Auto-discovery: Loading {} worker(s)", #worker_count);
#(#function_calls)*
Ok(())
})
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use std::path::Path;
use std::sync::{Mutex, MutexGuard};
use tempfile::TempDir;
static ENV_LOCK: Mutex<()> = Mutex::new(());
struct ManifestGuard {
_lock: MutexGuard<'static, ()>,
previous: Option<String>,
}
impl ManifestGuard {
fn enter(manifest_dir: &Path) -> Self {
let lock = ENV_LOCK.lock().unwrap_or_else(|err| err.into_inner());
let previous = std::env::var("CARGO_MANIFEST_DIR").ok();
std::env::set_var("CARGO_MANIFEST_DIR", manifest_dir);
Self {
_lock: lock,
previous,
}
}
}
impl Drop for ManifestGuard {
fn drop(&mut self) {
if let Some(previous) = &self.previous {
std::env::set_var("CARGO_MANIFEST_DIR", previous);
} else {
std::env::remove_var("CARGO_MANIFEST_DIR");
}
}
}
fn create_manifest(name: &str) -> TempDir {
let temp_dir = TempDir::new().expect("temp dir");
fs::create_dir_all(temp_dir.path().join("src")).expect("src dir");
fs::write(
temp_dir.path().join("Cargo.toml"),
format!("[package]\nname = \"{}\"\nversion = \"0.1.0\"\nedition = \"2021\"\n", name),
)
.expect("cargo toml");
temp_dir
}
fn write_rs(path: &Path, body: &str) {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent).expect("parent dir");
}
fs::write(path, body).expect("rust file");
}
#[test]
fn auto_discovery_discovers_nested_controllers_and_skips_special_files() {
let temp_dir = create_manifest("fixture-app");
write_rs(
&temp_dir.path().join("src/controllers/home.rs"),
"pub fn install() -> Vec<()> { vec![] }",
);
write_rs(
&temp_dir.path().join("src/controllers/api/users.rs"),
"pub fn install() -> Vec<()> { vec![] }",
);
write_rs(
&temp_dir.path().join("src/controllers/_private.rs"),
"pub fn install() -> Vec<()> { vec![] }",
);
write_rs(
&temp_dir.path().join("src/controllers/shared.inc.rs"),
"pub fn install() -> Vec<()> { vec![] }",
);
write_rs(
&temp_dir.path().join("src/controllers/mod.rs"),
"pub fn ignored() {}",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_auto_discovery("controllers", "install").to_string();
assert!(tokens.contains("home"));
assert!(tokens.contains("api_users"));
assert!(tokens.contains("routes . extend (home :: install ())"));
assert!(tokens.contains("routes . extend (api_users :: install ())"));
assert!(tokens.contains("Loading {} controller(s)"));
assert!(!tokens.contains("_private"));
assert!(!tokens.contains("shared.inc"));
}
#[test]
fn auto_discovery_skips_framework_internal_models() {
let temp_dir = create_manifest("rustf");
write_rs(
&temp_dir.path().join("src/models/user.rs"),
"pub fn register(_: &mut ()) {}",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_auto_discovery("models", "register").to_string();
assert!(tokens.contains("| _registry : & mut crate :: models :: ModelRegistry |"));
assert!(!tokens.contains("user"));
}
#[test]
fn worker_discovery_generates_async_install_calls() {
let temp_dir = create_manifest("fixture-app");
write_rs(
&temp_dir.path().join("src/workers/email.rs"),
"pub async fn install() -> Result<(), ()> { Ok(()) }",
);
write_rs(
&temp_dir.path().join("src/workers/jobs/cleanup.rs"),
"pub async fn install() -> Result<(), ()> { Ok(()) }",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_worker_discovery().to_string();
assert!(tokens.contains("email :: install () . await ?"));
assert!(tokens.contains("jobs_cleanup :: install () . await ?"));
assert!(tokens.contains("Loading {} worker(s)"));
}
#[test]
fn generate_mod_declarations_creates_wrapper_and_generated_files() {
let temp_dir = create_manifest("fixture-app");
write_rs(
&temp_dir.path().join("src/controllers/home.rs"),
"pub fn install() -> Vec<()> { vec![] }",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_mod_declarations(&temp_dir.path().join("src"), "controllers")
.to_string();
assert!(tokens.contains("# [path = \"controllers/mod.rs\"] mod controllers ;"));
let wrapper_path = temp_dir.path().join("src/controllers/mod.rs");
let generated_path = temp_dir.path().join("src/.rustf/controllers_gen.rs");
let wrapper = fs::read_to_string(wrapper_path).expect("wrapper content");
let generated = fs::read_to_string(generated_path).expect("generated content");
assert!(wrapper.contains("#[path = \"../.rustf/controllers_gen.rs\"]"));
assert!(wrapper.contains("mod generated;"));
assert!(wrapper.contains("pub use generated::*;"));
assert!(generated.contains("#[path = \"../controllers/home.rs\"]"));
assert!(generated.contains("pub mod home;"));
assert!(!temp_dir.path().join("src/_controllers.rs").exists());
}
#[test]
fn generate_mod_declarations_removes_legacy_underscore_file() {
let temp_dir = create_manifest("fixture-app");
write_rs(
&temp_dir.path().join("src/models/users.rs"),
"pub fn register(_: &mut ()) {}",
);
write_rs(
&temp_dir.path().join("src/_models.rs"),
"// legacy auto-generated IDE file",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_mod_declarations(&temp_dir.path().join("src"), "models").to_string();
assert!(tokens.contains("# [path = \"models/mod.rs\"] mod models ;"));
assert!(!temp_dir.path().join("src/_models.rs").exists());
}
#[test]
fn generate_mod_declarations_rejects_invalid_wrapper_shape() {
let temp_dir = create_manifest("fixture-app");
write_rs(
&temp_dir.path().join("src/controllers/home.rs"),
"pub fn install() -> Vec<()> { vec![] }",
);
write_rs(
&temp_dir.path().join("src/controllers/mod.rs"),
"mod generated;\n",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_mod_declarations(&temp_dir.path().join("src"), "controllers")
.to_string();
assert!(tokens.contains("compile_error !"));
assert!(tokens.contains("mod generated"));
assert!(tokens.contains("controllers_gen.rs"));
}
#[test]
fn generate_mod_declarations_accepts_valid_existing_wrapper() {
let temp_dir = create_manifest("fixture-app");
write_rs(
&temp_dir.path().join("src/models/users.rs"),
"pub fn register(_: &mut ()) {}",
);
write_rs(
&temp_dir.path().join("src/models/mod.rs"),
"// custom comment is allowed\n#[path = \"../.rustf/models_gen.rs\"]\nmod generated;\n\npub use generated::*;\n",
);
let _guard = ManifestGuard::enter(temp_dir.path());
let tokens = generate_mod_declarations(&temp_dir.path().join("src"), "models").to_string();
assert!(tokens.contains("# [path = \"models/mod.rs\"] mod models ;"));
}
}