feat(cli): plugin add command (#7023)

Author: lucasfernog

.changes/add-command.md

@@ -0,0 +1,6 @@
+---
+"cli.rs": patch
+"cli.js": patch
+---
+
+Added `tauri plugin add` command to add a plugin to the Tauri project.

tooling/cli/src/helpers/mod.rs

@@ -6,13 +6,15 @@ pub mod app_paths;
 pub mod config;
 pub mod flock;
 pub mod framework;
+pub mod npm;
 pub mod template;
 pub mod updater_signature;
 pub mod web_dev_server;
 
 use std::{
   collections::HashMap,
   path::{Path, PathBuf},
+  process::Command,
 };
 
 pub fn command_env(debug: bool) -> HashMap<&'static str, String> {
@@ -38,3 +40,15 @@ pub fn resolve_tauri_path<P: AsRef<Path>>(path: P, crate_name: &str) -> PathBuf
     PathBuf::from("..").join(path).join(crate_name)
   }
 }
+
+pub fn cross_command(bin: &str) -> Command {
+  #[cfg(target_os = "windows")]
+  let cmd = {
+    let mut cmd = Command::new("cmd");
+    cmd.arg("/c").arg(bin);
+    cmd
+  };
+  #[cfg(not(target_os = "windows"))]
+  let cmd = Command::new(bin);
+  cmd
+}

tooling/cli/src/helpers/npm.rs

@@ -0,0 +1,68 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use std::{fmt::Display, path::Path};
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum PackageManager {
+  Npm,
+  Pnpm,
+  Yarn,
+  YarnBerry,
+}
+
+impl Display for PackageManager {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(
+      f,
+      "{}",
+      match self {
+        PackageManager::Npm => "npm",
+        PackageManager::Pnpm => "pnpm",
+        PackageManager::Yarn => "yarn",
+        PackageManager::YarnBerry => "yarn berry",
+      }
+    )
+  }
+}
+
+impl PackageManager {
+  pub fn from_project<P: AsRef<Path>>(path: P) -> Vec<Self> {
+    let mut use_npm = false;
+    let mut use_pnpm = false;
+    let mut use_yarn = false;
+
+    if let Ok(entries) = std::fs::read_dir(path) {
+      for entry in entries.flatten() {
+        let path = entry.path();
+        let name = path.file_name().unwrap().to_string_lossy();
+        if name.as_ref() == "package-lock.json" {
+          use_npm = true;
+        } else if name.as_ref() == "pnpm-lock.yaml" {
+          use_pnpm = true;
+        } else if name.as_ref() == "yarn.lock" {
+          use_yarn = true;
+        }
+      }
+    }
+
+    if !use_npm && !use_pnpm && !use_yarn {
+      return Vec::new();
+    }
+
+    let mut found = Vec::new();
+
+    if use_npm {
+      found.push(PackageManager::Npm);
+    }
+    if use_pnpm {
+      found.push(PackageManager::Pnpm);
+    }
+    if use_yarn {
+      found.push(PackageManager::Yarn);
+    }
+
+    found
+  }
+}

tooling/cli/src/info/env_nodejs.rs

@@ -2,10 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use super::{cross_command, VersionMetadata};
+use super::VersionMetadata;
 use super::{SectionItem, Status};
 use colored::Colorize;
 
