feat: prepare 3.0.0 release

This commit is contained in:
Kevin Yue committed 2026-10-09 18:21:44 +08:00
1 parent e98fd7894a
commit b7b708e9cd
252 files changed
+26210 -7457

No files matched your search

+19
View File
@@ -0,0 +1,19 @@
[package]
name = "browser-launcher"
rust-version.workspace = true
version.workspace = true
authors.workspace = true
homepage.workspace = true
edition.workspace = true
license = "MIT"
[dependencies]
anyhow.workspace = true
log.workspace = true
open = { version = "5", optional = true }
webbrowser = { version = "1", optional = true }
which = { workspace = true, optional = true }
[features]
default = []
launcher = ["dep:open", "dep:webbrowser", "dep:which"]
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2024 Kevin Yue
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+89
View File
@@ -0,0 +1,89 @@
#[cfg(all(feature = "launcher", target_os = "macos"))]
#[path = "platform/macos.rs"]
mod platform;
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
#[path = "platform/generic.rs"]
mod platform;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Browser<'a> {
Auto,
Default,
Chrome,
Edge,
Firefox,
Safari,
Other(&'a str),
}
impl<'a> Browser<'a> {
pub fn from_config(value: Option<&'a str>) -> Self {
let Some(value) = value.filter(|value| !value.trim().is_empty()) else {
return Browser::Auto;
};
Self::from_name(value)
}
pub fn from_name(value: &'a str) -> Self {
match value.trim().to_lowercase().as_str() {
"auto" => Browser::Auto,
"default" => Browser::Default,
"chrome" => Browser::Chrome,
"edge" => Browser::Edge,
"firefox" => Browser::Firefox,
"safari" => Browser::Safari,
_ => Browser::Other(value),
}
}
#[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::Safari => "safari",
Browser::Other(browser) => browser,
}
}
}
#[cfg(feature = "launcher")]
pub fn open_url(url: &str, browser: Browser<'_>) -> anyhow::Result<()> {
platform::open_url(url, browser)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty_config_uses_auto() {
assert_eq!(Browser::from_config(None), Browser::Auto);
assert_eq!(Browser::from_config(Some("")), Browser::Auto);
assert_eq!(Browser::from_config(Some(" ")), Browser::Auto);
}
#[test]
fn known_browser_names_are_case_insensitive() {
assert_eq!(Browser::from_name("AUTO"), Browser::Auto);
assert_eq!(Browser::from_name("Default"), Browser::Default);
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]
fn custom_browser_names_are_preserved() {
assert_eq!(Browser::from_name("/opt/browser"), Browser::Other("/opt/browser"));
assert_eq!(
Browser::from_config(Some(" custom-browser ")),
Browser::Other(" custom-browser ")
);
}
}
@@ -0,0 +1,467 @@
use std::{
os::unix::process::CommandExt,
process::{Command, Stdio},
};
use anyhow::Context;
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"];
const BRAVE_BROWSERS: &[&str] = &["brave-browser-stable"];
const VIVALDI_BROWSERS: &[&str] = &["vivaldi-stable"];
const FALKON_BROWSERS: &[&str] = &["falkon"];
const EPIPHANY_BROWSERS: &[&str] = &["epiphany"];
const OPERA_BROWSERS: &[&str] = &["opera"];
const LIBREWOLF_BROWSERS: &[&str] = &["librewolf"];
const WATERFOX_BROWSERS: &[&str] = &["waterfox"];
const QUTEBROWSER_BROWSERS: &[&str] = &["qutebrowser"];
const AUTO_BROWSER_PROGRAMS: &[&[&str]] = &[
GOOGLE_CHROME_BROWSERS,
CHROMIUM_BROWSERS,
EDGE_BROWSERS,
EDGE_BETA_BROWSERS,
EDGE_DEV_BROWSERS,
FIREFOX_BROWSERS,
FIREFOX_ESR_BROWSERS,
BRAVE_BROWSERS,
VIVALDI_BROWSERS,
FALKON_BROWSERS,
EPIPHANY_BROWSERS,
OPERA_BROWSERS,
LIBREWOLF_BROWSERS,
WATERFOX_BROWSERS,
QUTEBROWSER_BROWSERS,
];
const AUTO_BROWSER_FLATPAK_IDS: &[&str] = &[
"com.google.Chrome",
"org.chromium.Chromium",
"com.microsoft.Edge",
"org.mozilla.firefox",
"com.brave.Browser",
"com.vivaldi.Vivaldi",
"org.kde.falkon",
"org.gnome.Epiphany",
"com.opera.Opera",
"io.gitlab.librewolf-community",
"net.waterfox.waterfox",
"org.qutebrowser.qutebrowser",
];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LauncherSpec {
Programs(&'static [&'static str]),
Flatpak(&'static str),
ProgramsOrFlatpak {
programs: &'static [&'static str],
app_id: &'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 => open_resolved_browser(url, find_chrome_browser(), "Chrome is not available."),
Browser::Edge => open_resolved_browser(url, find_edge_browser(), "Edge is not available."),
Browser::Firefox => open_resolved_browser(url, find_firefox_browser(), "Firefox is not available."),
Browser::Safari => open_resolved_browser(url, find_program(browser.as_str()), "Safari is not available."),
Browser::Other(browser) => open_resolved_browser(
url,
find_program(browser.trim()),
"Configured browser is not available.",
),
}
}
fn open_resolved_browser(
url: &str,
executable: Option<String>,
unavailable_message: &'static str,
) -> anyhow::Result<()> {
let executable = executable.context(unavailable_message)?;
open_with_browser(url, &executable)
}
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])
.process_group(0)
.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::ProgramsOrFlatpak {
programs: FIREFOX_BROWSERS,
app_id: "org.mozilla.firefox",
}),
"com.brave.Browser.desktop" => Some(LauncherSpec::Flatpak("com.brave.Browser")),
"vivaldi-stable.desktop" => Some(LauncherSpec::Programs(VIVALDI_BROWSERS)),
"com.vivaldi.Vivaldi.desktop" => Some(LauncherSpec::Flatpak("com.vivaldi.Vivaldi")),
"org.kde.falkon.desktop" => Some(LauncherSpec::ProgramsOrFlatpak {
programs: FALKON_BROWSERS,
app_id: "org.kde.falkon",
}),
"org.gnome.Epiphany.desktop" => Some(LauncherSpec::ProgramsOrFlatpak {
programs: EPIPHANY_BROWSERS,
app_id: "org.gnome.Epiphany",
}),
"com.opera.Opera.desktop" => Some(LauncherSpec::Flatpak("com.opera.Opera")),
"io.gitlab.librewolf-community.desktop" => Some(LauncherSpec::Flatpak("io.gitlab.librewolf-community")),
"net.waterfox.waterfox.desktop" => Some(LauncherSpec::Flatpak("net.waterfox.waterfox")),
"org.qutebrowser.qutebrowser.desktop" => Some(LauncherSpec::ProgramsOrFlatpak {
programs: QUTEBROWSER_BROWSERS,
app_id: "org.qutebrowser.qutebrowser",
}),
_ => None,
}
}
fn resolve_launcher(spec: LauncherSpec) -> Option<BrowserLauncher> {
match spec {
LauncherSpec::Programs(programs) => find_programs(programs).map(BrowserLauncher::Executable),
LauncherSpec::Flatpak(app_id) => find_flatpak_browser(app_id),
LauncherSpec::ProgramsOrFlatpak { programs, app_id } => find_programs(programs)
.map(BrowserLauncher::Executable)
.or_else(|| find_flatpak_browser(app_id)),
}
}
fn find_flatpak_browser(app_id: &'static str) -> Option<BrowserLauncher> {
let executable = find_program("flatpak")?;
let installed = Command::new(&executable)
.args(["info", app_id])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.is_ok_and(|status| status.success());
installed.then_some(BrowserLauncher::Flatpak { executable, app_id })
}
fn find_auto_browser_launcher() -> Option<BrowserLauncher> {
find_auto_browser()
.map(BrowserLauncher::Executable)
.or_else(find_auto_flatpak_browser)
}
fn find_auto_browser() -> Option<String> {
AUTO_BROWSER_PROGRAMS
.iter()
.find_map(|programs| find_programs(programs))
}
fn find_auto_flatpak_browser() -> Option<BrowserLauncher> {
let executable = find_program("flatpak")?;
let output = Command::new(&executable)
.args(["list", "--app", "--columns=application"])
.stdin(Stdio::null())
.stderr(Stdio::null())
.output()
.ok()?;
if !output.status.success() {
return None;
}
let installed_apps = String::from_utf8_lossy(&output.stdout);
let app_id = find_auto_flatpak_app_id(&installed_apps)?;
Some(BrowserLauncher::Flatpak { executable, app_id })
}
fn find_auto_flatpak_app_id(installed_apps: &str) -> Option<&'static str> {
AUTO_BROWSER_FLATPAK_IDS
.iter()
.copied()
.find(|app_id| installed_apps.lines().any(|installed| installed.trim() == *app_id))
}
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_use_the_expected_order() {
let candidates = AUTO_BROWSER_PROGRAMS
.iter()
.flat_map(|programs| programs.iter())
.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",
"brave-browser-stable",
"vivaldi-stable",
"falkon",
"epiphany",
"opera",
"librewolf",
"waterfox",
"qutebrowser",
]
);
assert_eq!(
AUTO_BROWSER_FLATPAK_IDS,
[
"com.google.Chrome",
"org.chromium.Chromium",
"com.microsoft.Edge",
"org.mozilla.firefox",
"com.brave.Browser",
"com.vivaldi.Vivaldi",
"org.kde.falkon",
"org.gnome.Epiphany",
"com.opera.Opera",
"io.gitlab.librewolf-community",
"net.waterfox.waterfox",
"org.qutebrowser.qutebrowser",
]
);
}
#[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::ProgramsOrFlatpak {
programs: FIREFOX_BROWSERS,
app_id: "org.mozilla.firefox",
},
),
("com.brave.Browser.desktop", LauncherSpec::Flatpak("com.brave.Browser")),
("vivaldi-stable.desktop", LauncherSpec::Programs(VIVALDI_BROWSERS)),
(
"com.vivaldi.Vivaldi.desktop",
LauncherSpec::Flatpak("com.vivaldi.Vivaldi"),
),
(
"org.kde.falkon.desktop",
LauncherSpec::ProgramsOrFlatpak {
programs: FALKON_BROWSERS,
app_id: "org.kde.falkon",
},
),
(
"org.gnome.Epiphany.desktop",
LauncherSpec::ProgramsOrFlatpak {
programs: EPIPHANY_BROWSERS,
app_id: "org.gnome.Epiphany",
},
),
("com.opera.Opera.desktop", LauncherSpec::Flatpak("com.opera.Opera")),
(
"io.gitlab.librewolf-community.desktop",
LauncherSpec::Flatpak("io.gitlab.librewolf-community"),
),
(
"net.waterfox.waterfox.desktop",
LauncherSpec::Flatpak("net.waterfox.waterfox"),
),
(
"org.qutebrowser.qutebrowser.desktop",
LauncherSpec::ProgramsOrFlatpak {
programs: QUTEBROWSER_BROWSERS,
app_id: "org.qutebrowser.qutebrowser",
},
),
];
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);
}
#[test]
fn auto_flatpak_candidates_use_priority_and_exact_ids() {
assert_eq!(
find_auto_flatpak_app_id("org.kde.falkon\ncom.brave.Browser\n"),
Some("com.brave.Browser")
);
assert_eq!(find_auto_flatpak_app_id("com.brave.Browser.beta\n"), None);
}
#[test]
fn unavailable_custom_browser_returns_an_error() {
let err = open_url(
"https://example.com",
Browser::Other("gpgui-browser-that-does-not-exist"),
)
.unwrap_err();
assert_eq!(err.to_string(), "Configured browser is not available.");
}
}
@@ -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)
}