feat: improve platform integration and release packaging

This commit is contained in:
Kevin Yue committed 2026-07-26 23:22:57 +08:00
1 parent c0c517806e
commit 2ca6b80728
17 files changed
+357 -105

No files matched your search

+14 -96
View File
@@ -1,17 +1,10 @@
#[cfg(feature = "launcher")]
use log::info;
#[cfg(all(feature = "launcher", target_os = "macos"))]
#[path = "platform/macos.rs"]
mod platform;
#[cfg(any(feature = "launcher", test))]
const CHROME_BROWSERS: &[&str] = &["google-chrome-stable", "google-chrome", "chromium"];
#[cfg(any(feature = "launcher", test))]
const EDGE_BROWSERS: &[&str] = &[
"microsoft-edge-stable",
"microsoft-edge",
"microsoft-edge-beta",
"microsoft-edge-dev",
];
#[cfg(any(feature = "launcher", test))]
const FIREFOX_BROWSER: &str = "firefox";
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
#[path = "platform/generic.rs"]
mod platform;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Browser<'a> {
@@ -20,6 +13,7 @@ pub enum Browser<'a> {
Chrome,
Edge,
Firefox,
Safari,
Other(&'a str),
}
@@ -39,18 +33,20 @@ impl<'a> Browser<'a> {
"chrome" => Browser::Chrome,
"edge" => Browser::Edge,
"firefox" => Browser::Firefox,
"safari" => Browser::Safari,
_ => Browser::Other(value),
}
}
#[cfg(feature = "launcher")]
fn as_str(&self) -> &str {
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
pub(crate) fn as_str(&self) -> &str {
match self {
Browser::Auto => "auto",
Browser::Default => "default",
Browser::Chrome => "chrome",
Browser::Edge => "edge",
Browser::Firefox => FIREFOX_BROWSER,
Browser::Firefox => "firefox",
Browser::Safari => "safari",
Browser::Other(browser) => browser,
}
}
@@ -58,62 +54,7 @@ impl<'a> Browser<'a> {
#[cfg(feature = "launcher")]
pub fn open_url(url: &str, browser: Browser<'_>) -> anyhow::Result<()> {
match browser {
Browser::Auto => {
if let Some(browser) = find_auto_browser() {
open_with_browser(url, &browser).or_else(|_| open_default_browser(url))
} else {
open_default_browser(url)
}
}
Browser::Default => open_default_browser(url),
Browser::Chrome => {
let browser = find_chrome_browser().unwrap_or_else(|| browser.as_str().to_string());
open_with_browser(url, &browser)
}
Browser::Edge => {
let browser = find_edge_browser().unwrap_or_else(|| browser.as_str().to_string());
open_with_browser(url, &browser)
}
Browser::Firefox | Browser::Other(_) => open_with_browser(url, browser.as_str()),
}
}
#[cfg(feature = "launcher")]
fn open_default_browser(url: &str) -> anyhow::Result<()> {
if webbrowser::open(url).is_ok() {
return Ok(());
}
open::that_detached(url).map_err(Into::into)
}
#[cfg(feature = "launcher")]
fn open_with_browser(url: &str, browser: &str) -> anyhow::Result<()> {
info!("Launching browser: {}", browser);
open::with_detached(url, browser).map_err(Into::into)
}
#[cfg(feature = "launcher")]
fn find_auto_browser() -> Option<String> {
find_chrome_browser()
.or_else(find_edge_browser)
.or_else(|| find_program(FIREFOX_BROWSER))
}
#[cfg(feature = "launcher")]
fn find_chrome_browser() -> Option<String> {
CHROME_BROWSERS.iter().find_map(|browser| find_program(browser))
}
#[cfg(feature = "launcher")]
fn find_edge_browser() -> Option<String> {
EDGE_BROWSERS.iter().find_map(|browser| find_program(browser))
}
#[cfg(feature = "launcher")]
fn find_program(name: &str) -> Option<String> {
which::which(name).ok().map(|path| path.to_string_lossy().to_string())
platform::open_url(url, browser)
}
#[cfg(test)]
@@ -134,6 +75,7 @@ mod tests {
assert_eq!(Browser::from_name("Chrome"), Browser::Chrome);
assert_eq!(Browser::from_name("EDGE"), Browser::Edge);
assert_eq!(Browser::from_name("Firefox"), Browser::Firefox);
assert_eq!(Browser::from_name("Safari"), Browser::Safari);
}
#[test]
@@ -144,28 +86,4 @@ mod tests {
Browser::Other(" custom-browser ")
);
}
#[test]
fn auto_candidates_try_chrome_then_edge_then_firefox() {
let candidates = CHROME_BROWSERS
.iter()
.chain(EDGE_BROWSERS)
.chain([FIREFOX_BROWSER].iter())
.copied()
.collect::<Vec<_>>();
assert_eq!(
candidates,
vec![
"google-chrome-stable",
"google-chrome",
"chromium",
"microsoft-edge-stable",
"microsoft-edge",
"microsoft-edge-beta",
"microsoft-edge-dev",
"firefox",
]
);
}
}
@@ -0,0 +1,269 @@
use std::process::{Command, Stdio};
use log::{debug, info, warn};
use crate::Browser;
const GOOGLE_CHROME_BROWSERS: &[&str] = &["google-chrome-stable", "google-chrome"];
const CHROMIUM_BROWSERS: &[&str] = &["chromium", "chromium-browser"];
const EDGE_BROWSERS: &[&str] = &["microsoft-edge-stable", "microsoft-edge"];
const EDGE_BETA_BROWSERS: &[&str] = &["microsoft-edge-beta"];
const EDGE_DEV_BROWSERS: &[&str] = &["microsoft-edge-dev"];
const FIREFOX_BROWSERS: &[&str] = &["firefox"];
const FIREFOX_ESR_BROWSERS: &[&str] = &["firefox-esr"];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LauncherSpec {
Programs(&'static [&'static str]),
Flatpak(&'static str),
}
#[derive(Debug, PartialEq, Eq)]
enum BrowserLauncher {
Executable(String),
Flatpak { executable: String, app_id: &'static str },
}
pub(super) fn open_url(url: &str, browser: Browser<'_>) -> anyhow::Result<()> {
match browser {
Browser::Auto => open_auto_browser(url),
Browser::Default => open_default_browser(url),
Browser::Chrome => {
let browser = find_chrome_browser().unwrap_or_else(|| browser.as_str().to_string());
open_with_browser(url, &browser)
}
Browser::Edge => {
let browser = find_edge_browser().unwrap_or_else(|| browser.as_str().to_string());
open_with_browser(url, &browser)
}
Browser::Firefox => {
let browser = find_firefox_browser().unwrap_or_else(|| browser.as_str().to_string());
open_with_browser(url, &browser)
}
Browser::Safari | Browser::Other(_) => open_with_browser(url, browser.as_str()),
}
}
fn open_auto_browser(url: &str) -> anyhow::Result<()> {
let default_launcher = find_default_browser_launcher();
if let Some(launcher) = default_launcher.as_ref() {
if let Err(err) = open_with_launcher(url, launcher) {
warn!("Failed to launch recognized default browser: {err}");
} else {
return Ok(());
}
}
if let Some(launcher) = find_auto_browser_launcher()
&& Some(&launcher) != default_launcher.as_ref()
{
if let Err(err) = open_with_launcher(url, &launcher) {
warn!("Failed to launch an automatically detected browser: {err}");
} else {
return Ok(());
}
}
warn!("Falling back to the system URL handler");
open_default_browser(url)
}
fn open_default_browser(url: &str) -> anyhow::Result<()> {
if webbrowser::open(url).is_ok() {
return Ok(());
}
open::that_detached(url).map_err(Into::into)
}
fn open_with_browser(url: &str, browser: &str) -> anyhow::Result<()> {
info!("Launching browser: {}", browser);
open::with_detached(url, browser).map_err(Into::into)
}
fn open_with_launcher(url: &str, launcher: &BrowserLauncher) -> anyhow::Result<()> {
match launcher {
BrowserLauncher::Executable(executable) => open_with_browser(url, executable),
BrowserLauncher::Flatpak { executable, app_id } => {
info!("Launching Flatpak browser: {app_id}");
Command::new(executable)
.args(["run", app_id, url])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()?;
Ok(())
}
}
}
fn find_default_browser_launcher() -> Option<BrowserLauncher> {
let desktop_id = default_browser_desktop_id()?;
let Some(spec) = launcher_spec_for_desktop_id(&desktop_id) else {
warn!("Default browser desktop ID is not recognized: {desktop_id}");
return None;
};
let launcher = resolve_launcher(spec);
if launcher.is_none() {
warn!("Default browser is recognized but its launcher is unavailable: {desktop_id}");
}
launcher
}
fn default_browser_desktop_id() -> Option<String> {
let output = match Command::new("xdg-settings")
.args(["get", "default-web-browser"])
.output()
{
Ok(output) => output,
Err(err) => {
debug!("Unable to query the default browser: {err}");
return None;
}
};
if !output.status.success() {
debug!("xdg-settings could not determine the default browser");
return None;
}
let desktop_id = String::from_utf8_lossy(&output.stdout).trim().to_string();
(!desktop_id.is_empty()).then_some(desktop_id)
}
fn launcher_spec_for_desktop_id(desktop_id: &str) -> Option<LauncherSpec> {
match desktop_id {
"google-chrome.desktop" | "google-chrome-stable.desktop" => Some(LauncherSpec::Programs(GOOGLE_CHROME_BROWSERS)),
"chromium.desktop" | "chromium-browser.desktop" | "chromium_chromium.desktop" => {
Some(LauncherSpec::Programs(CHROMIUM_BROWSERS))
}
"microsoft-edge.desktop" | "microsoft-edge-stable.desktop" => Some(LauncherSpec::Programs(EDGE_BROWSERS)),
"microsoft-edge-beta.desktop" => Some(LauncherSpec::Programs(EDGE_BETA_BROWSERS)),
"microsoft-edge-dev.desktop" => Some(LauncherSpec::Programs(EDGE_DEV_BROWSERS)),
"firefox.desktop" | "firefox_firefox.desktop" => Some(LauncherSpec::Programs(FIREFOX_BROWSERS)),
"firefox-esr.desktop" => Some(LauncherSpec::Programs(FIREFOX_ESR_BROWSERS)),
"com.google.Chrome.desktop" => Some(LauncherSpec::Flatpak("com.google.Chrome")),
"org.chromium.Chromium.desktop" => Some(LauncherSpec::Flatpak("org.chromium.Chromium")),
"com.microsoft.Edge.desktop" => Some(LauncherSpec::Flatpak("com.microsoft.Edge")),
"org.mozilla.firefox.desktop" => Some(LauncherSpec::Flatpak("org.mozilla.firefox")),
_ => None,
}
}
fn resolve_launcher(spec: LauncherSpec) -> Option<BrowserLauncher> {
match spec {
LauncherSpec::Programs(programs) => find_programs(programs).map(BrowserLauncher::Executable),
LauncherSpec::Flatpak(app_id) => {
find_program("flatpak").map(|executable| BrowserLauncher::Flatpak { executable, app_id })
}
}
}
fn find_auto_browser_launcher() -> Option<BrowserLauncher> {
find_auto_browser().map(BrowserLauncher::Executable)
}
fn find_auto_browser() -> Option<String> {
find_chrome_browser()
.or_else(find_edge_browser)
.or_else(find_firefox_browser)
}
fn find_chrome_browser() -> Option<String> {
find_programs(GOOGLE_CHROME_BROWSERS).or_else(|| find_programs(CHROMIUM_BROWSERS))
}
fn find_edge_browser() -> Option<String> {
find_programs(EDGE_BROWSERS)
.or_else(|| find_programs(EDGE_BETA_BROWSERS))
.or_else(|| find_programs(EDGE_DEV_BROWSERS))
}
fn find_firefox_browser() -> Option<String> {
find_programs(FIREFOX_BROWSERS).or_else(|| find_programs(FIREFOX_ESR_BROWSERS))
}
fn find_programs(programs: &[&str]) -> Option<String> {
programs.iter().find_map(|program| find_program(program))
}
fn find_program(name: &str) -> Option<String> {
which::which(name).ok().map(|path| path.to_string_lossy().to_string())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn auto_candidates_try_chrome_then_edge_then_firefox() {
let candidates = GOOGLE_CHROME_BROWSERS
.iter()
.chain(CHROMIUM_BROWSERS)
.chain(EDGE_BROWSERS)
.chain(EDGE_BETA_BROWSERS)
.chain(EDGE_DEV_BROWSERS)
.chain(FIREFOX_BROWSERS)
.chain(FIREFOX_ESR_BROWSERS)
.copied()
.collect::<Vec<_>>();
assert_eq!(
candidates,
vec![
"google-chrome-stable",
"google-chrome",
"chromium",
"chromium-browser",
"microsoft-edge-stable",
"microsoft-edge",
"microsoft-edge-beta",
"microsoft-edge-dev",
"firefox",
"firefox-esr",
]
);
}
#[test]
fn known_desktop_ids_map_to_expected_launchers() {
let cases = [
("google-chrome.desktop", LauncherSpec::Programs(GOOGLE_CHROME_BROWSERS)),
("chromium.desktop", LauncherSpec::Programs(CHROMIUM_BROWSERS)),
("chromium-browser.desktop", LauncherSpec::Programs(CHROMIUM_BROWSERS)),
("chromium_chromium.desktop", LauncherSpec::Programs(CHROMIUM_BROWSERS)),
("microsoft-edge.desktop", LauncherSpec::Programs(EDGE_BROWSERS)),
(
"microsoft-edge-beta.desktop",
LauncherSpec::Programs(EDGE_BETA_BROWSERS),
),
("microsoft-edge-dev.desktop", LauncherSpec::Programs(EDGE_DEV_BROWSERS)),
("firefox.desktop", LauncherSpec::Programs(FIREFOX_BROWSERS)),
("firefox-esr.desktop", LauncherSpec::Programs(FIREFOX_ESR_BROWSERS)),
("firefox_firefox.desktop", LauncherSpec::Programs(FIREFOX_BROWSERS)),
("com.google.Chrome.desktop", LauncherSpec::Flatpak("com.google.Chrome")),
(
"org.chromium.Chromium.desktop",
LauncherSpec::Flatpak("org.chromium.Chromium"),
),
(
"com.microsoft.Edge.desktop",
LauncherSpec::Flatpak("com.microsoft.Edge"),
),
(
"org.mozilla.firefox.desktop",
LauncherSpec::Flatpak("org.mozilla.firefox"),
),
];
for (desktop_id, expected) in cases {
assert_eq!(launcher_spec_for_desktop_id(desktop_id), Some(expected));
}
}
#[test]
fn unknown_desktop_id_is_not_used() {
assert_eq!(launcher_spec_for_desktop_id("code.desktop"), None);
}
}
@@ -0,0 +1,45 @@
use log::info;
use crate::Browser;
const SAFARI_BUNDLE_ID: &str = "com.apple.Safari";
const CHROME_BUNDLE_ID: &str = "com.google.Chrome";
const EDGE_BUNDLE_ID: &str = "com.microsoft.edgemac";
const FIREFOX_BUNDLE_ID: &str = "org.mozilla.firefox";
pub(super) fn open_url(url: &str, browser: Browser<'_>) -> anyhow::Result<()> {
match browser {
Browser::Auto | Browser::Default => open_default_browser(url),
Browser::Safari => open_browser_bundle(url, SAFARI_BUNDLE_ID),
Browser::Chrome => open_browser_bundle(url, CHROME_BUNDLE_ID),
Browser::Edge => open_browser_bundle(url, EDGE_BUNDLE_ID),
Browser::Firefox => open_browser_bundle(url, FIREFOX_BUNDLE_ID),
Browser::Other(application) => open_browser_application(url, application),
}
}
fn open_default_browser(url: &str) -> anyhow::Result<()> {
if webbrowser::open(url).is_ok() {
return Ok(());
}
open::that_detached(url).map_err(Into::into)
}
fn open_browser_bundle(url: &str, bundle_id: &str) -> anyhow::Result<()> {
info!("Launching browser bundle: {}", bundle_id);
let status = std::process::Command::new("/usr/bin/open")
.args(["-b", bundle_id, url])
.status()?;
if !status.success() {
anyhow::bail!("Failed to launch browser bundle {bundle_id}: {status}");
}
Ok(())
}
fn open_browser_application(url: &str, application: &str) -> anyhow::Result<()> {
info!("Launching browser application: {}", application);
open::with_detached(url, application).map_err(Into::into)
}