light_fw_cli_core/

init.rs

//! Команда `light init`: создание скелета нового проекта Light.
//!
//! Модуль генерирует минимальный проект: `Cargo.toml` с зависимостью `light-fw`,
//! самодостаточный `src/main.rs` (окно с текстом «Hello, Light!»), `.gitignore`
//! и `light.lock`. Внешние эффекты (проверка `cargo`) идут через трейт
//! [`CommandRunner`], поэтому логика тестируется без запуска процессов.

use std::path::PathBuf;
use std::str::FromStr;

use crate::error::{Error, Result};
use crate::lockfile::{LOCKFILE_NAME, Lockfile};
use crate::process::CommandRunner;

/// Версия мета-крейта `light-fw`, которую прописывает `light init`.
pub const LIGHT_DEPENDENCY_VERSION: &str = env!("CARGO_PKG_VERSION");

/// Minor-диапазон версии (`major.minor`), используемый в `Cargo.toml` нового
/// проекта: пользователь всегда получает latest `major.minor.x`, не привязываясь
/// к конкретному yanked-патчу.
pub fn minor_version() -> String {
    LIGHT_DEPENDENCY_VERSION
        .rsplit_once('.')
        .map(|(prefix, _)| prefix.to_string())
        .unwrap_or_else(|| LIGHT_DEPENDENCY_VERSION.to_string())
}

/// Содержимое `.gitignore` нового проекта.
pub const GITIGNORE: &str = "target/\n";

/// Алиасы `cargo dev` / `cargo prod`: отладочный режим (DevTools) и релиз.
pub const CARGO_CONFIG: &str =
    "[alias]\ndev = \"run --features light-fw/dev-mode\"\nprod = \"run --release\"\n";

/// Конфигурация `light.config.json`: профили `dev` (DevTools на 9229, debug)
/// и `prod` (DevTools выключен, error).
pub const LIGHT_CONFIG: &str = r#"{
    "dev": {
        "devtools": {
            "enabled": true,
            "port": 9229
        },
        "log_level": "debug"
    },
    "prod": {
        "devtools": {
            "enabled": false
        },
        "log_level": "error"
    }
}
"#;

const COUNTER_MAIN: &str = include_str!("../assets/counter/src/main.rs");
const COUNTER_HTML: &str = include_str!("../assets/counter/templates/counter.html");
const TODO_MAIN: &str = include_str!("../assets/todo/src/main.rs");
const TODO_HTML: &str = include_str!("../assets/todo/templates/todo.html");
const CALCULATOR_MAIN: &str = include_str!("../assets/calculator/src/main.rs");
const CALCULATOR_HTML: &str = include_str!("../assets/calculator/templates/calculator.html");

/// Готовый пример, который `light init --template` кладёт в новый проект.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InitTemplate {
    /// Счётчик с реактивным состоянием.
    Counter,
    /// Список задач с `v-model`, `v-if` и `v-for`.
    Todo,
    /// Калькулятор с обработчиками кнопок.
    Calculator,
}

impl InitTemplate {
    /// Все поддерживаемые шаблоны.
    pub const ALL: [Self; 3] = [Self::Counter, Self::Todo, Self::Calculator];

    /// Разбирает имя шаблона из `--template`.
    pub fn parse(value: &str) -> Result<Self> {
        match value {
            "counter" => Ok(Self::Counter),
            "todo" => Ok(Self::Todo),
            "calculator" => Ok(Self::Calculator),
            other => Err(Error::Init(format!(
                "неизвестный шаблон `{other}` (поддерживаются: counter, todo, calculator)"
            ))),
        }
    }

    /// Содержимое `src/main.rs` шаблона.
    pub fn main_rs(self) -> &'static str {
        match self {
            Self::Counter => COUNTER_MAIN,
            Self::Todo => TODO_MAIN,
            Self::Calculator => CALCULATOR_MAIN,
        }
    }

    /// Дополнительные HTML-шаблоны: путь в проекте и содержимое.
    pub fn template_files(self) -> &'static [(&'static str, &'static str)] {
        match self {
            Self::Counter => &[("templates/counter.html", COUNTER_HTML)],
            Self::Todo => &[("templates/todo.html", TODO_HTML)],
            Self::Calculator => &[("templates/calculator.html", CALCULATOR_HTML)],
        }
    }
}