+use crate::helpers::cross_command;
+
 pub fn items(metadata: &VersionMetadata) -> (Vec<SectionItem>, Option<String>) {
   let yarn_version = cross_command("yarn")
     .arg("-v")

tooling/cli/src/info/mod.rs

@@ -10,7 +10,6 @@ use serde::Deserialize;
 use std::{
   fmt::{self, Display, Formatter},
   panic,
-  process::Command,
 };
 
 mod app;
@@ -73,18 +72,6 @@ pub(crate) fn cli_upstream_version() -> Result<String> {
     .map_err(|e| anyhow::Error::new(e))
 }
 
-pub fn cross_command(bin: &str) -> Command {
-  #[cfg(target_os = "windows")]
-  let cmd = {
-    let mut cmd = Command::new("cmd");
-    cmd.arg("/c").arg(bin);
-    cmd
-  };
-  #[cfg(not(target_os = "windows"))]
-  let cmd = Command::new(bin);
-  cmd
-}
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
 pub enum Status {
   Neutral = 0,

tooling/cli/src/info/packages_nodejs.rs

@@ -2,41 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use super::{cross_command, VersionMetadata};
+use super::VersionMetadata;
 use super::{SectionItem, Status};
 use colored::Colorize;
 use serde::Deserialize;
-use std::fmt::Display;
 use std::path::{Path, PathBuf};
 
+use crate::helpers::{cross_command, npm::PackageManager};
+
 #[derive(Deserialize)]
 struct YarnVersionInfo {
   data: Vec<String>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-enum PackageManager {
-  Npm,
-  Pnpm,
-  Yarn,
-  YarnBerry,
-}
-
-impl Display for PackageManager {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    write!(
-      f,
-      "{}",
-      match self {
-        PackageManager::Npm => "npm",
-        PackageManager::Pnpm => "pnpm",
-        PackageManager::Yarn => "yarn",
-        PackageManager::YarnBerry => "yarn berry",
-      }
-    )
-  }
-}
-
 fn npm_latest_version(pm: &PackageManager, name: &str) -> crate::Result<Option<String>> {
   match pm {
     PackageManager::Yarn => {
@@ -154,74 +132,36 @@ fn npm_package_version<P: AsRef<Path>>(
   }
 }
 
-fn get_package_manager<T: AsRef<str>>(app_dir_entries: &[T]) -> PackageManager {
-  let mut use_npm = false;
-  let mut use_pnpm = false;
-  let mut use_yarn = false;
-
-  for name in app_dir_entries {
-    if name.as_ref() == "package-lock.json" {
-      use_npm = true;
-    } else if name.as_ref() == "pnpm-lock.yaml" {
-      use_pnpm = true;
-    } else if name.as_ref() == "yarn.lock" {
-      use_yarn = true;
-    }
-  }
-
-  if !use_npm && !use_pnpm && !use_yarn {
-    println!(
-      "{}: no lock files found, defaulting to npm",
-      "WARNING".yellow()
-    );
-    return PackageManager::Npm;
-  }
-
-  let mut found = Vec::new();
-
-  if use_npm {
-    found.push(PackageManager::Npm);
-  }
-  if use_pnpm {
-    found.push(PackageManager::Pnpm);
-  }
-  if use_yarn {
-    found.push(PackageManager::Yarn);
-  }
-
-  if found.len() > 1 {
-    let pkg_manger = found[0];
-    println!(
-      "{}: Only one package manager should be used, but found {}.\n         Please remove unused package manager lock files, will use {} for now!",
-      "WARNING".yellow(),
-      found.iter().map(ToString::to_string).collect::<Vec<_>>().join(" and "),
-      pkg_manger
-    );
-    return pkg_manger;
-  }
-
-  if use_npm {
-    PackageManager::Npm
-  } else if use_pnpm {
-    PackageManager::Pnpm
-  } else {
-    PackageManager::Yarn
-  }
-}
-
 pub fn items(
   app_dir: Option<&PathBuf>,
   metadata: &VersionMetadata,
   yarn_version: Option<String>,
 ) -> Vec<SectionItem> {
-  let mut package_manager = PackageManager::Npm;
-  if let Some(app_dir) = &app_dir {
-    let app_dir_entries = std::fs::read_dir(app_dir)
-      .unwrap()
-      .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
-      .collect::<Vec<String>>();
-    package_manager = get_package_manager(&app_dir_entries);
-  }
+  let package_managers = app_dir
+    .map(PackageManager::from_project)
+    .unwrap_or_else(|| {
+      println!(
+        "{}: no lock files found, defaulting to npm",
+        "WARNING".yellow()
+      );
+      vec![PackageManager::Npm]
+    });
+
+  let mut package_manager = if package_managers.len() > 1 {
+    let pkg_manager = package_managers[0];
+    println!(
+          "{}: Only one package manager should be used, but found {}.\n         Please remove unused package manager lock files, will use {} for now!",
+          "WARNING".yellow(),
+          package_managers.iter().map(ToString::to_string).collect::<Vec<_>>().join(" and "),
+          pkg_manager
+        );
+    pkg_manager
+  } else {
+    package_managers
+      .into_iter()
+      .next()
+      .unwrap_or(PackageManager::Npm)
+  };
 
   if package_manager == PackageManager::Yarn
     && yarn_version

tooling/cli/src/plugin.rs

@@ -6,6 +6,7 @@ use clap::{Parser, Subcommand};
 
 use crate::Result;
 
+mod add;
 mod android;
 mod init;
 mod ios;
@@ -26,13 +27,15 @@ pub struct Cli {
 #[derive(Subcommand)]
 enum Commands {
   Init(init::Options),
+  Add(add::Options),
   Android(android::Cli),
   Ios(ios::Cli),
 }
 
 pub fn command(cli: Cli) -> Result<()> {
   match cli.command {
     Commands::Init(options) => init::command(options)?,
+    Commands::Add(options) => add::command(options)?,
     Commands::Android(cli) => android::command(cli)?,
     Commands::Ios(cli) => ios::command(cli)?,
   }