use std::collections::BTreeSet;
use std::path::PathBuf;
use anyhow::{Context, Result};
use tera::Tera;
use crate::models::{GeneratedFile, GenerationConfig, Language, ProjectAnalysis};
use crate::templates::resolve_dockerignore_template;
pub fn generate_dockerignores(
analysis: &ProjectAnalysis,
config: &GenerationConfig,
tera: &Tera,
) -> Result<Vec<GeneratedFile>> {
if analysis.services.is_empty() {
anyhow::bail!("no services to generate .dockerignore files for");
}
let single = config.force_single || !analysis.is_monorepo || analysis.services.len() == 1;
let mut files = Vec::new();
if single {
let service = &analysis.services[0];
let tpl_path = resolve_dockerignore_template(&service.language);
let content = tera
.render(tpl_path, &tera::Context::new())
.with_context(|| {
format!(
"failed to render .dockerignore for service '{}'",
service.name
)
})?;
files.push(GeneratedFile {
relative_path: ".dockerignore".into(),
content,
description: format!(".dockerignore for {} ({})", service.name, service.language),
});
} else {
for service in &analysis.services {
let tpl_path = resolve_dockerignore_template(&service.language);
let content = tera
.render(tpl_path, &tera::Context::new())
.with_context(|| {
format!(
"failed to render .dockerignore for service '{}'",
service.name
)
})?;
files.push(GeneratedFile {
relative_path: PathBuf::from(service.name.clone()).join(".dockerignore"),
content,
description: format!(".dockerignore for {} ({})", service.name, service.language),
});
}
let root_content = synthesize_polyglot_dockerignore(analysis, tera)?;
files.push(GeneratedFile {
relative_path: ".dockerignore".into(),
content: root_content,
description: "root .dockerignore (polyglot merged)".into(),
});
}
Ok(files)
}
fn synthesize_polyglot_dockerignore(analysis: &ProjectAnalysis, tera: &Tera) -> Result<String> {
let mut seen_languages = BTreeSet::new();
let mut all_lines = Vec::new();
let generic_tpl = resolve_dockerignore_template(&Language::Unknown("root".into()));
if let Ok(content) = tera.render(generic_tpl, &tera::Context::new()) {
for line in content.lines() {
let trimmed = line.trim();
if !trimmed.is_empty() && !all_lines.contains(&trimmed.to_string()) {
all_lines.push(trimmed.to_string());
}
}
}
for service in &analysis.services {
if seen_languages.insert(service.language.to_string()) {
let tpl_path = resolve_dockerignore_template(&service.language);
if let Ok(content) = tera.render(tpl_path, &tera::Context::new()) {
for line in content.lines() {
let trimmed = line.trim();
if !trimmed.is_empty() && !all_lines.contains(&trimmed.to_string()) {
all_lines.push(trimmed.to_string());
}
}
}
}
}
all_lines.sort();
all_lines.dedup();
Ok(all_lines.join("\n") + "\n")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::*;
use crate::templates::create_tera_engine;
use std::collections::BTreeMap;
fn make_service(name: &str, lang: Language) -> Service {
Service {
name: name.into(),
path: PathBuf::from(format!("/project/{name}")),
package_name: None,
language: lang,
framework: Framework::Generic,
package_manager: PackageManager::Unknown,
runtime_version: None,
entrypoint: None,
exposed_ports: vec![],
env_vars: vec![],
service_type: ServiceType::Single,
build_command: None,
start_command: None,
is_monorepo: false,
dependencies: vec![],
}
}
fn make_analysis(services: Vec<Service>, is_monorepo: bool) -> ProjectAnalysis {
ProjectAnalysis {
root_path: PathBuf::from("/project"),
is_monorepo,
workspace_tool: None,
services,
detected_infrastructures: vec![],
warnings: vec![],
root_env_vars: BTreeMap::new(),
}
}
fn default_config() -> GenerationConfig {
GenerationConfig {
base_image_override: None,
port_overrides: vec![],
force_single: false,
dry_run: false,
emit_compose: false,
output_dir: None,
interactive: false,
assume_yes: false,
interactive_answers: None,
}
}
fn tera_engine() -> Tera {
create_tera_engine().expect("tera engine init failed")
}
#[test]
fn single_service_generates_root_dockerignore() {
let svc = make_service("api", Language::NodeJs);
let analysis = make_analysis(vec![svc], false);
let config = default_config();
let tera = tera_engine();
let files = generate_dockerignores(&analysis, &config, &tera).unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].relative_path, PathBuf::from(".dockerignore"));
assert!(files[0].content.contains("node_modules"));
}
#[test]
fn monorepo_generates_per_service_and_root() {
let svcs = vec![
make_service("frontend", Language::NodeJs),
make_service("backend", Language::Go),
];
let analysis = make_analysis(svcs, true);
let config = default_config();
let tera = tera_engine();
let files = generate_dockerignores(&analysis, &config, &tera).unwrap();
assert_eq!(files.len(), 3);
assert!(files
.iter()
.any(|f| f.relative_path == std::path::Path::new("frontend/.dockerignore")));
assert!(files
.iter()
.any(|f| f.relative_path == std::path::Path::new("backend/.dockerignore")));
assert!(files
.iter()
.any(|f| f.relative_path == std::path::Path::new(".dockerignore")));
}
#[test]
fn force_single_prevents_per_service() {
let svcs = vec![
make_service("a", Language::Python),
make_service("b", Language::Rust),
];
let analysis = make_analysis(svcs, true);
let config = GenerationConfig {
force_single: true,
..default_config()
};
let tera = tera_engine();
let files = generate_dockerignores(&analysis, &config, &tera).unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].relative_path, PathBuf::from(".dockerignore"));
}
#[test]
fn empty_services_is_error() {
let analysis = make_analysis(vec![], false);
let config = default_config();
let tera = tera_engine();
assert!(generate_dockerignores(&analysis, &config, &tera).is_err());
}
#[test]
fn deterministic_output() {
let svc = make_service("api", Language::Python);
let analysis = make_analysis(vec![svc], false);
let config = default_config();
let tera = tera_engine();
let f1 = generate_dockerignores(&analysis, &config, &tera).unwrap();
let f2 = generate_dockerignores(&analysis, &config, &tera).unwrap();
assert_eq!(f1[0].content, f2[0].content);
}
#[test]
fn polyglot_root_merges_all_languages() {
let svcs = vec![
make_service("frontend", Language::NodeJs),
make_service("api", Language::Python),
make_service("worker", Language::Go),
];
let analysis = make_analysis(svcs, true);
let config = default_config();
let tera = tera_engine();
let files = generate_dockerignores(&analysis, &config, &tera).unwrap();
let root = files
.iter()
.find(|f| f.relative_path == std::path::Path::new(".dockerignore"))
.expect("root .dockerignore missing");
assert!(root.content.contains("node_modules"), "missing Node rule");
assert!(root.content.contains("__pycache__"), "missing Python rule");
assert!(root.content.contains("vendor"), "missing Go rule");
assert!(root.description.contains("polyglot"));
}
#[test]
fn polyglot_root_is_deterministic() {
let svcs = vec![
make_service("frontend", Language::NodeJs),
make_service("api", Language::Python),
];
let analysis = make_analysis(svcs, true);
let config = default_config();
let tera = tera_engine();
let f1 = generate_dockerignores(&analysis, &config, &tera).unwrap();
let f2 = generate_dockerignores(&analysis, &config, &tera).unwrap();
let root1 = f1
.iter()
.find(|f| f.relative_path == std::path::Path::new(".dockerignore"))
.unwrap();
let root2 = f2
.iter()
.find(|f| f.relative_path == std::path::Path::new(".dockerignore"))
.unwrap();
assert_eq!(root1.content, root2.content);
}
}