makectl 0.2.0

Generate and manage targets in your Makefiles
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::fs;
use std::path::Path;

use anyhow::{bail, Result};
use colored::Colorize;
use inquire::MultiSelect;

use crate::parser::Makefile;
use crate::templates::TemplateRegistry;

pub fn execute(file: &str, templates: &[String], interactive: bool) -> Result<()> {
    if !Path::new(file).exists() {
        bail!(
            "Makefile not found at {}. Run 'makectl init' to create one.",
            file
        );
    }

    let registry = TemplateRegistry::new();
    let content = fs::read_to_string(file)?;
    let makefile = Makefile::parse(&content)?;

    let template_ids = if interactive && templates.is_empty() {
        prompt_templates(&registry, &makefile)?
    } else if templates.is_empty() {
        bail!("No templates specified. Use -i for interactive mode or provide template names.");
    } else {
        templates.to_vec()
    };

    let mut to_append = String::new();
    let mut added = Vec::new();
    let mut skipped = Vec::new();

    for template_id in &template_ids {
        let template = match registry.get(template_id) {
            Some(t) => t,
            None => bail!(
                "Template '{}' not found. Run 'makectl list' to see available templates.",
                template_id
            ),
        };

        let target_name = &template.name;

        if makefile.has_target(target_name)
            || makefile
                .managed_blocks()
                .iter()
                .any(|mb| mb.template_id == *template_id)
        {
            skipped.push(template_id.clone());
            continue;
        }

        to_append.push_str(&format!(
            "\n# MAKECTL MANAGED START {} {}\n{}\n# MAKECTL MANAGED END {}\n",
            target_name, template_id, template.content, target_name
        ));
        added.push(template_id.clone());
    }

    if !to_append.is_empty() {
        let mut full = content;
        if !full.ends_with('\n') {
            full.push('\n');
        }
        full.push_str(&to_append);
        fs::write(file, full)?;
    }

    for name in &added {
        println!("  {} {}", "+".green().bold(), name);
    }
    for name in &skipped {
        println!("  {} {} (already exists)", "~".yellow().bold(), name);
    }

    if added.is_empty() && skipped.is_empty() {
        println!("Nothing to add.");
    } else if !added.is_empty() {
        println!(
            "{} Added {} template(s) to {}",
            "Done.".green().bold(),
            added.len(),
            file
        );
    }

    Ok(())
}

fn prompt_templates(registry: &TemplateRegistry, makefile: &Makefile) -> Result<Vec<String>> {
    let existing_ids: Vec<String> = makefile
        .managed_blocks()
        .iter()
        .map(|mb| mb.template_id.clone())
        .collect();

    let existing_targets: Vec<String> = makefile.targets().iter().map(|t| t.name.clone()).collect();

    let available: Vec<_> = registry
        .list_all()
        .iter()
        .filter(|t| !existing_ids.contains(&t.id) && !existing_targets.contains(&t.name))
        .collect();

    if available.is_empty() {
        println!("All templates are already added.");
        return Ok(Vec::new());
    }

    let display_items: Vec<String> = available
        .iter()
        .map(|t| format!("{} - {}", t.id, t.description))
        .collect();

    let selected = MultiSelect::new("Select templates to add:", display_items).prompt()?;

    let ids: Vec<String> = selected
        .iter()
        .filter_map(|s| s.split(" - ").next())
        .map(|s| s.to_string())
        .collect();

    Ok(ids)
}