impl FromStr for InitTemplate {
    type Err = Error;

    fn from_str(value: &str) -> Result<Self> {
        Self::parse(value)
    }
}

/// Дополнительный компонент, подключаемый флагом `--with`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum InitComponent {
    /// `light-fw-element-form`: `<checkbox>`, `<radio>`, `<select>`/`<option>`.
    Form,
    /// `light-fw-behavior-validation`: `required`, `:validator`, `@validate`.
    Validation,
}

impl InitComponent {
    /// Все поддерживаемые компоненты в порядке вывода в `Cargo.toml`.
    pub const ALL: [Self; 2] = [Self::Form, Self::Validation];

    /// Разбирает имя компонента из `--with`.
    pub fn parse(value: &str) -> Result<Self> {
        match value {
            "form" => Ok(Self::Form),
            "validation" => Ok(Self::Validation),
            other => Err(Error::Init(format!(
                "неизвестный компонент `{other}` (поддерживаются: form, validation)"
            ))),
        }
    }

    /// Имя крейта-компонента.
    pub fn crate_name(self) -> &'static str {
        match self {
            Self::Form => "light-fw-element-form",
            Self::Validation => "light-fw-behavior-validation",
        }
    }

    /// Фича мета-крейта `light-fw`, включающая компонент.
    pub fn light_feature(self) -> &'static str {
        match self {
            Self::Form => "elements-form",
            Self::Validation => "validation",
        }
    }
}

impl FromStr for InitComponent {
    type Err = Error;

    fn from_str(value: &str) -> Result<Self> {
        Self::parse(value)
    }
}

/// Параметры команды `light init`.
#[derive(Debug, Clone)]
pub struct InitOptions {
    /// Имя проекта (оно же имя крейта).
    pub name: String,
    /// Каталог проекта; по умолчанию — `./<name>`.
    pub path: Option<PathBuf>,
    /// Только `Cargo.toml` и `src/main.rs` (без `.gitignore` и `light.lock`).
    pub minimal: bool,
    /// Дополнительные компоненты (`--with`).
    pub components: Vec<InitComponent>,
    /// Готовый шаблон приложения (`--template`).
    pub template: Option<InitTemplate>,
}

/// Что будет создано (результат [`plan`]).
#[derive(Debug, Clone)]
pub struct InitPlan {
    /// Каталог проекта.
    pub directory: PathBuf,
    /// Файлы проекта: относительный путь и содержимое.
    pub files: Vec<(PathBuf, String)>,
    /// Создавать ли `light.lock`.
    pub write_lockfile: bool,
}

impl InitPlan {
    /// Человекочитаемый план.
    pub fn to_text(&self) -> String {
        let mut out = format!("Проект в {}\n", self.directory.display());
        for (path, _) in &self.files {
            out.push_str(&format!("  + {}\n", path.display()));
        }
        if self.write_lockfile {
            out.push_str(&format!("  + {}\n", LOCKFILE_NAME));
        }
        out
    }
}

/// Итог создания проекта.
#[derive(Debug, Clone)]
pub struct InitReport {
    /// Каталог проекта.
    pub directory: PathBuf,
    /// Созданные файлы (относительные пути).
    pub files: Vec<PathBuf>,
    /// Создан ли `light.lock`.
    pub lockfile: bool,
}

impl InitReport {
    /// Человекочитаемый отчёт с подсказкой о запуске.
    pub fn to_text(&self) -> String {
        let mut out = format!("✓ Проект создан в {}\n", self.directory.display());
        for path in &self.files {
            out.push_str(&format!("  {}\n", path.display()));
        }
        if self.lockfile {
            out.push_str(&format!("  {}\n", LOCKFILE_NAME));
        }
        out.push_str(&format!(
            "\nДалее: cd \"{}\" && cargo run\n",
            self.directory.display()
        ));
        out
    }
}

