impl list

Author: chmln

.rustfmt.toml

@@ -0,0 +1,2 @@
+max_width = 80
+merge-imports = true

Cargo.lock

@@ -1,14 +1,11 @@
 [package]
-name = "mime"
+name = "handlr"
 version = "0.1.0"
 authors = ["greg <gregory.mkv@gmail.com>"]
 edition = "2018"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 dirs = "2.0.2"
-anyhow = "1.0.28"
 pest = "2.1.3"
 pest_derive = "2.1.0"
 rayon = "1.3.0"
@@ -18,3 +15,7 @@ url = "2.1.1"
 mime_guess = "2.0.3"
 itertools = "0.9.0"
 derive_more = {version = "0.99.5", default-features = false, features = ["display"] }
+json = "0.12.4"
+shlex = "0.1.1"
+thiserror = "1.0.14"
+ascii_table = "3.0.0"

Cargo.toml

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use crate::{Error, Result};
 use pest::Parser;
 use std::convert::TryFrom;
 use std::path::PathBuf;
@@ -12,11 +12,13 @@ impl std::str::FromStr for Mime {
         Ok(Self(s.to_owned()))
     }
 }
-#[derive(Debug, derive_more::Display, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(
+    Debug, derive_more::Display, Clone, Hash, PartialEq, Eq, PartialOrd, Ord,
+)]
 pub struct Handler(String);
 
 impl std::str::FromStr for Handler {
-    type Err = anyhow::Error;
+    type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Self::resolve(s.to_owned())
     }
@@ -41,21 +43,31 @@ impl Handler {
         locally.or(system)
     }
     pub fn resolve(name: String) -> Result<Self> {
-        let path =
-            Self::get_path(&name).ok_or_else(|| anyhow::Error::msg("Handler does not exist"))?;
+        let path = Self::get_path(&name).ok_or(Error::NotFound)?;
         DesktopEntry::try_from(path)?;
         Ok(Self(name))
     }
     pub fn get_entry(&self) -> Result<DesktopEntry> {
         DesktopEntry::try_from(Self::get_path(&self.0).unwrap())
     }
-    pub fn run(&self, arg: &str) -> Result<()> {
-        std::process::Command::new("gtk-launch")
-            .args(&[self.0.as_str(), arg])
+    pub fn open(&self, arg: String) -> Result<()> {
+        let (cmd, args) = self.get_entry()?.get_cmd(Some(arg))?;
+        std::process::Command::new(cmd)
+            .args(args)
             .stdout(std::process::Stdio::null())
             .spawn()?;
         Ok(())
     }
+    pub fn launch(&self, args: Vec<String>) -> Result<()> {
+        let (cmd, mut base_args) = self.get_entry()?.get_cmd(None)?;
+        base_args.extend_from_slice(&args);
+        std::process::Command::new(cmd)
+            .args(base_args)
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .spawn()?;
+        Ok(())
+    }
 }
 
 #[derive(Debug, Clone, pest_derive::Parser, Default, PartialEq, Eq)]
@@ -67,8 +79,22 @@ pub struct DesktopEntry {
     pub(crate) mimes: Vec<Mime>,
 }
 
