Better command-line

2 files changed, 79 insertions, 43 deletions

diff --git a/src/main.rs b/src/main.rs
index 10c9434..171fe3c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,51 +5,80 @@ extern crate log;
 #[macro_use]
 extern crate failure;
 
+#[macro_use]
 extern crate clap;
 extern crate clap_log_flag;
 extern crate clap_verbosity_flag;
 extern crate structopt;
 
-use structopt::StructOpt;
-
-use failure::Error;
-
-//use dbus::stdintf::org_freedesktop_dbus::Properties;
-use dbus::Connection;
-
-use dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
-
 mod dbus_api;
 mod parsing;
 mod utils;
 
 use utils::*;
 
+use dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
+use failure::Error;
+use structopt::StructOpt;
+
+use std::fs::File;
+use std::io;
+
+#[derive(StructOpt, Debug)]
+#[structopt(raw(setting = "structopt::clap::AppSettings::ColoredHelp"))]
+/// Hello World! How are you doing?
+struct Cli {
+    #[structopt(flatten)]
+    verbose: clap_verbosity_flag::Verbosity,
+    #[structopt(flatten)]
+    log: clap_log_flag::Log,
+    #[structopt(short = "s")]
+    /// Use the given sink.
+    ///
+    /// By default it will use the last equalized sink it finds
+    sink: Option<String>,
+    #[structopt(subcommand)]
+    cmd: Command,
+}
+
 #[derive(StructOpt, Debug)]
 enum Command {
-    #[structopt(name = "load")]
+    #[structopt(name = "load",)]
+    /// Load and switch to a given equalizer configuration
     Load(LoadCli),
     #[structopt(name = "reset")]
+    /// Switch to a neutral equalizer
     Reset(ResetCli),
 }
 
 #[derive(StructOpt, Debug)]
 struct LoadCli {
+    #[structopt(default_value = "-")]
+    /// The file from which to load the equalizer configuration
+    ///
+    /// If "-" is given, read the configuration from the command-line.
+    file: String,
+    #[structopt(
+        short = "f",
+        raw(
+            possible_values = "&EqualizerConfFormat::variants()",
+            case_insensitive = "true"
+        ),
+        default_value = "EqualizerAPO"
+    )]
+    /// The file format of the equalizer configuration
+    format: EqualizerConfFormat,
 }
 
-#[derive(StructOpt, Debug)]
-struct ResetCli {
+arg_enum! {
+    #[derive(Debug)]
+    enum EqualizerConfFormat {
+        EqualizerAPO
+    }
 }
 
 #[derive(StructOpt, Debug)]
-struct Cli {
-    #[structopt(flatten)]
-    verbose: clap_verbosity_flag::Verbosity,
-    #[structopt(flatten)]
-    log: clap_log_flag::Log,
-    #[structopt(subcommand)]
-    cmd: Command,
-}
+struct ResetCli {}
 
 #[derive(Fail, Debug)]
 #[fail(display = "No equalized sink found")]
@@ -88,7 +117,7 @@ fn main() -> Result<(), Error> {
 
     match args.cmd {
         Load(args) => load(args),
-        Reset(args)=> reset(args),
+        Reset(args) => reset(args),
     }
 }
 
@@ -110,23 +139,18 @@ fn reset(args: ResetCli) -> Result<(), Error> {
 fn load(args: LoadCli) -> Result<(), Error> {
     let conn = connect()?;
     let conn_sink = get_equalized_sink(&conn)?;
-    let filter = read_filter()?;
+
+    let filter = if args.file == "-" {
+        let stdin = io::stdin();
+        let mut lock = stdin.lock();
+        read_filter(&mut lock)?
+    } else {
+        let mut file = File::open(args.file)?;
+        read_filter(&mut file)?
+    };
+
     let filter_rate = conn_sink.get_filter_sample_rate()?;
     send_filter(&conn_sink, filter.pad(filter_rate))?;
 
     Ok(())
 }
-
-/*
-fn introspect(conn: &dbus::ConnPath<&Connection>) {
-    let mut thing = conn
-        .method_call_with_args(
-            &"org.freedesktop.DBus.Introspectable".into(),
-            &"Introspect".into(),
-            |_| {},
-        ).unwrap();
-    thing.as_result().unwrap();
-
-    println!("{}", thing.iter_init().read::<String>().unwrap());
-}
-*/
diff --git a/src/utils.rs b/src/utils.rs
index 5aae29d..6d7ae58 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -9,7 +9,7 @@ use ::dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
 use dbus::{BusType, Connection, ConnPath};
 use failure::{Error, ResultExt};
 
-use std::io::{self, Read};
+use std::io;
 
 pub fn connect() -> Result<Connection, Error> {
     let pulse_sock_path =
@@ -36,7 +36,7 @@ pub fn get_equalized_sink<'a>(conn: &'a Connection) -> Result<ConnPath<'a, &'a C
 pub fn send_filter(conn_sink: &ConnPath<&Connection>, filter: Filter) -> Result<(), Error> {
     let channel = conn_sink.get_nchannels()?;
     info!("Using channel: {}", channel);
-    trace!("Sending filter");
+    trace!("Sending filter: {:?}", filter);
     conn_sink.seed_filter(
         channel,
         filter.frequencies,
@@ -46,17 +46,15 @@ pub fn send_filter(conn_sink: &ConnPath<&Connection>, filter: Filter) -> Result<
     Ok(())
 }
 
-pub fn read_filter() -> Result<Filter, Error> {
+pub fn read_filter(file: &mut impl io::Read) -> Result<Filter, Error> {
     let mut buffer = String::new();
-    let stdin = io::stdin();
-    let mut handle = stdin.lock();
 
     info!("Reading filter in GraphicEQ format from the command line");
-    handle.read_to_string(&mut buffer)?;
+    file.read_to_string(&mut buffer)?;
 
     // TODO: lifetime issue when "throwing" parse error
     let filter = EqualizerApoParser::new().parse(&buffer).unwrap();
-    info!("Parsed filter: {:?}", filter);
+    trace!("Parsed filter: {:?}", filter);
 
     Ok(filter)
 }
@@ -69,3 +67,17 @@ fn get_pulse_dbus_sock() -> Result<String, Error> {
     trace!("Checking PulseAudio's D-Bus socket path");
     Ok(conn.get_address()?)
 }
+
+/*
+fn introspect(conn: &dbus::ConnPath<&Connection>) {
+    let mut thing = conn
+        .method_call_with_args(
+            &"org.freedesktop.DBus.Introspectable".into(),
+            &"Introspect".into(),
+            |_| {},
+        ).unwrap();
+    thing.as_result().unwrap();
+
+    println!("{}", thing.iter_init().read::<String>().unwrap());
+}
+*/