/// Проверяет, что `name` — допустимое имя крейта.
///
/// Разрешены латинские буквы, цифры, `-` и `_`; первый символ — буква или `_`.
pub fn validate_name(name: &str) -> Result<()> {
    if name.is_empty() || name.len() > 64 {
        return Err(Error::Init(
            "имя проекта должно быть длиной от 1 до 64 символов".to_string(),
        ));
    }
    let mut chars = name.chars();
    let first = chars.next().expect("непустое имя");
    if !(first.is_ascii_alphabetic() || first == '_') {
        return Err(Error::Init(format!(
            "имя `{name}` должно начинаться с латинской буквы или `_`"
        )));
    }
    if let Some(bad) = name
        .chars()
        .find(|c| !(c.is_ascii_alphanumeric() || *c == '-' || *c == '_'))
    {
        return Err(Error::Init(format!(
            "недопустимый символ `{bad}` в имени `{name}` (разрешены латинские буквы, цифры, `-`, `_`)"
        )));
    }
    Ok(())
}

/// Целевой каталог проекта из параметров.
pub fn project_dir(options: &InitOptions) -> PathBuf {
    match &options.path {
        Some(path) => path.clone(),
        None => PathBuf::from(&options.name),
    }
}

/// Компоненты без дублей в порядке [`InitComponent::ALL`].
fn normalized_components(components: &[InitComponent]) -> Vec<InitComponent> {
    InitComponent::ALL
        .into_iter()
        .filter(|component| components.contains(component))
        .collect()
}

/// Содержимое `Cargo.toml` нового проекта.
/// Шаблон-заглушка для проекта без `--template`: минимальное окно с
/// приветствием, центрированным в контентной области.
const APP_HTML: &str = r#"<window title="Hello, Light!" width="480" height="320">
    <div width="100%" height="100%" direction="vertical" justify-content="center" align-items="center" padding="16">
        <h1>Hello, Light!</h1>
    </div>
</window>
"#;

/// Содержимое `Cargo.toml` для нового проекта: зависимости `light-fw`,
/// компоненты и фича `dev-mode` (алиас `light-fw/dev-mode`).
pub fn cargo_toml(name: &str, components: &[InitComponent]) -> String {
    let components = normalized_components(components);
    let mut text = format!(
        "[package]\n\
         name = \"{name}\"\n\
         version = \"0.1.0\"\n\
         edition = \"2021\"\n\
         \n\
         [dependencies]\n"
    );

    if components.is_empty() {
        text.push_str(&format!("light-fw = \"{}\"\n", minor_version()));
    } else {
        let features = components
            .iter()
            .map(|component| format!("\"{}\"", component.light_feature()))
            .collect::<Vec<_>>()
            .join(", ");
        let v = minor_version();
        text.push_str(&format!(
            "light-fw = {{ version = \"{v}\", features = [{features}] }}\n"
        ));
        for component in &components {
            text.push_str(&format!("{} = \"{v}\"\n", component.crate_name()));
        }
    }

    // Фича `dev-mode` — алиас для `light-fw/dev-mode` (runtime-templates, hot
    // reload). Необходима для `light dev` и `.cargo/config.toml`.
    text.push_str("\n[features]\ndev-mode = [\"light-fw/dev-mode\"]\n");
    // ТЗ 0.16.1, задача 2: пустой `[workspace]` в самом конце — чтобы проект
    // не «попадал» в чужой workspace, если создан внутри папки с Cargo.toml
    // («current package believes it's in a workspace when it's not»).
    text.push_str("\n[workspace]\n");
    text
}

/// Закомментированный пример формы для проектов с компонентом `form`.
const FORM_EXAMPLE: &str = r#"
// Пример формы (компонент `form`):
//
// #[template("templates/form.html")]
// #[proxy]
// struct SignUp {
//     email: String,
//     agree: bool,
// }
//
// impl SignUp {
//     fn submit(&self) {
//         if self.agree() {
//             println!("email: {}", self.email());
//         }
//     }
// }
//
// templates/form.html:
// <window title="Sign up" width="360" height="240">
//     <div direction="vertical" padding="12">
//         <text v-model="email" placeholder="Email" required />
//         <checkbox v-model="agree">Согласен с условиями</checkbox>
//         <button @click="submit" :disabled="!agree">Отправить</button>
//     </div>
// </window>
"#;

