Compare commits

..

6 commits
v1.0.0 ... main

7 changed files with 175 additions and 105 deletions

View file

@ -1,6 +1,6 @@
[package]
name = "open"
version = "1.0.0"
version = "2.0.1"
authors = ["Valerie Wolfe <sleeplessval@gmail.com>"]
edition = "2018"

View file

@ -3,3 +3,11 @@
An opinionated, friendly alternative to `xdg-open` focused on opening files from a
terminal. Easily understandable and configurable with a simple toml file.
Does technically break convention. If you're using the `open` shell builtin, or
otherwise care about compliance, consider installing under a different binary name.
## Libraries
- [pico-args](https://crates.io/crates/pico-args) — argument parsing
- [toml](https://crates.io/crates/toml) — TOML file parsing

70
man/open.1 Normal file
View file

@ -0,0 +1,70 @@
.Dd $Mdocdate$
.Dt OPEN 1
.Os
.Sh NAME
.Nm open
.Nd opens files with a user-defined program.
.Sh SYNOPSIS
.Nm open
.Op Ar file
.Nm open
.Op Fl hpv
.Sh DESCRIPTION
.Nm
is a replacement for
.Xr xdg-open 1
that is more easily configurable with a TOML file. Its options are as follows:
.Bl -tag -width Ds
.It Fl h\ |\ --help
Displays a brief help text.
.It Fl p\ |\ --path
Displays the path to the configuration file being used.
.It Fl v\ |\ --version
Displays version information.
.It Ar file
The file to open. If not provided, the current directory is used.
.El
.Sh FILES
.Bl -tag -width DS
.It $HOME/.config/open.toml
The global configuration file in TOML format.
.It .open
The local configuration file in TOML format.
.Nm open
will search upwards to try to find a local file. Local configuration items are prioritized.
.El
.Sh CONFIGURATION
Files can be matched on extension or exact name. Filenames are in the 'filename' array, and extensions are in the 'extension' array.
.Pp
.Dl [[extension]]
.Dl match = (string or array; matching value(s))
.Dl command = (string; the command to open with)
.Dl shell = (boolean; decides if the command is run in the terminal)
.Pp
.Pp
The "dir" section is used to set associations for directories:
.Pp
.Dl [dir]
.Dl command = (string; the command to open with)
.Dl shell = (boolean; decides if the command is run in the terminal)
.Pp
.Sh EXIT STATUS
.Bl -tag -width Ds
.It 1
No configuration file was found.
.It 4
The target file does not exist.
.It 5
No matching configuration section was found for the target file.
.El
.Sh SEE ALSO
.Xr xdg-open 1 ,
.Xr open 3p
.Sh AUTHORS
.An -nosplit
.An Valerie Wolfe Aq Mt sleeplessval@gmail.com
.Sh BUGS
.Nm
hides the
.Xr open 3p
builtin, breaking convention and possibly some older script files.

View file

@ -1,5 +1,4 @@
use std::{
fs::read_to_string,
env::{current_dir, var},
path::Path
};
@ -9,6 +8,8 @@ use toml::{
map::Map
};
use crate::{ error, util };
pub struct Config {
pub local: Option<Map<String, Value>>,
pub global: Option<Map<String, Value>>,
@ -18,81 +19,51 @@ pub struct Config {
impl Config {
pub fn new() -> Config {
// Instantiate global config
let i_dir_global = String::from(var("HOME").ok().unwrap());
let dir_global = Path::new(i_dir_global.as_str());
let i_path_global = dir_global.join(".config/open.toml");
let path_global = i_path_global.as_path();
let mut global = None;
if path_global.exists() {
let raw_conf = read_to_string(path_global).unwrap();
let toml_conf: Value = toml::from_str(raw_conf.as_str()).unwrap();
let toml = toml_conf.as_table().unwrap();
global = Some(toml.to_owned());
}
// initialize global config, if it exists
let str_path_global = var("HOME").unwrap() + "/.config/open.toml";
let path_global = Path::new(&str_path_global);
let global = util::read_toml(path_global);
// Instantiate local config, if it exists.
let i_dir_local = current_dir().unwrap();
let mut dir_local = i_dir_local.as_path();
let mut i_path_local = dir_local.join(".open");
let mut path_local = i_path_local.as_path();
let root = Path::new("/");
// propagate up for local config, if it exists
let cwd = current_dir().unwrap();
let mut path_local = Path::new(&cwd);
let mut local = None;
loop {
if dir_local == root {
while let Some(parent) = path_local.parent() {
let file_local = path_local.join(".open");
if let Some(toml) = util::read_toml(file_local.as_path()) {
local = Some(toml);
break;
}
if path_local.exists() {
let raw_conf = read_to_string(path_local).unwrap();
let toml_conf: Value = toml::from_str(raw_conf.as_str()).unwrap();
let toml = toml_conf.as_table().unwrap();
local = Some(toml.to_owned());
break;
}
dir_local = dir_local.parent().unwrap();
i_path_local = dir_local.join(".open");
path_local = i_path_local.as_path();
path_local = parent;
}
if global.is_none() && local.is_none() {
panic!("No configuration found.");
}
if global.is_none() && local.is_none() { error::no_configs(); }
// prepare path vars
let global_path: Option<String>;
if global.is_some() {
global_path = Some(path_global.to_str().unwrap().to_string());
} else {
global_path = None
}
let local_path: Option<String>;
if local.is_some() {
local_path = Some(dir_local.join(".open").to_str().unwrap().to_string());
} else {
local_path = None;
}
let output = Config {
let global_path: Option<String> =
if global.is_some() { Some(path_global.to_string_lossy().into()) }
else { None };
let local_path =
if local.is_some() { Some(path_local.join(".open").to_string_lossy().into()) }
else { None };
Config {
global,
local,
local_path,
global_path
};
return output;
}
}
pub fn get(&self, key: &str) -> Option<Value> {
let mut output: Option<Value> = None;
if self.local.is_some() {
let result = self.local.as_ref().unwrap().get(key);
if result.is_some() {
output = Some(result.unwrap().to_owned());
}
if let Some(local) = &self.local {
if let Some(result) = local.get(key) { return Some(result.to_owned()); }
}
if output.is_none() && self.global.is_some() {
let result = self.global.as_ref().unwrap().get(key);
if result.is_some() {
output = Some(result.unwrap().to_owned());
}
if let Some(global) = &self.global {
if let Some(result) = global.get(key) { return Some(result.to_owned()); }
}
return output;
None
}
}

View file

@ -3,27 +3,27 @@ use std::{
process::exit
};
pub fn no_configs() {
pub fn no_configs() -> ! {
println!("open: no configurations found");
exit(1);
}
pub fn many_args() {
pub fn many_args() -> ! {
println!("open: too many arguments supplied");
exit(2);
}
pub fn editor_unset() {
pub fn editor_unset() -> ! {
println!("open: $EDITOR is not set");
exit(3);
}
pub fn not_found(path: &Path) {
pub fn not_found(path: &Path) -> ! {
println!("open: {path:?} does not exist");
exit(4);
}
pub fn no_section(path: &Path) {
pub fn no_section(path: &Path) -> ! {
println!("open: no appropriate sections for {path:?}");
exit(5);
}

View file

@ -1,14 +1,17 @@
use std::{
env::current_dir,
io::{ stdout, IsTerminal },
path::Path,
process::{ Command, Stdio }
process::{ exit, Command, Stdio }
};
use pico_args::Arguments;
use toml::value::{ Array, Value };
use toml::value::Value;
mod config;
mod error;
mod util;
use config::Config;
fn main() {
@ -32,17 +35,8 @@ fn main() {
// path flag (-p / --path)
if args.contains(["-p", "--path"]) {
let local = config.local_path;
let global = config.global_path;
if local.is_some() {
println!("{}", local.unwrap());
return;
}
if global.is_some() {
println!("{}", global.unwrap());
return;
}
error::no_configs();
if let Some(local) = config.local_path { println!("{local}"); }
else if let Some(global) = config.global_path { println!("{global}"); }
return;
}
@ -53,16 +47,17 @@ fn main() {
if !target.exists() { error::not_found(&target); }
// get section
// ordering: filename -> type (ext/dir)
// ordering: filename -> type (ext/dir) -> default
let mut section = None;
// by exact filename
let filename = target.file_name();
if filename.is_some() {
let filename_section = config.get(filename.unwrap().to_str().unwrap());
if filename_section.is_some() {
section = filename_section;
}
if let Some(filename) = target.file_name() {
let array = config.get("filename");
let matches: Vec<Value>;
if let Some(Value::Array(array)) = array { matches = util::matches(array, filename.to_string_lossy().into()); }
else { matches = Vec::new(); }
section = if matches.len() > 0 { matches.get(0).cloned() } else { None };
}
// handle types; dir first
@ -75,24 +70,13 @@ fn main() {
// handle types; extensions second
if section.is_none() {
let extension = target.extension();
if extension.is_some() {
let extension = extension.unwrap().to_str();
if let Some(extension) = target.extension() {
let array: Option<Value> = config.get("extension");
let matches: Vec<Value>;
if let Some(Value::Array(array)) = array { matches = util::matches(array, extension.to_string_lossy().into()); }
else { matches = Vec::new(); }
// pull extension array and filter matches
let i_macrosection: Option<Value> = config.get("extension");
let macrosection: Array = i_macrosection.unwrap().as_array().unwrap().to_owned();
let matches = macrosection.iter().filter(|value| {
let table = value.as_table().unwrap();
let i_target = table.get("match").unwrap();
let target = i_target.as_str();
target == extension
}).map(|value| value.to_owned() );
let sections: Vec<Value> = matches.collect();
if sections.len() > 0 {
section = sections.get(0).cloned();
}
section = if matches.len() > 0 { matches.get(0).cloned() } else { None };
}
}
@ -110,6 +94,11 @@ fn main() {
let command = properties.get("command").unwrap().as_str().unwrap().to_string();
let shell = properties.get("shell").unwrap_or(&Value::Boolean(false)).as_bool().unwrap();
if !stdout().is_terminal() {
println!("{command} {i_target}");
exit(0);
}
// build child
let mut parts = command.split(" ");
let mut child = Command::new(parts.next().unwrap());

View file

@ -1,5 +1,37 @@
use std::{
process::{ Command, Stdio }
fs::read_to_string,
path::Path
};
use toml::{
self,
Value,
map::Map,
value::Array,
};
/// gets array entries with matching "match" values.
pub fn matches(macrosection: Array, to_match: String) -> Vec<Value> {
macrosection.iter().filter(|value| {
if let Some(table) = value.as_table() {
match table.get("match").unwrap() {
Value::String(target) => *target == to_match,
Value::Array(values) => values.contains(&Value::String(to_match.clone())),
_ => false
}
} else { false }
}).map(|value| value.to_owned()).collect()
}
pub fn read_toml(path: &Path) -> Option<Map<String, Value>> {
if path.exists() {
if let Ok(raw) = read_to_string(path) {
if let Ok(Value::Table(toml)) = toml::from_str(&raw) {
return Some(toml);
}
}
}
None
}