+impl DesktopEntry {
+    pub fn get_cmd(
+        &self,
+        arg: Option<String>,
+    ) -> Result<(String, Vec<String>)> {
+        let arg = arg.unwrap_or_default();
+        let arg = shlex::quote(&arg);
+        let replaced = self.exec.replace("%f", &arg).replace("%U", &arg);
+
+        let mut split = shlex::split(&replaced).ok_or(Error::BadCmd)?;
+        Ok((split.remove(0), split))
+    }
+}
+
 impl TryFrom<PathBuf> for DesktopEntry {
-    type Error = anyhow::Error;
+    type Error = Error;
     fn try_from(p: PathBuf) -> Result<DesktopEntry> {
         let raw = std::fs::read_to_string(&p)?;
         let file = Self::parse(Rule::file, &raw)?.next().unwrap();
@@ -84,10 +110,12 @@ impl TryFrom<PathBuf> for DesktopEntry {
                     let name = inner_rules.next().unwrap().as_str();
                     match name {
                         "Name" => {
-                            entry.name = inner_rules.next().unwrap().as_str().into();
+                            entry.name =
+                                inner_rules.next().unwrap().as_str().into();
                         }
                         "Exec" => {
-                            entry.exec = inner_rules.next().unwrap().as_str().into();
+                            entry.exec =
+                                inner_rules.next().unwrap().as_str().into();
                         }
                         "MimeType" => {
                             let mut mimes = inner_rules
@@ -111,7 +139,7 @@ impl TryFrom<PathBuf> for DesktopEntry {
         if !entry.name.is_empty() && !entry.exec.is_empty() {
             Ok(entry)
         } else {
-            Err(anyhow::Error::msg("Invalid desktop entry"))
+            Err(Error::BadCmd)
         }
     }
 }

src/common.rs

@@ -0,0 +1,17 @@
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error(transparent)]
+    Parse(#[from] pest::error::Error<crate::common::Rule>),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error("handler not found")]
+    NotFound,
+    #[error("Invalid desktop entry")]
+    BadCmd,
+    #[error("Could not find config dir")]
+    NoConfigDir,
+    #[error("could not guess mime type")]
+    Ambiguous,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;

src/error.rs

@@ -1,44 +1,61 @@
-use anyhow::Result;
+use error::{Error, Result};
 use structopt::StructOpt;
 
 mod common;
+mod error;
 mod mimeapps;
 
 pub use common::{DesktopEntry, Handler, Mime};
 
 #[derive(StructOpt)]
-enum Options {
+enum Cmd {
     List,
-    Open { path: String },
-    Get { mime: Mime },
-    Set { mime: Mime, handler: Handler },
+    Open {
+        path: String,
+    },
+    Get {
+        #[structopt(long)]
+        json: bool,
+        mime: Mime,
+    },
+    Launch {
+        mime: Mime,
+        args: Vec<String>,
+    },
+    Set {
+        mime: Mime,
+        handler: Handler,
+    },
 }
 
 fn main() -> Result<()> {
-    let cmd = Options::from_args();
+    let mut apps = mimeapps::MimeApps::read()?;
 
-    let mut user = mimeapps::MimeApps::read()?;
-
-    match cmd {
-        Options::Set { mime, handler } => {
-            user.set_handler(mime, handler)?;
+    match Cmd::from_args() {
+        Cmd::Set { mime, handler } => {
+            apps.set_handler(mime, handler)?;
+        }
+        Cmd::Launch { mime, args } => {
+            apps.get_handler(&mime)?.launch(args)?;
         }
-        Options::Get { mime } => {
-            println!("{}", user.get_handler(&mime)?);
+        Cmd::Get { mime, json } => {
+            apps.show_handler(&mime, json)?;
         }
-        Options::Open { path } => match url::Url::parse(&path) {
+        Cmd::Open { path } => match url::Url::parse(&path) {
             Ok(url) => {
                 let mime = Mime(format!("x-scheme-handler/{}", url.scheme()));
-                user.get_handler(&mime)?.run(&path)?;
+                apps.get_handler(&mime)?.open(path)?;
             }
             Err(_) => {
                 let guess = mime_guess::from_path(&path)
                     .first_raw()
-                    .ok_or_else(|| anyhow::Error::msg("Could not determine mime type"))?;
-                user.get_handler(&Mime(guess.to_owned()))?.run(&path)?;
+                    .ok_or(Error::Ambiguous)?;
+                apps.get_handler(&Mime(guess.to_owned()))?.open(path)?;
             }
         },
-        _ => {}
+        Cmd::List => {
+            apps.print()?;
+        }
     };
 
     Ok(())