/// Содержимое `src/main.rs` — минимальное приложение с HTML-шаблоном
/// (`templates/app.html`) и пустой прокси-структурой.
pub fn main_rs(components: &[InitComponent]) -> String {
    let mut text = r#"use light_fw::prelude::*;

#[template("templates/app.html")]
#[proxy]
struct App {}

fn main() -> light_fw::Result<()> {
    light_fw::run_with_config("light.config.json", App::new())
}
"#
    .to_string();

    if components.contains(&InitComponent::Form) {
        text.push_str(FORM_EXAMPLE);
    }
    text
}

/// Строит план создания проекта, проверяя, что каталог свободен.
///
/// Ошибка, если каталог существует и не пуст.
pub fn plan(options: &InitOptions) -> Result<InitPlan> {
    validate_name(&options.name)?;
    let directory = project_dir(options);

    if directory.is_dir() {
        let mut entries = std::fs::read_dir(&directory)?;
        if entries.next().is_some() {
            return Err(Error::Init(format!(
                "каталог `{}` не пуст — укажите другое имя или `--path`",
                directory.display()
            )));
        }
    } else if directory.exists() {
        return Err(Error::Init(format!(
            "`{}` существует и не является каталогом",
            directory.display()
        )));
    }

    let components = normalized_components(&options.components);
    let main = match options.template {
        Some(template) => template.main_rs().to_string(),
        None => main_rs(&components),
    };
    let mut files = vec![
        (
            PathBuf::from("Cargo.toml"),
            cargo_toml(&options.name, &components),
        ),
        (PathBuf::from("src").join("main.rs"), main),
        // Алиасы `cargo dev` / `cargo prod` и конфигурация DevTools/логирования.
        (
            PathBuf::from(".cargo").join("config.toml"),
            CARGO_CONFIG.to_string(),
        ),
        (PathBuf::from("light.config.json"), LIGHT_CONFIG.to_string()),
    ];
    if let Some(template) = options.template {
        for (path, content) in template.template_files() {
            files.push((PathBuf::from(path), (*content).to_string()));
        }
    } else {
        // Проект без `--template`: `main.rs` ссылается на `templates/app.html`.
        files.push((
            PathBuf::from("templates").join("app.html"),
            APP_HTML.to_string(),
        ));
    }
    if !options.minimal {
        files.push((PathBuf::from(".gitignore"), GITIGNORE.to_string()));
    }

    Ok(InitPlan {
        directory,
        files,
        write_lockfile: !options.minimal,
    })
}

/// Проверяет, что `cargo` доступен в `PATH`.
pub fn require_cargo(runner: &dyn CommandRunner) -> Result<()> {
    match runner.run("cargo", &["--version".to_string()], None) {
        Ok(_) => Ok(()),
        Err(Error::CommandNotFound(_)) => Err(Error::Init(
            "`cargo` не найден в PATH — установите Rust (https://rustup.rs)".to_string(),
        )),
        Err(error) => Err(error),
    }
}

/// Записывает файлы плана на диск, создавая каталоги по мере необходимости.
pub fn scaffold(plan: &InitPlan) -> Result<()> {
    for (relative, content) in &plan.files {
        let path = plan.directory.join(relative);
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }
        std::fs::write(&path, content)?;
    }
    Ok(())
}

