refactor(cli): set binary name on dev (#4447)

Author: lucasfernog

.changes/dev-bin-name.md

@@ -0,0 +1,6 @@
+---
+"cli.rs": patch
+"cli.js": patch
+---
+
+Set the binary name to the product name in development.

examples/api/src-tauri/Cargo.lock

@@ -2,57 +2,59 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use crate::helpers::{
-  app_paths::{app_dir, tauri_dir},
-  command_env,
-  config::{get as get_config, AppUrl, WindowUrl},
-  manifest::rewrite_manifest,
-  updater_signature::sign_file_from_env_variables,
+use crate::{
+  helpers::{
+    app_paths::{app_dir, tauri_dir},
+    command_env,
+    config::{get as get_config, AppUrl, WindowUrl},
+    manifest::rewrite_manifest,
+    updater_signature::sign_file_from_env_variables,
+  },
+  interface::{AppInterface, AppSettings, Interface},
+  CommandExt, Result,
 };
-use crate::{CommandExt, Result};
 use anyhow::{bail, Context};
 use clap::Parser;
-#[cfg(target_os = "linux")]
-use heck::ToKebabCase;
 use log::warn;
 use log::{error, info};
-use std::{env::set_current_dir, fs::rename, path::PathBuf, process::Command};
+use std::{env::set_current_dir, path::PathBuf, process::Command};
 use tauri_bundler::bundle::{bundle_project, PackageType};
 
-#[derive(Debug, Parser)]
+#[derive(Debug, Clone, Parser)]
 #[clap(about = "Tauri build")]
 pub struct Options {
   /// Binary to use to build the application, defaults to `cargo`
   #[clap(short, long)]
-  runner: Option<String>,
+  pub runner: Option<String>,
   /// Builds with the debug flag
   #[clap(short, long)]
-  debug: bool,
+  pub debug: bool,
   /// Target triple to build against.
   ///
   /// It must be one of the values outputted by `$rustc --print target-list` or `universal-apple-darwin` for an universal macOS application.
   ///
   /// Note that compiling an universal macOS application requires both `aarch64-apple-darwin` and `x86_64-apple-darwin` targets to be installed.
   #[clap(short, long)]
-  target: Option<String>,
+  pub target: Option<String>,
   /// Space or comma separated list of features to activate
   #[clap(short, long, multiple_occurrences(true), multiple_values(true))]
-  features: Option<Vec<String>>,
+  pub features: Option<Vec<String>>,
   /// Space or comma separated list of bundles to package.
   ///
   /// Each bundle must be one of `deb`, `appimage`, `msi`, `app` or `dmg` on MacOS and `updater` on all platforms.
+  /// If `none` is specified, the bundler will be skipped.
   ///
   /// Note that the `updater` bundle is not automatically added so you must specify it if the updater is enabled.
   #[clap(short, long, multiple_occurrences(true), multiple_values(true))]
-  bundles: Option<Vec<String>>,
+  pub bundles: Option<Vec<String>>,
   /// JSON string or path to JSON file to merge with tauri.conf.json
   #[clap(short, long)]
-  config: Option<String>,
+  pub config: Option<String>,
   /// Command line arguments passed to the runner
-  args: Vec<String>,
+  pub args: Vec<String>,
 }
 
-pub fn command(options: Options) -> Result<()> {
+pub fn command(mut options: Options) -> Result<()> {
   let merge_config = if let Some(config) = &options.config {
     Some(if config.starts_with('{') {
       config.to_string()
@@ -150,116 +152,30 @@ pub fn command(options: Options) -> Result<()> {
     }
   }
 
-  let runner_from_config = config_.build.runner.clone();
-  let runner = options
-    .runner
-    .or(runner_from_config)
-    .unwrap_or_else(|| "cargo".to_string());
-
-  let mut features = config_.build.features.clone().unwrap_or_default();
-  if let Some(list) = options.features {
-    features.extend(list);
-  }
-
-  let mut args = Vec::new();
-  if !options.args.is_empty() {
-    args.extend(options.args);
-  }
-
-  if !features.is_empty() {
-    args.push("--features".into());
-    args.push(features.join(","));
-  }
-
-  if !options.debug {
-    args.push("--release".into());
-  }
-
-  let app_settings = crate::interface::rust::AppSettings::new(config_)?;
-
-  let out_dir = app_settings
-    .get_out_dir(options.target.clone(), options.debug)
-    .with_context(|| "failed to get project out directory")?;
-
-  let bin_name = app_settings
-    .cargo_package_settings()
-    .name
-    .clone()
-    .expect("Cargo manifest must have the `package.name` field");
-
-  let target: String = if let Some(target) = options.target.clone() {
-    target
-  } else {
-    tauri_utils::platform::target_triple()?
-  };
-  let binary_extension: String = if target.contains("windows") {
-    "exe"
-  } else {
-    ""
+  if options.runner.is_none() {
+    options.runner = config_.build.runner.clone();
   }
-  .into();
-
-  let bin_path = out_dir.join(&bin_name).with_extension(&binary_extension);
-
-  let no_default_features = args.contains(&"--no-default-features".into());
-
-  if options.target == Some("universal-apple-darwin".into()) {
-    std::fs::create_dir_all(&out_dir).with_context(|| "failed to create project out directory")?;
-
-    let mut lipo_cmd = Command::new("lipo");
-    lipo_cmd
-      .arg("-create")
-      .arg("-output")
-      .arg(out_dir.join(&bin_name));
-    for triple in ["aarch64-apple-darwin", "x86_64-apple-darwin"] {
-      let mut args_ = args.clone();
-      args_.push("--target".into());
-      args_.push(triple.into());
-      crate::interface::rust::build_project(runner.clone(), args_)
-        .with_context(|| format!("failed to build {} binary", triple))?;
-      let triple_out_dir = app_settings
-        .get_out_dir(Some(triple.into()), options.debug)
-        .with_context(|| format!("failed to get {} out dir", triple))?;
-      lipo_cmd.arg(triple_out_dir.join(&bin_name));
-    }
 
-    let lipo_status = lipo_cmd.status()?;
-    if !lipo_status.success() {
-      return Err(anyhow::anyhow!(format!(
-        "Result of `lipo` command was unsuccessful: {}. (Is `lipo` installed?)",
-        lipo_status
-      )));
-    }
-  } else {
-    if let Some(target) = &options.target {
-      args.push("--target".into());
-      args.push(target.clone());
-    }
-    crate::interface::rust::build_project(runner, args).with_context(|| "failed to build app")?;
+  if let Some(list) = options.features.as_mut() {
+    list.extend(config_.build.features.clone().unwrap_or_default());
   }
 
-  if let Some(product_name) = config_.package.product_name.clone() {
-    #[cfg(target_os = "linux")]
-    let product_name = product_name.to_kebab_case();
+  let interface = AppInterface::new(config_)?;
+  let app_settings = interface.app_settings();
+  let interface_options = options.clone().into();
 
-    let product_path = out_dir
-      .join(&product_name)
-      .with_extension(&binary_extension);
+  let bin_path = app_settings.app_binary_path(&interface_options)?;
+  let out_dir = bin_path.parent().unwrap();
 
-    rename(&bin_path, &product_path).with_context(|| {
-      format!(
-        "failed to rename `{}` to `{}`",
-        bin_path.display(),
-        product_path.display(),
-      )
-    })?;
-  }
+  interface
+    .build(interface_options)
+    .with_context(|| "failed to build app")?;
 
   if config_.tauri.bundle.active {
-    let package_types = if let Some(names) = options.bundles {
+    let package_types = if let Some(names) = &options.bundles {
       let mut types = vec![];
       for name in names
-        .into_iter()
+        .iter()
         .flat_map(|n| n.split(',').map(|s| s.to_string()).collect::<Vec<String>>())
       {
         if name == "none" {
@@ -293,20 +209,9 @@ pub fn command(options: Options) -> Result<()> {
       }
     }
 
-    let mut enabled_features = features.clone();
-    if !no_default_features {
-      enabled_features.push("default".into());
-    }
-    let settings = crate::interface::get_bundler_settings(
-      app_settings,
-      target,
-      &enabled_features,
-      &manifest,
-      config_,
-      &out_dir,
-      package_types,
-    )
-    .with_context(|| "failed to build bundler settings")?;
+    let settings = app_settings
+      .get_bundler_settings(&options.into(), &manifest, config_, out_dir, package_types)
+      .with_context(|| "failed to build bundler settings")?;
 
     // set env vars used by the bundler
     #[cfg(target_os = "linux")]