electron-cli 0.3.0-alpha.2 → 0.3.0-alpha.20

package/src/commands/init.rs

@@ -13,22 +13,40 @@ use crate::{
     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 {
@@ -39,9 +57,10 @@ enum InitStatus {
 #[derive(Debug, Serialize)]
 struct ElectronCliConfig {
     version: &'static str,
-    generator: &'static str,
+    generator: String,
     template: String,
     package_manager: String,
+    electron_version: Option<String>,
 }
 
 pub fn run(args: InitArgs) -> Result<()> {
@@ -79,8 +98,31 @@ fn build_plan(args: &InitArgs) -> Result<InitReport> {
     let package_manager = args
         .package_manager
         .unwrap_or_else(|| detect_package_manager(&cwd));
-    let command = create_command(package_manager, &target_arg, args);
-    let command_display = display_command(&command);
+    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();
@@ -92,31 +134,46 @@ fn build_plan(args: &InitArgs) -> Result<InitReport> {
     }
 
     if target_dir.exists() && !args.force {
-        warnings
-            .push("Use --force to allow create-electron-app to overwrite the target.".to_string());
+        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: vec![
-            format!("cd {target_label}"),
-            start_command(package_manager),
-            "electron-cli doctor --json".to_string(),
-        ],
+        next_steps,
         warnings,
         status: InitStatus::Planned,
     })
 }
 
-fn create_command(
+fn create_forge_command(
     package_manager: PackageManager,
     target_arg: &str,
     args: &InitArgs,
@@ -171,6 +228,13 @@ fn create_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()
@@ -195,6 +259,10 @@ fn execute_plan(plan: &InitReport) -> Result<()> {
 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.",
@@ -208,9 +276,10 @@ fn ensure_target_can_be_created(plan: &InitReport, force: bool) -> Result<()> {
 fn write_project_config(plan: &InitReport) -> Result<()> {
     let config = ElectronCliConfig {
         version: env!("CARGO_PKG_VERSION"),
-        generator: "create-electron-app@latest",
+        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)?;
@@ -232,13 +301,25 @@ fn print_report(report: &InitReport, json: bool) -> Result<()> {
     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!("Command");
+    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");
@@ -266,6 +347,203 @@ fn print_report(report: &InitReport, json: bool) -> Result<()> {
     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 product_name = product_name(package_name);
+    let app_bundle_id = format!("com.electron.{package_name}");
+    let package = serde_json::json!({
+        "name": package_name,
+        "productName": product_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
+        },
+        "electronCli": {
+            "packagerConfig": {
+                "appBundleId": app_bundle_id
+            }
+        }
+    });
+
+    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
@@ -278,6 +556,15 @@ fn detect_package_manager(cwd: &Path) -> PackageManager {
     }
 }
 
+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(),
@@ -287,6 +574,25 @@ fn start_command(package_manager: PackageManager) -> 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()
@@ -310,6 +616,56 @@ 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 product_name(package_name: &str) -> String {
+    package_name
+        .split(['-', '_', '.'])
+        .filter(|part| !part.is_empty())
+        .map(|part| {
+            let mut chars = part.chars();
+            match chars.next() {
+                Some(first) => {
+                    let mut word = first.to_uppercase().collect::<String>();
+                    word.push_str(chars.as_str());
+                    word
+                }
+                None => String::new(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
 fn utf8_path(path: PathBuf) -> Result<Utf8PathBuf> {
     Utf8PathBuf::from_path_buf(path).map_err(|path| {
         anyhow::anyhow!(
@@ -337,7 +693,7 @@ mod tests {
         let args = InitArgs {
             dir: PathBuf::from("my-app"),
             cwd: PathBuf::from(env!("CARGO_MANIFEST_DIR")),
-            template: "vite-typescript".to_string(),
+            template: "minimal".to_string(),
             package_manager: Some(PackageManager::Npm),
             electron_version: None,
             copy_ci_files: false,
@@ -349,27 +705,23 @@ mod tests {
 
         let plan = build_plan(&args).expect("plan should build");
 
-        assert_eq!(
-            plan.command,
-            vec![
-                "npx",
-                "-y",
-                "create-electron-app@latest",
-                "my-app",
-                "--template",
-                "vite-typescript",
-                "--skip-git",
-            ]
-        );
+        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_create_flags() {
+    fn includes_optional_forge_create_flags() {
         let args = InitArgs {
             dir: PathBuf::from("desktop app"),
             cwd: PathBuf::from(env!("CARGO_MANIFEST_DIR")),
@@ -385,6 +737,8 @@ mod tests {
 
         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()));
@@ -395,4 +749,66 @@ mod tests {
             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("\"productName\": \"Native App\""));
+        assert!(package_json.contains("\"electron\": \"30.0.0\""));
+        assert!(package_json.contains("\"appBundleId\": \"com.electron.native-app\""));
+        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");
+        assert_eq!(product_name("native-app"), "Native 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
+    }
 }