Revamp

Author: Seeker14491

CHANGELOG.md

@@ -5,6 +5,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- `open_browser()`, which uses the `$BROWSER` environment variable before falling back to `open()`.
+- WSL-specific implementation. Previously, WSL used the same implementation as Linux. Now, the strategy is to use the
+system `xdg-open` if available, otherwise we try using the system's `wslview` command from
+[`wslu`](https://github.com/wslutilities/wslu).
+### Changed
+- On Linux (non-WSL), the system `xdg-open` is now used if present. Otherwise, the bundled version is used, as before.
+- The command name in the `OpenError::ExitStatus` variant is now returned as a `Cow<'static, str>` instead of a
+`&'static str`.
 ### Removed
 - `impl From<io::Error> for OpenError`.
 

opener-bin/src/main.rs

@@ -3,23 +3,33 @@
     deprecated_in_future,
     macro_use_extern_crate,
     missing_debug_implementations,
-    unused_qualifications,
-    clippy::cast_possible_truncation
+    unused_qualifications
 )]
 
 use std::{path::PathBuf, process};
 use structopt::StructOpt;
 
 #[derive(Debug, StructOpt)]
-struct Cli {
+struct Args {
+    /// The path to open
     #[structopt(parse(from_os_str))]
     path: PathBuf,
+
+    /// Open the path with the `open_browser()` function instead of the `open` function
+    #[structopt(long = "browser")]
+    browser: bool,
 }
 
 fn main() {
-    let args = Cli::from_args();
+    let args = Args::from_args();
+
+    let open_result = if args.browser {
+        opener::open_browser(&args.path)
+    } else {
+        opener::open(&args.path)
+    };
 
-    match opener::open(&args.path) {
+    match open_result {
         Ok(()) => {
             println!("Opened path successfully.");
         }

opener/Cargo.toml

@@ -18,5 +18,8 @@ maintenance = { status = "passively-maintained" }
 [dev-dependencies]
 version-sync = "0.9"
 
+[target.'cfg(target_os = "linux")'.dependencies]
+wsl = "0.1"
+
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3", features = ["shellapi"] }

opener/src/lib.rs

@@ -1,7 +1,7 @@
 #![doc(html_root_url = "https://docs.rs/opener/0.4.1")]
 
 //! This crate provides the [`open`] function, which opens a file or link with the default program
-//! configured on the system.
+//! configured on the system:
 //!
 //! ```no_run
 //! # fn main() -> Result<(), ::opener::OpenError> {
@@ -14,10 +14,9 @@
 //! # }
 //! ```
 //!
-//! ## Platform Implementation Details
-//! On Windows the `ShellExecuteW` Windows API function is used. On Mac the system `open` command is
-//! used. On other platforms, the `xdg-open` script is used. The system `xdg-open` is not used;
-//! instead a version is embedded within this library.
+//! An [`open_browser`] function is also provided, for when you intend on opening a file or link in a
+//! browser, specifically. This function works like the [`open`] function, but explicitly allows
+//! overriding the browser launched by setting the `$BROWSER` environment variable.
 
 #![warn(
     rust_2018_idioms,
@@ -35,18 +34,21 @@ mod macos;
 mod windows;
 
 #[cfg(not(any(target_os = "windows", target_os = "macos")))]
-use crate::linux_and_more::open as open_sys;
+use crate::linux_and_more as sys;
 #[cfg(target_os = "macos")]
-use crate::macos::open as open_sys;
+use crate::macos as sys;
 #[cfg(target_os = "windows")]
-use crate::windows::open as open_sys;
+use crate::windows as sys;
 
 use std::{
+    borrow::Cow,
+    env,
     error::Error,
-    ffi::OsStr,
+    ffi::{OsStr, OsString},
     fmt::{self, Display, Formatter},
     io,
-    process::ExitStatus,
+    io::Read,
+    process::{Child, Command, ExitStatus, Stdio},
 };
 
 /// Opens a file or link with the system default program.
@@ -58,11 +60,56 @@ use std::{
 /// occurred as a direct result of opening the path. Errors beyond that point aren't caught. For
 /// example, `Ok(())` would be returned even if a file was opened with a program that can't read the
 /// file, or a dead link was opened in a browser.
+///
+/// ## Platform Implementation Details
+///
+/// - On Windows the `ShellExecuteW` Windows API function is used.
+/// - On Mac the system `open` command is used.
+/// - On Windows Subsystem for Linux (WSL), the system `xdg-open` will be used if available,
+/// otherwise the system `wslview` from [`wslu`] is used.
+/// - On non-WSL Linux and other platforms,
+/// the system `xdg-open` script is used if available, otherwise an `xdg-open` script embedded in
+/// this library is used.
+///
+/// [`wslu`]: https://github.com/wslutilities/wslu/
 pub fn open<P>(path: P) -> Result<(), OpenError>
 where
     P: AsRef<OsStr>,
 {
-    open_sys(path.as_ref())
+    sys::open(path.as_ref())
+}
+
+/// Opens a file or link with the system default program, using the `BROWSER` environment variable
+/// when set.
+///
+/// If the `BROWSER` environment variable is set, the program specified by it is used to open the
+/// path. If not, behavior is identical to [`open()`].
+pub fn open_browser<P>(path: P) -> Result<(), OpenError>
+where
+    P: AsRef<OsStr>,
+{
+    let mut path = path.as_ref();
+    if let Ok(browser_var) = env::var("BROWSER") {
+        let windows_path;
+        if is_wsl() && browser_var.ends_with(".exe") {
+            if let Some(windows_path_2) = wsl_to_windows_path(path) {
+                windows_path = windows_path_2;
+                path = &windows_path;
+            }
+        };
+
+        let mut browser_child = Command::new(&browser_var)
+            .arg(path)
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::piped())
+            .spawn()
+            .map_err(OpenError::Io)?;
+
+        wait_child(&mut browser_child, browser_var.into())
+    } else {
+        sys::open(path)
+    }
 }
 
 /// An error type representing the failure to open a path. Possibly returned by the [`open`]
@@ -74,10 +121,10 @@ pub enum OpenError {
     /// An IO error occurred.
     Io(io::Error),
 
-    /// The command exited with a non-zero exit status.
+    /// A command exited with a non-zero exit status.
     ExitStatus {
         /// A string that identifies the command.
-        cmd: &'static str,
+        cmd: Cow<'static, str>,
 
         /// The failed process's exit status.
         status: ExitStatus,
@@ -123,3 +170,56 @@ impl Error for OpenError {
         }
     }
 }
+
+#[cfg(target_os = "linux")]
+fn is_wsl() -> bool {
+    wsl::is_wsl()
+}
+
+#[cfg(not(target_os = "linux"))]
+fn is_wsl() -> bool {
+    false
+}
+
+#[cfg(target_os = "linux")]
+fn wsl_to_windows_path(path: &OsStr) -> Option<OsString> {
+    use std::os::unix::ffi::OsStringExt;
+
+    let output = Command::new("wslpath")
+        .arg("-w")
+        .arg(path)
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    Some(OsString::from_vec(output.stdout))
+}
+
+#[cfg(not(target_os = "linux"))]
+fn wsl_to_windows_path(path: &OsStr) -> Option<OsString> {
+    unreachable!()
+}
+
+fn wait_child(child: &mut Child, cmd_name: Cow<'static, str>) -> Result<(), OpenError> {
+    let exit_status = child.wait().map_err(OpenError::Io)?;
+    if exit_status.success() {
+        Ok(())
+    } else {
+        let mut stderr_output = String::new();
+        if let Some(stderr) = child.stderr.as_mut() {
+            stderr.read_to_string(&mut stderr_output).ok();
+        }
+
+        Err(OpenError::ExitStatus {
+            cmd: cmd_name,
+            status: exit_status,
+            stderr: stderr_output,
+        })
+    }
+}

opener/src/linux_and_more.rs

@@ -1,42 +1,83 @@
 use crate::OpenError;
 use std::{
     ffi::OsStr,
-    io::{Read, Write},
+    io::Write,
     process::{Command, Stdio},
 };
 
 const XDG_OPEN_SCRIPT: &[u8] = include_bytes!("xdg-open");
 
 pub(crate) fn open(path: &OsStr) -> Result<(), OpenError> {
-    let mut cmd = Command::new("sh")
-        .args(&["-s"])
+    if crate::is_wsl() {
+        wsl_open(path)
+    } else {
+        non_wsl_open(path)
+    }
+}
+
+fn wsl_open(path: &OsStr) -> Result<(), OpenError> {
+    let system_xdg_open = Command::new("xdg-open")
         .arg(path)
-        .stdin(Stdio::piped())
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::piped())
+        .spawn();
+
+    if let Ok(mut child) = system_xdg_open {
+        return crate::wait_child(&mut child, "xdg-open (system)".into());
+    }
+
+    let mut wslview = Command::new("wslview")
+        .arg(path)
+        .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::piped())
         .spawn()
         .map_err(OpenError::Io)?;
 
-    let child_stdin = cmd.stdin.as_mut().unwrap();
-    child_stdin
-        .write_all(XDG_OPEN_SCRIPT)
-        .map_err(OpenError::Io)?;
+    crate::wait_child(&mut wslview, "wslview".into())
+}
+
+fn non_wsl_open(path: &OsStr) -> Result<(), OpenError> {
+    let system_xdg_open = Command::new("xdg-open")
+        .arg(path)
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(Stdio::piped())
+        .spawn();
 
-    let exit_status = cmd.wait().map_err(OpenError::Io)?;
-    if exit_status.success() {
-        Ok(())
+    let system_xdg_open_used;
+    let mut xdg_open = match system_xdg_open {
+        Ok(child) => {
+            system_xdg_open_used = true;
+            child
+        }
+        Err(_) => {
+            system_xdg_open_used = false;
+            let mut sh = Command::new("sh")
+                .arg("-s")
+                .arg(path)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::null())
+                .stderr(Stdio::piped())
+                .spawn()
+                .map_err(OpenError::Io)?;
+
+            sh.stdin
+                .as_mut()
+                .unwrap()
+                .write_all(XDG_OPEN_SCRIPT)
+                .map_err(OpenError::Io)?;
+
+            sh
+        }
+    };
+
+    let cmd_name = if system_xdg_open_used {
+        "xdg-open (system)"
     } else {
-        let mut stderr_output = String::new();
-        cmd.stderr
-            .as_mut()
-            .unwrap()
-            .read_to_string(&mut stderr_output)
-            .ok();
-
-        Err(OpenError::ExitStatus {
-            cmd: "xdg-open (internal)",
-            status: exit_status,
-            stderr: stderr_output,
-        })
-    }
+        "xdg-open (internal)"
+    };
+
+    crate::wait_child(&mut xdg_open, cmd_name.into())
 }

opener/src/macos.rs

@@ -1,34 +1,17 @@
 use crate::OpenError;
 use std::{
     ffi::OsStr,
-    io::Read,
     process::{Command, Stdio},
 };
 
 pub(crate) fn open(path: &OsStr) -> Result<(), OpenError> {
-    let mut cmd = Command::new("open")
+    let mut open = Command::new("open")
         .arg(path)
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::piped())
         .spawn()
         .map_err(OpenError::Io)?;
 
-    let exit_status = cmd.wait().map_err(OpenError::Io)?;
-    if exit_status.success() {
-        Ok(())
-    } else {
-        let mut stderr_output = String::new();
-        cmd.stderr
-            .as_mut()
-            .unwrap()
-            .read_to_string(&mut stderr_output)
-            .ok();
-
-        Err(OpenError::ExitStatus {
-            cmd: "open",
-            status: exit_status,
-            stderr: stderr_output,
-        })
-    }
+    crate::wait_child(&mut open, "open".into())
 }