From e2e2f14accc751573a2a52b43bd8c87e1f1b89db Mon Sep 17 00:00:00 2001
From: Minijackson <minijackson@riseup.net>
Date: Tue, 4 Sep 2018 18:40:41 +0200
Subject: Centralize error context + properly report parse errors

---
 src/main.rs            | 24 +++++++----------------
 src/parsing/.gitignore |  1 +
 src/utils.rs           | 52 ++++++++++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 58 insertions(+), 19 deletions(-)
 create mode 100644 src/parsing/.gitignore

(limited to 'src')

diff --git a/src/main.rs b/src/main.rs
index 310fa1a..360117c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,6 +12,8 @@ extern crate clap_verbosity_flag;
 #[macro_use]
 extern crate structopt;
 
+extern crate lalrpop_util;
+
 mod dbus_api;
 mod parsing;
 mod utils;
@@ -19,7 +21,7 @@ mod utils;
 use utils::*;
 
 use dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
-use failure::{Error, ResultExt};
+use failure::Error;
 use structopt::StructOpt;
 
 use std::fs::File;
@@ -81,10 +83,6 @@ arg_enum! {
 #[derive(StructOpt, Debug)]
 struct ResetCli {}
 
-#[derive(Fail, Debug)]
-#[fail(display = "No equalized sink found")]
-struct NoEqualizedSink;
-
 #[derive(Debug)]
 pub struct Filter {
     preamp: f64,
@@ -136,12 +134,8 @@ fn start() -> Result<(), Error> {
 }
 
 fn reset(args: ResetCli) -> Result<(), Error> {
-    let conn = connect().context(
-        "Could not connect to PulseAudio's D-Bus socket. Have you loaded the 'module-dbus-protocol' module?"
-    )?;
-    let conn_sink = get_equalized_sink(&conn).context(
-        "Could not find an equalized sink. Have you loaded the 'module-equalizer-sink' module?",
-    )?;
+    let conn = connect()?;
+    let conn_sink = get_equalized_sink(&conn)?;
     let filter_rate = conn_sink.get_filter_sample_rate()?;
     let filter = Filter {
         preamp: 1f64,
@@ -155,12 +149,8 @@ fn reset(args: ResetCli) -> Result<(), Error> {
 }
 
 fn load(args: LoadCli) -> Result<(), Error> {
-    let conn = connect().context(
-        "Could not connect to PulseAudio's D-Bus socket. Have you loaded the 'module-dbus-protocol' module?"
-    )?;
-    let conn_sink = get_equalized_sink(&conn).context(
-        "Could not find an equalized sink. Have you loaded the 'module-equalizer-sink' module?",
-    )?;
+    let conn = connect()?;
+    let conn_sink = get_equalized_sink(&conn)?;
 
     let filter = if args.file == "-" {
         let stdin = io::stdin();
diff --git a/src/parsing/.gitignore b/src/parsing/.gitignore
new file mode 100644
index 0000000..cdfabf6
--- /dev/null
+++ b/src/parsing/.gitignore
@@ -0,0 +1 @@
+./equalizer_apo.rs
diff --git a/src/utils.rs b/src/utils.rs
index 24af366..de9ed3c 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,4 +1,4 @@
-use {Filter, NoEqualizedSink};
+use {EqualizerConfFormat, Filter};
 
 use parsing::EqualizerApoParser;
 
@@ -8,10 +8,33 @@ use dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
 
 use dbus::{BusType, ConnPath, Connection};
 use failure::{Error, ResultExt};
+use lalrpop_util;
 
+use std::fmt;
 use std::io;
 
+#[derive(Fail, Debug)]
+#[fail(display = "No equalized sink found")]
+struct NoEqualizedSink;
+
+#[derive(Fail, Debug)]
+#[fail(
+    display = "Could not parse using the {} format: {}",
+    format,
+    message
+)]
+struct ParseError {
+    format: EqualizerConfFormat,
+    message: String,
+}
+
 pub fn connect() -> Result<Connection, Error> {
+    Ok(connect_impl().context(
+        "Could not connect to PulseAudio's D-Bus socket. Have you loaded the 'module-dbus-protocol' module?"
+    )?)
+}
+
+fn connect_impl() -> Result<Connection, Error> {
     let pulse_sock_path = get_pulse_dbus_sock()?;
     info!("PulseAudio's D-Bus socket path is: {}", pulse_sock_path);
 
@@ -20,6 +43,14 @@ pub fn connect() -> Result<Connection, Error> {
 }
 
 pub fn get_equalized_sink<'a>(conn: &'a Connection) -> Result<ConnPath<'a, &'a Connection>, Error> {
+    Ok(get_equalized_sink_impl(conn).context(
+        "Could not find an equalized sink. Have you loaded the 'module-equalizer-sink' module?",
+    )?)
+}
+
+fn get_equalized_sink_impl<'a>(
+    conn: &'a Connection,
+) -> Result<ConnPath<'a, &'a Connection>, Error> {
     let conn_manager = conn.with_path("org.PulseAudio.Core1", "/org/pulseaudio/equalizing1", 2000);
 
     // TODO: make that a command-line option
@@ -55,12 +86,29 @@ where
     file.read_to_string(&mut buffer)?;
 
     // TODO: lifetime issue when "throwing" parse error
-    let filter = EqualizerApoParser::new().parse(&buffer).unwrap();
+    let filter = EqualizerApoParser::new()
+        .parse(&buffer)
+        .map_err(|e| convert_parse_error(EqualizerConfFormat::EqualizerAPO, e))?;
     trace!("Parsed filter: {:?}", filter);
 
     Ok(filter)
 }
 
+fn convert_parse_error<L, T, E>(
+    format: EqualizerConfFormat,
+    error: lalrpop_util::ParseError<L, T, E>,
+) -> ParseError
+where
+    L: fmt::Display,
+    T: fmt::Display,
+    E: fmt::Display,
+{
+    ParseError {
+        format,
+        message: format!("{}", error),
+    }
+}
+
 fn get_pulse_dbus_sock() -> Result<String, Error> {
     trace!("Connecting to the D-Bus' session bus");
     let conn = Connection::get_private(BusType::Session)?;
-- 
cgit v1.2.3