electron-cli 0.3.0-alpha.1 → 0.3.0-alpha.3

package/src/commands/init.rs

@@ -0,0 +1,784 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use anyhow::{bail, Context, Result};
+use camino::Utf8PathBuf;
+use serde::Serialize;
+
+use crate::{
+    cli::{InitArgs, PackageManager},
+    output,
+};
+
+const NATIVE_TEMPLATE_NAME: &str = "minimal";
+const MAIN_JS: &str = include_str!("../../templates/minimal/src/main.js");
+const PRELOAD_JS: &str = include_str!("../../templates/minimal/src/preload.js");
+const INDEX_HTML: &str = include_str!("../../templates/minimal/src/index.html");
+const RENDERER_JS: &str = include_str!("../../templates/minimal/src/renderer.js");
+const GITIGNORE: &str = include_str!("../../templates/minimal/gitignore");
+
+#[derive(Debug, Serialize)]
+struct InitReport {
+    cwd: Utf8PathBuf,
+    target_dir: Utf8PathBuf,
+    target_arg: String,
+    template: String,
+    template_kind: InitTemplateKind,
+    generator: String,
+    package_manager: String,
+    electron_version: Option<String>,
+    dry_run: bool,
+    command: Vec<String>,
+    command_display: String,
+    create_files: Vec<String>,
+    post_create_files: Vec<String>,
+    next_steps: Vec<String>,
+    warnings: Vec<String>,
+    status: InitStatus,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum InitTemplateKind {
+    Native,
+    Forge,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum InitStatus {
+    Planned,
+    Created,
+}
+
+#[derive(Debug, Serialize)]
+struct ElectronCliConfig {
+    version: &'static str,
+    generator: String,
+    template: String,
+    package_manager: String,
+    electron_version: Option<String>,
+}
+
+pub fn run(args: InitArgs) -> Result<()> {
+    let plan = build_plan(&args)?;
+
+    if args.dry_run {
+        return print_report(&plan, args.json);
+    }
+
+    ensure_target_can_be_created(&plan, args.force)?;
+    execute_plan(&plan)?;
+    write_project_config(&plan)?;
+
+    let report = InitReport {
+        status: InitStatus::Created,
+        ..plan
+    };
+
+    print_report(&report, args.json)
+}
+
+fn build_plan(args: &InitArgs) -> Result<InitReport> {
+    let cwd = args
+        .cwd
+        .canonicalize()
+        .with_context(|| format!("Could not resolve {}", args.cwd.display()))?;
+
+    let target_dir = if args.dir.is_absolute() {
+        args.dir.clone()
+    } else {
+        cwd.join(&args.dir)
+    };
+
+    let target_arg = path_arg(&args.dir);
+    let package_manager = args
+        .package_manager
+        .unwrap_or_else(|| detect_package_manager(&cwd));
+    let template_kind = template_kind(&args.template);
+    let electron_version = match template_kind {
+        InitTemplateKind::Native => Some(
+            args.electron_version
+                .clone()
+                .unwrap_or_else(|| "latest".to_string()),
+        ),
+        InitTemplateKind::Forge => args.electron_version.clone(),
+    };
+    let command = match template_kind {
+        InitTemplateKind::Native => Vec::new(),
+        InitTemplateKind::Forge => create_forge_command(package_manager, &target_arg, args),
+    };
+    let command_display = match template_kind {
+        InitTemplateKind::Native => "write built-in minimal template files".to_string(),
+        InitTemplateKind::Forge => display_command(&command),
+    };
+    let generator = match template_kind {
+        InitTemplateKind::Native => "electron-cli".to_string(),
+        InitTemplateKind::Forge => "create-electron-app@latest".to_string(),
+    };
+    let create_files = match template_kind {
+        InitTemplateKind::Native => native_template_paths(args.copy_ci_files),
+        InitTemplateKind::Forge => Vec::new(),
+    };
+    let target_label = target_arg.clone();
+
+    let mut warnings = Vec::new();
+    if target_dir.exists() {
+        warnings.push(format!(
+            "Target directory already exists: {}",
+            target_dir.display()
+        ));
+    }
+
+    if target_dir.exists() && !args.force {
+        let force_message = match template_kind {
+            InitTemplateKind::Native => {
+                "Use --force to overwrite files generated by the native template."
+            }
+            InitTemplateKind::Forge => {
+                "Use --force to allow create-electron-app to overwrite the target."
+            }
+        };
+        warnings.push(force_message.to_string());
+    }
+
+    let mut next_steps = Vec::new();
+    next_steps.push(format!("cd {target_label}"));
+    if template_kind == InitTemplateKind::Native {
+        next_steps.push(install_command(package_manager));
+    }
+    next_steps.push(start_command(package_manager));
+    next_steps.push("electron-cli doctor --json".to_string());
+
+    Ok(InitReport {
+        cwd: utf8_path(cwd)?,
+        target_dir: utf8_path(target_dir)?,
+        target_arg,
+        template: args.template.clone(),
+        template_kind,
+        generator,
+        package_manager: package_manager.as_str().to_string(),
+        electron_version,
+        dry_run: args.dry_run,
+        command,
+        command_display,
+        create_files,
+        post_create_files: vec![".electron-cli.json".to_string()],
+        next_steps,
+        warnings,
+        status: InitStatus::Planned,
+    })
+}
+
+fn create_forge_command(
+    package_manager: PackageManager,
+    target_arg: &str,
+    args: &InitArgs,
+) -> Vec<String> {
+    let mut command = match package_manager {
+        PackageManager::Npm => vec![
+            "npx".to_string(),
+            "-y".to_string(),
+            "create-electron-app@latest".to_string(),
+            target_arg.to_string(),
+        ],
+        PackageManager::Pnpm => vec![
+            "pnpm".to_string(),
+            "dlx".to_string(),
+            "create-electron-app@latest".to_string(),
+            target_arg.to_string(),
+        ],
+        PackageManager::Yarn => vec![
+            "yarn".to_string(),
+            "dlx".to_string(),
+            "create-electron-app@latest".to_string(),
+            target_arg.to_string(),
+        ],
+        PackageManager::Bun => vec![
+            "bunx".to_string(),
+            "create-electron-app@latest".to_string(),
+            target_arg.to_string(),
+        ],
+    };
+
+    command.push("--template".to_string());
+    command.push(args.template.clone());
+
+    if args.copy_ci_files {
+        command.push("--copy-ci-files".to_string());
+    }
+
+    if args.force {
+        command.push("--force".to_string());
+    }
+
+    if args.skip_git {
+        command.push("--skip-git".to_string());
+    }
+
+    if let Some(electron_version) = &args.electron_version {
+        command.push("--electron-version".to_string());
+        command.push(electron_version.clone());
+    }
+
+    command
+}
+
+fn execute_plan(plan: &InitReport) -> Result<()> {
+    match plan.template_kind {
+        InitTemplateKind::Native => write_native_template(plan),
+        InitTemplateKind::Forge => execute_forge_plan(plan),
+    }
+}
+
+fn execute_forge_plan(plan: &InitReport) -> Result<()> {
+    let (program, args) = plan
+        .command
+        .split_first()
+        .context("Init command could not be constructed")?;
+
+    let status = Command::new(program)
+        .args(args)
+        .current_dir(&plan.cwd)
+        .status()
+        .with_context(|| format!("Could not execute {}", plan.command_display))?;
+
+    if !status.success() {
+        bail!(
+            "Init command failed with {status}: {}",
+            plan.command_display
+        );
+    }
+
+    Ok(())
+}
+
+fn ensure_target_can_be_created(plan: &InitReport, force: bool) -> Result<()> {
+    let target = Path::new(plan.target_dir.as_str());
+
+    if target.exists() && !target.is_dir() {
+        bail!("Target exists but is not a directory: {}", plan.target_dir);
+    }
+
+    if target.exists() && !force {
+        bail!(
+            "Target directory already exists: {}. Use --force to overwrite it.",
+            plan.target_dir
+        );
+    }
+
+    Ok(())
+}
+
+fn write_project_config(plan: &InitReport) -> Result<()> {
+    let config = ElectronCliConfig {
+        version: env!("CARGO_PKG_VERSION"),
+        generator: plan.generator.clone(),
+        template: plan.template.clone(),
+        package_manager: plan.package_manager.clone(),
+        electron_version: plan.electron_version.clone(),
+    };
+    let config_path = Path::new(plan.target_dir.as_str()).join(".electron-cli.json");
+    let json = serde_json::to_string_pretty(&config)?;
+
+    fs::write(&config_path, format!("{json}\n"))
+        .with_context(|| format!("Could not write {}", config_path.display()))?;
+
+    Ok(())
+}
+
+fn print_report(report: &InitReport, json: bool) -> Result<()> {
+    if json {
+        return output::json(report);
+    }
+
+    println!("electron-cli init");
+    println!();
+    println!("Project");
+    println!("  cwd: {}", report.cwd);
+    println!("  target: {}", report.target_dir);
+    println!("  template: {}", report.template);
+    println!("  generator: {}", report.generator);
+    println!("  package manager: {}", report.package_manager);
+    if let Some(electron_version) = &report.electron_version {
+        println!("  electron: {electron_version}");
+    }
+    println!("  status: {}", report.status.as_str());
+
+    println!();
+    println!("Action");
+    println!("  {}", report.command_display);
+
+    if !report.create_files.is_empty() {
+        println!();
+        println!("Create Files");
+        for file in &report.create_files {
+            println!("  {file}");
+        }
+    }
+
+    if !report.post_create_files.is_empty() {
+        println!();
+        println!("Post-Create Files");
+        for file in &report.post_create_files {
+            println!("  {file}");
+        }
+    }
+
+    if !report.next_steps.is_empty() {
+        println!();
+        println!("Next Steps");
+        for step in &report.next_steps {
+            println!("  {step}");
+        }
+    }
+
+    if !report.warnings.is_empty() {
+        println!();
+        println!("Warnings");
+        for warning in &report.warnings {
+            println!("  {warning}");
+        }
+    }
+
+    Ok(())
+}
+
+fn write_native_template(plan: &InitReport) -> Result<()> {
+    let target = Path::new(plan.target_dir.as_str());
+    fs::create_dir_all(target).with_context(|| format!("Could not create {}", target.display()))?;
+
+    for file in native_template_files(plan)? {
+        write_template_file(target, file.path, &file.contents)?;
+    }
+
+    Ok(())
+}
+
+struct TemplateFile {
+    path: &'static str,
+    contents: String,
+}
+
+fn native_template_files(plan: &InitReport) -> Result<Vec<TemplateFile>> {
+    let package_name = package_name(plan);
+    let electron_version = plan.electron_version.as_deref().unwrap_or("latest");
+    let package_manager = package_manager_from_str(&plan.package_manager)?;
+    let mut files = vec![
+        TemplateFile {
+            path: "package.json",
+            contents: package_json(&package_name, electron_version)?,
+        },
+        TemplateFile {
+            path: "README.md",
+            contents: readme(&package_name, package_manager),
+        },
+        TemplateFile {
+            path: ".gitignore",
+            contents: GITIGNORE.to_string(),
+        },
+        TemplateFile {
+            path: "src/main.js",
+            contents: MAIN_JS.to_string(),
+        },
+        TemplateFile {
+            path: "src/preload.js",
+            contents: PRELOAD_JS.to_string(),
+        },
+        TemplateFile {
+            path: "src/index.html",
+            contents: INDEX_HTML.to_string(),
+        },
+        TemplateFile {
+            path: "src/renderer.js",
+            contents: RENDERER_JS.to_string(),
+        },
+    ];
+
+    if plan
+        .create_files
+        .iter()
+        .any(|path| path == ".github/workflows/ci.yml")
+    {
+        files.push(TemplateFile {
+            path: ".github/workflows/ci.yml",
+            contents: ci_workflow(package_manager),
+        });
+    }
+
+    Ok(files)
+}
+
+fn native_template_paths(copy_ci_files: bool) -> Vec<String> {
+    let mut files = vec![
+        "package.json",
+        "README.md",
+        ".gitignore",
+        "src/main.js",
+        "src/preload.js",
+        "src/index.html",
+        "src/renderer.js",
+    ]
+    .into_iter()
+    .map(str::to_string)
+    .collect::<Vec<_>>();
+
+    if copy_ci_files {
+        files.push(".github/workflows/ci.yml".to_string());
+    }
+
+    files
+}
+
+fn write_template_file(target: &Path, relative_path: &str, contents: &str) -> Result<()> {
+    let path = target.join(relative_path);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)
+            .with_context(|| format!("Could not create {}", parent.display()))?;
+    }
+
+    fs::write(&path, ensure_trailing_newline(contents))
+        .with_context(|| format!("Could not write {}", path.display()))?;
+
+    Ok(())
+}
+
+fn package_json(package_name: &str, electron_version: &str) -> Result<String> {
+    let package = serde_json::json!({
+        "name": package_name,
+        "version": "0.1.0",
+        "private": true,
+        "description": "Minimal Electron app generated by electron-cli",
+        "main": "src/main.js",
+        "scripts": {
+            "start": "electron .",
+            "smoke": "electron --version"
+        },
+        "devDependencies": {
+            "electron": electron_version
+        }
+    });
+
+    Ok(serde_json::to_string_pretty(&package)?)
+}
+
+fn readme(package_name: &str, package_manager: PackageManager) -> String {
+    format!(
+        r#"# {package_name}
+
+Minimal Electron app generated by electron-cli.
+
+## Scripts
+
+```sh
+{install}
+{start}
+{smoke}
+```
+"#,
+        install = install_command(package_manager),
+        start = start_command(package_manager),
+        smoke = run_script_command(package_manager, "smoke"),
+    )
+}
+
+fn ci_workflow(package_manager: PackageManager) -> String {
+    let setup = match package_manager {
+        PackageManager::Npm => {
+            "      - uses: actions/setup-node@v6\n        with:\n          node-version: 22\n"
+                .to_string()
+        }
+        PackageManager::Pnpm | PackageManager::Yarn => {
+            "      - uses: actions/setup-node@v6\n        with:\n          node-version: 22\n      - run: corepack enable\n"
+                .to_string()
+        }
+        PackageManager::Bun => "      - uses: oven-sh/setup-bun@v2\n".to_string(),
+    };
+
+    format!(
+        r#"name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+{setup}      - run: {install}
+      - run: {smoke}
+"#,
+        setup = setup,
+        install = install_command(package_manager),
+        smoke = run_script_command(package_manager, "smoke"),
+    )
+}
+
+fn ensure_trailing_newline(contents: &str) -> String {
+    if contents.ends_with('\n') {
+        contents.to_string()
+    } else {
+        format!("{contents}\n")
+    }
+}
+
+fn template_kind(template: &str) -> InitTemplateKind {
+    if template == NATIVE_TEMPLATE_NAME {
+        InitTemplateKind::Native
+    } else {
+        InitTemplateKind::Forge
+    }
+}
+
+fn detect_package_manager(cwd: &Path) -> PackageManager {
+    if cwd.join("pnpm-lock.yaml").exists() {
+        PackageManager::Pnpm
+    } else if cwd.join("yarn.lock").exists() {
+        PackageManager::Yarn
+    } else if cwd.join("bun.lock").exists() || cwd.join("bun.lockb").exists() {
+        PackageManager::Bun
+    } else {
+        PackageManager::Npm
+    }
+}
+
+fn install_command(package_manager: PackageManager) -> String {
+    match package_manager {
+        PackageManager::Npm => "npm install".to_string(),
+        PackageManager::Pnpm => "pnpm install".to_string(),
+        PackageManager::Yarn => "yarn install".to_string(),
+        PackageManager::Bun => "bun install".to_string(),
+    }
+}
+
+fn start_command(package_manager: PackageManager) -> String {
+    match package_manager {
+        PackageManager::Npm => "npm start".to_string(),
+        PackageManager::Pnpm => "pnpm start".to_string(),
+        PackageManager::Yarn => "yarn start".to_string(),
+        PackageManager::Bun => "bun run start".to_string(),
+    }
+}
+
+fn run_script_command(package_manager: PackageManager, script: &str) -> String {
+    match package_manager {
+        PackageManager::Npm => format!("npm run {script}"),
+        PackageManager::Pnpm => format!("pnpm run {script}"),
+        PackageManager::Yarn => format!("yarn {script}"),
+        PackageManager::Bun => format!("bun run {script}"),
+    }
+}
+
+fn package_manager_from_str(package_manager: &str) -> Result<PackageManager> {
+    match package_manager {
+        "npm" => Ok(PackageManager::Npm),
+        "pnpm" => Ok(PackageManager::Pnpm),
+        "yarn" => Ok(PackageManager::Yarn),
+        "bun" => Ok(PackageManager::Bun),
+        _ => bail!("Unknown package manager in init plan: {package_manager}"),
+    }
+}
+
+fn display_command(command: &[String]) -> String {
+    command
+        .iter()
+        .map(|arg| shell_quote(arg))
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+fn shell_quote(value: &str) -> String {
+    if value
+        .chars()
+        .all(|char| char.is_ascii_alphanumeric() || matches!(char, '.' | '/' | '-' | '_' | '@'))
+    {
+        value.to_string()
+    } else {
+        format!("'{}'", value.replace('\'', "'\\''"))
+    }
+}
+
+fn path_arg(path: &Path) -> String {
+    path.to_string_lossy().to_string()
+}
+
+fn package_name(plan: &InitReport) -> String {
+    let raw_name = Path::new(plan.target_dir.as_str())
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("electron-app");
+
+    sanitize_package_name(raw_name)
+}
+
+fn sanitize_package_name(raw_name: &str) -> String {
+    let name = raw_name
+        .to_ascii_lowercase()
+        .chars()
+        .map(|char| {
+            if char.is_ascii_alphanumeric() || matches!(char, '-' | '_' | '.') {
+                char
+            } else {
+                '-'
+            }
+        })
+        .collect::<String>()
+        .trim_matches(['-', '.', '_'])
+        .to_string();
+
+    if name.is_empty() {
+        "electron-app".to_string()
+    } else {
+        name
+    }
+}
+
+fn utf8_path(path: PathBuf) -> Result<Utf8PathBuf> {
+    Utf8PathBuf::from_path_buf(path).map_err(|path| {
+        anyhow::anyhow!(
+            "Path contains invalid UTF-8 and cannot be represented in JSON: {}",
+            path.display()
+        )
+    })
+}
+
+impl InitStatus {
+    fn as_str(&self) -> &'static str {
+        match self {
+            InitStatus::Planned => "planned",
+            InitStatus::Created => "created",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builds_default_npm_init_plan() {
+        let args = InitArgs {
+            dir: PathBuf::from("my-app"),
+            cwd: PathBuf::from(env!("CARGO_MANIFEST_DIR")),
+            template: "minimal".to_string(),
+            package_manager: Some(PackageManager::Npm),
+            electron_version: None,
+            copy_ci_files: false,
+            force: false,
+            skip_git: true,
+            dry_run: true,
+            json: true,
+        };
+
+        let plan = build_plan(&args).expect("plan should build");
+
+        assert_eq!(plan.template_kind, InitTemplateKind::Native);
+        assert_eq!(plan.generator, "electron-cli");
+        assert!(plan.command.is_empty());
+        assert!(plan.create_files.contains(&"package.json".to_string()));
+        assert_eq!(plan.package_manager, "npm");
+        assert_eq!(
+            plan.next_steps.first().map(String::as_str),
+            Some("cd my-app")
+        );
+        assert_eq!(
+            plan.next_steps.get(1).map(String::as_str),
+            Some("npm install")
+        );
+    }
+
+    #[test]
+    fn includes_optional_forge_create_flags() {
+        let args = InitArgs {
+            dir: PathBuf::from("desktop app"),
+            cwd: PathBuf::from(env!("CARGO_MANIFEST_DIR")),
+            template: "webpack".to_string(),
+            package_manager: Some(PackageManager::Pnpm),
+            electron_version: Some("latest".to_string()),
+            copy_ci_files: true,
+            force: true,
+            skip_git: true,
+            dry_run: true,
+            json: false,
+        };
+
+        let plan = build_plan(&args).expect("plan should build");
+
+        assert_eq!(plan.template_kind, InitTemplateKind::Forge);
+        assert_eq!(plan.generator, "create-electron-app@latest");
+        assert_eq!(plan.command[0], "pnpm");
+        assert!(plan.command.contains(&"--copy-ci-files".to_string()));
+        assert!(plan.command.contains(&"--force".to_string()));
+        assert!(plan.command.contains(&"--electron-version".to_string()));
+        assert!(plan.command_display.contains("'desktop app'"));
+        assert_eq!(
+            plan.next_steps.get(1).map(String::as_str),
+            Some("pnpm start")
+        );
+    }
+
+    #[test]
+    fn writes_native_template_files() {
+        let cwd = unique_temp_dir();
+        let args = InitArgs {
+            dir: PathBuf::from("native app"),
+            cwd: cwd.clone(),
+            template: "minimal".to_string(),
+            package_manager: Some(PackageManager::Npm),
+            electron_version: Some("30.0.0".to_string()),
+            copy_ci_files: true,
+            force: false,
+            skip_git: true,
+            dry_run: false,
+            json: false,
+        };
+
+        let plan = build_plan(&args).expect("plan should build");
+        ensure_target_can_be_created(&plan, args.force).expect("target should be available");
+        execute_plan(&plan).expect("template should write");
+        write_project_config(&plan).expect("config should write");
+
+        let target = cwd.join("native app");
+        let package_json =
+            fs::read_to_string(target.join("package.json")).expect("package.json should exist");
+        let config =
+            fs::read_to_string(target.join(".electron-cli.json")).expect("config should exist");
+
+        assert!(target.join("src/main.js").exists());
+        assert!(target.join("src/preload.js").exists());
+        assert!(target.join("src/index.html").exists());
+        assert!(target.join("src/renderer.js").exists());
+        assert!(target.join(".github/workflows/ci.yml").exists());
+        assert!(package_json.contains("\"name\": \"native-app\""));
+        assert!(package_json.contains("\"electron\": \"30.0.0\""));
+        assert!(config.contains("\"generator\": \"electron-cli\""));
+
+        let _ = fs::remove_dir_all(cwd);
+    }
+
+    #[test]
+    fn sanitizes_package_names() {
+        assert_eq!(sanitize_package_name("Native App"), "native-app");
+        assert_eq!(sanitize_package_name("..."), "electron-app");
+        assert_eq!(sanitize_package_name("@Scope/App"), "scope-app");
+    }
+
+    fn unique_temp_dir() -> PathBuf {
+        let nanos = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("clock should be after epoch")
+            .as_nanos();
+        let path = std::env::temp_dir().join(format!(
+            "electron-cli-init-test-{}-{nanos}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&path).expect("temp dir should be created");
+        path
+    }
+}