/// Полный цикл: проверка `cargo` → план → запись файлов → `light.lock`.
pub fn apply(runner: &dyn CommandRunner, options: &InitOptions) -> Result<InitReport> {
    require_cargo(runner)?;
    let plan = plan(options)?;
    scaffold(&plan)?;

    let lockfile = if plan.write_lockfile {
        let lock = Lockfile::from_project(&plan.directory)?;
        lock.write(&plan.directory)?;
        true
    } else {
        false
    };

    Ok(InitReport {
        directory: plan.directory,
        files: plan.files.into_iter().map(|(path, _)| path).collect(),
        lockfile,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::process::CommandOutput;
    use std::path::Path;
    use std::sync::atomic::{AtomicU64, Ordering};

    static COUNTER: AtomicU64 = AtomicU64::new(0);

    fn scratch(name: &str) -> PathBuf {
        let unique = COUNTER.fetch_add(1, Ordering::Relaxed);
        let dir = std::env::temp_dir().join(format!(
            "light-fw-cli-init-{name}-{}-{unique}",
            std::process::id()
        ));
        let _ = std::fs::remove_dir_all(&dir);
        std::fs::create_dir_all(&dir).expect("scratch dir");
        dir
    }

    struct StubRunner {
        found: bool,
    }

    impl CommandRunner for StubRunner {
        fn run(
            &self,
            program: &str,
            _args: &[String],
            _cwd: Option<&Path>,
        ) -> Result<CommandOutput> {
            if self.found {
                Ok(CommandOutput {
                    status: 0,
                    stdout: "cargo 1.99.0".to_string(),
                    stderr: String::new(),
                })
            } else {
                Err(Error::CommandNotFound(program.to_string()))
            }
        }
    }

    #[test]
    fn rejects_invalid_names() {
        assert!(validate_name("my-app").is_ok());
        assert!(validate_name("app_2").is_ok());
        assert!(validate_name("").is_err());
        assert!(validate_name("2app").is_err());
        assert!(validate_name("my app").is_err());
        assert!(validate_name("app!").is_err());
    }

    #[test]
    fn plan_default_creates_all_files() {
        let root = scratch("plan-default");
        let dir = root.join("cool-app");
        let options = InitOptions {
            name: "cool-app".to_string(),
            path: Some(dir.clone()),
            minimal: false,
            components: Vec::new(),
            template: None,
        };
        let plan = plan(&options).expect("plan");
        let names: Vec<String> = plan
            .files
            .iter()
            .map(|(path, _)| path.to_string_lossy().replace('\\', "/"))
            .collect();
        assert!(names.contains(&"Cargo.toml".to_string()));
        assert!(names.contains(&"src/main.rs".to_string()));
        assert!(names.contains(&"templates/app.html".to_string()));
        assert!(names.contains(&".gitignore".to_string()));
        assert!(names.contains(&".cargo/config.toml".to_string()));
        assert!(names.contains(&"light.config.json".to_string()));
        // main.rs использует `#[template]` (HTML-шаблон).
        let main = plan
            .files
            .iter()
            .find(|(path, _)| path.to_string_lossy().replace('\\', "/") == "src/main.rs")
            .map(|(_, c)| c.as_str())
            .expect("main.rs in plan");
        assert!(main.contains("#[template"), "{main}");
        assert!(plan.write_lockfile);
    }

    #[test]
    fn plan_minimal_omits_gitignore_and_lockfile() {
        let root = scratch("plan-minimal");
        let options = InitOptions {
            name: "tiny".to_string(),
            path: Some(root.join("tiny")),
            minimal: true,
            components: Vec::new(),
            template: None,
        };
        let plan = plan(&options).expect("plan");
        let names: Vec<String> = plan
            .files
            .iter()
            .map(|(path, _)| path.to_string_lossy().replace('\\', "/"))
            .collect();
        assert!(!names.contains(&".gitignore".to_string()));
        assert!(!plan.write_lockfile);
    }

    #[test]
    fn plan_rejects_non_empty_directory() {
        let root = scratch("plan-nonempty");
        let target = root.join("busy");
        std::fs::create_dir_all(&target).expect("dir");
        std::fs::write(target.join("file.txt"), "x").expect("file");
        let options = InitOptions {
            name: "busy".to_string(),
            path: Some(target),
            minimal: false,
            components: Vec::new(),
            template: None,
        };
        let error = plan(&options).expect_err("должна быть ошибка");
        assert!(error.to_string().contains("не пуст"), "{error}");
    }

    #[test]
    fn cargo_toml_pins_light_version() {
        let text = cargo_toml("demo", &[]);
        assert!(text.contains("name = \"demo\""));
        let mv = minor_version();
        // Обёртка переименована: новый проект зависит от `light-fw`, а не `light`.
        assert!(text.contains(&format!("light-fw = \"{mv}\"")));
        assert!(!text.contains(&format!("light = \"{mv}\"")), "{text}");
        // Фича `dev-mode` всегда присутствует (алиас `light-fw/dev-mode`).
        assert!(text.contains("[features]"), "{text}");
        assert!(
            text.contains("dev-mode = [\"light-fw/dev-mode\"]"),
            "{text}"
        );
        // ТЗ 0.16.1: в самом конце — пустой `[workspace]`.
        assert!(text.trim_end().ends_with("[workspace]"), "{text}");
    }

    #[test]
    fn cargo_toml_adds_form_dependency_and_feature() {
        let text = cargo_toml("demo", &[InitComponent::Form]);
        let mv = minor_version();
        // Мета-крейт — `light-fw` (не `light`).
        assert!(
            text.contains(&format!(
                "light-fw = {{ version = \"{mv}\", features = [\"elements-form\"] }}"
            )),
            "{text}"
        );
        assert!(
            text.contains(&format!("light-fw-element-form = \"{mv}\"")),
            "{text}"
        );
        assert!(!text.contains("light-fw-behavior-validation"), "{text}");
    }

    #[test]
    fn cargo_toml_adds_both_dependencies_and_deduplicates() {
        let text = cargo_toml(
            "demo",
            &[
                InitComponent::Validation,
                InitComponent::Form,
                InitComponent::Form,
            ],
        );
        let mv = minor_version();
        // Мета-крейт — `light-fw` (не `light`).
        assert!(
            text.contains(&format!(
                "light-fw = {{ version = \"{mv}\", features = [\"elements-form\", \"validation\"] }}"
            )),
            "{text}"
        );
        assert_eq!(text.matches("light-fw-element-form =").count(), 1, "{text}");
        assert_eq!(
            text.matches("light-fw-behavior-validation =").count(),
            1,
            "{text}"
        );
    }

    #[test]
    fn main_rs_uses_template_macro() {
        let text = main_rs(&[]);
        assert!(text.contains("#[template"), "{text}");
        assert!(text.contains("templates/app.html"), "{text}");
        assert!(text.contains("#[proxy]"), "{text}");
        assert!(text.contains("App::new()"), "{text}");
        assert!(text.contains("run_with_config"), "{text}");
        assert!(!text.contains("include_str!"));
        assert!(!text.contains("Пример формы"));
    }

    #[test]
    fn main_rs_includes_form_example_only_for_form_component() {
        let text = main_rs(&[InitComponent::Form]);
        assert!(text.contains("Пример формы"), "{text}");
        let validation_only = main_rs(&[InitComponent::Validation]);
        assert!(
            !validation_only.contains("Пример формы"),
            "{validation_only}"
        );
    }

    #[test]
    fn parses_supported_templates() {
        assert_eq!(
            InitTemplate::parse("counter").expect("counter"),
            InitTemplate::Counter
        );
        assert_eq!(
            InitTemplate::parse("todo").expect("todo"),
            InitTemplate::Todo
        );
        assert_eq!(
            InitTemplate::parse("calculator").expect("calculator"),
            InitTemplate::Calculator
        );
        let error = InitTemplate::parse("unknown").expect_err("unknown template");
        assert!(error.to_string().contains("counter"), "{error}");
    }

    #[test]
    fn template_plan_includes_main_and_html() {
        let root = scratch("plan-template");
        let options = InitOptions {
            name: "todo-app".to_string(),
            path: Some(root.join("todo-app")),
            minimal: true,
            components: Vec::new(),
            template: Some(InitTemplate::Todo),
        };
        let plan = plan(&options).expect("plan");
        let by_path = |name: &str| {
            plan.files
                .iter()
                .find(|(path, _)| path.to_string_lossy().replace('\\', "/") == name)
                .map(|(_, content)| content.as_str())
        };
        assert!(by_path("src/main.rs").expect("main").contains("TodoApp"));
        assert!(
            by_path("templates/todo.html")
                .expect("todo template")
                .contains("Light Todo")
        );
        // Cargo.toml + main.rs + шаблон + `.cargo/config.toml` + `light.config.json`.
        assert_eq!(
            plan.files.len(),
            5,
            "Cargo.toml + main.rs + template + cargo config + light config"
        );
        assert!(
            by_path(".cargo/config.toml")
                .expect("cargo config")
                .contains("dev = \"run --features light-fw/dev-mode\"")
        );
        assert!(
            by_path("light.config.json")
                .expect("light config")
                .contains("\"port\": 9229")
        );
    }

    #[test]
    fn require_cargo_reports_missing_tool() {
        let error = require_cargo(&StubRunner { found: false }).expect_err("нет cargo");
        assert!(error.to_string().contains("cargo"), "{error}");
        assert!(require_cargo(&StubRunner { found: true }).is_ok());
    }

    #[test]
    fn apply_creates_project_and_lockfile() {
        let root = scratch("apply");
        let dir = root.join("my-app");
        let options = InitOptions {
            name: "my-app".to_string(),
            path: Some(dir.clone()),
            minimal: false,
            components: Vec::new(),
            template: None,
        };
        let report = apply(&StubRunner { found: true }, &options).expect("apply");
        assert!(report.lockfile);
        assert!(dir.join("Cargo.toml").is_file());
        assert!(dir.join("src").join("main.rs").is_file());
        assert!(dir.join(".gitignore").is_file());
        assert!(dir.join(LOCKFILE_NAME).is_file());

        let lock = Lockfile::read(&dir).expect("read lock");
        assert_eq!(lock.core, minor_version());
    }

    #[test]
    fn apply_minimal_skips_lockfile() {
        let root = scratch("apply-minimal");
        let dir = root.join("tiny");
        let options = InitOptions {
            name: "tiny".to_string(),
            path: Some(dir.clone()),
            minimal: true,
            components: Vec::new(),
            template: None,
        };
        let report = apply(&StubRunner { found: true }, &options).expect("apply");
        assert!(!report.lockfile);
        assert!(dir.join("Cargo.toml").is_file());
        assert!(!dir.join(".gitignore").exists());
        assert!(!dir.join(LOCKFILE_NAME).exists());
    }

    #[test]
    fn apply_fails_without_cargo_before_writing() {
        let root = scratch("apply-nocargo");
        let dir = root.join("nope");
        let options = InitOptions {
            name: "nope".to_string(),
            path: Some(dir.clone()),
            minimal: false,
            components: Vec::new(),
            template: None,
        };
        assert!(apply(&StubRunner { found: false }, &options).is_err());
        assert!(!dir.exists(), "каталог не должен создаваться");
    }

    /// Регрессия 0.17.1, задача 1: `light init` **никогда** не записывает
    /// `default-features = false` в `Cargo.toml` нового проекта. Зависимость
    /// `light-fw` должна остаться с дефолтными фичами (строка или inline-таблица
    /// с `version`/`features`, но без `default-features = false`).
    #[test]
    fn cargo_toml_never_disables_default_features() {
        // Без компонентов: `light-fw = "0.17"`.
        let bare = cargo_toml("bare-app", &[]);
        assert!(
            !bare.contains("default-features"),
            "bare project must not mention default-features:\n{bare}"
        );

        // С компонентами: `light-fw = { version, features = [...] }` — тоже без
        // `default-features = false`.
        let with_components = cargo_toml(
            "form-app",
            &[InitComponent::Form, InitComponent::Validation],
        );
        assert!(
            !with_components.contains("default-features"),
            "project with --with components must not disable default features:\n{with_components}"
        );
        // Фичи компонентов при этом на месте.
        assert!(
            with_components.contains("\"elements-form\""),
            "missing elements-form feature"
        );
        assert!(
            with_components.contains("\"validation\""),
            "missing validation feature"
        );
    }
}