fail gracefully when currencies cannot be converted in the roi command …

…#82

src/app.rs

@@ -445,10 +445,6 @@ fn execute_command(
             statistics::execute(&options, maybe_ledger)
         }
     } {
-        let err_str = format!("{}", e);
-        if !err_str.is_empty() {
-            eprintln!("{}", err_str);
-        }
         return Err(e);
     }
     Ok(())

src/commands/balance.rs

@@ -19,9 +19,8 @@ pub fn execute(
     flat: bool,
     show_total: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    assert_eq!(
-        options.convert.is_some() & options.exchange.is_some(),
-        false,
+    assert!(
+        !(options.convert.is_some() && options.exchange.is_some()),
         "Incompatible arguments --convert and --exchange"
     );
     let ledger = match maybe_ledger {

src/commands/roi.rs

@@ -158,8 +158,7 @@ pub fn execute(
             let multipliers = conversion(currency.as_ref().unwrap().clone(), p.end, &ledger.prices);
             p.final_money = Some(
                 convert_balance(&p.final_balance, &multipliers, currency.as_ref().unwrap())
-                    .to_money()
-                    .unwrap(),
+                    .to_money()?,
             );
         }
         if p.initial_money.is_none() {

src/error.rs

@@ -4,6 +4,8 @@ use std::fmt;
 use std::fmt::{Display, Formatter};
 use std::path::PathBuf;
 
+use crate::models::Balance;
+
 #[derive(Debug)]
 pub struct EmptyLedgerFileError;
 impl Error for EmptyLedgerFileError {}
@@ -42,12 +44,47 @@ impl Display for TimeParseError {
 
 #[derive(Debug)]
 pub enum LedgerError {
-    TransactionIsNotBalanced,
     EmptyPostingShouldBeLast,
     AliasNotInList(String),
     TooManyEmptyPostings(usize),
 }
+impl Error for LedgerError {}
+impl Display for LedgerError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            LedgerError::EmptyPostingShouldBeLast => {
+                write!(f, "{}", "Empty posting should be last".red())
+            }
+            LedgerError::AliasNotInList(x) => write!(f, "Alias not found: {}", x),
+            LedgerError::TooManyEmptyPostings(_) => write!(f, "{}", "Too many empty postings".red()),
+        }
+    }
+}
+#[derive(Debug)]
+pub enum BalanceError {
+    TransactionIsNotBalanced,
+    TooManyCurrencies(Balance),
+}
+impl Error for BalanceError {}
 
+impl Display for BalanceError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            BalanceError::TransactionIsNotBalanced => {
+                write!(f, "{}", "Transaction is not balanced".red())
+            }
+
+            BalanceError::TooManyCurrencies(bal) => write!(
+                f,
+                "Too many currencies, probably a price is missing: {}",
+                bal.iter()
+                    .map(|x| x.1.to_string())
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+        }
+    }
+}
 #[derive(Debug)]
 pub struct GenericError {
     pub message: Vec<ColoredString>,

src/models.rs

@@ -81,7 +81,7 @@ impl ParsedLedger {
     /// 5. Checks whether transactions are balanced again
     ///
     /// There may be room for optimization here
-    pub fn to_ledger(mut self, options: &CommonOpts) -> Result<Ledger, GenericError> {
+    pub fn to_ledger(mut self, options: &CommonOpts) -> Result<Ledger, Box<dyn std::error::Error>> {
         let mut commodity_strs = HashSet::<String>::new();
         let mut account_strs = HashSet::<String>::new();
         let mut payee_strs = HashSet::<String>::new();
@@ -211,13 +211,7 @@ impl ParsedLedger {
         for t in transactions.iter_mut() {
             let date = t.date.unwrap();
             // output_balances(&balances);
-            let balance = match t.balance(&mut balances, options.no_balance_check) {
-                Ok(balance) => balance,
-                Err(e) => {
-                    eprintln!("{}", t);
-                    return Err(e.into());
-                }
-            };
+            let balance = t.balance(&mut balances, options.no_balance_check)?;
             if balance.len() == 2 {
                 let vec = balance.iter().map(|(_, x)| x.abs()).collect::<Vec<Money>>();
 
@@ -350,7 +344,7 @@ impl ParsedLedger {
                     Ok(balance) => balance,
                     Err(e) => {
                         eprintln!("{}", t);
-                        return Err(e.into());
+                        return Err(e);
                     }
                 };
                 if balance.len() == 2 {

src/models/balance.rs

@@ -1,4 +1,4 @@
-use crate::error::LedgerError;
+use crate::error::BalanceError;
 use crate::models::{Currency, Money};
 use std::collections::hash_map::Iter;
 use std::collections::HashMap;
@@ -26,7 +26,7 @@ impl Balance {
 
     /// Automatic conversion from balance to regular money
     /// it can only be done if the balance has only one currency
-    pub fn to_money(&self) -> Result<Money, LedgerError> {
+    pub fn to_money(&self) -> Result<Money, BalanceError> {
         let vec = self
             .balance
             .values()
@@ -35,7 +35,7 @@ impl Balance {
         match vec.len() {
             0 => Ok(Money::Zero),
             1 => Ok(vec[0].clone()),
-            _ => Err(LedgerError::TransactionIsNotBalanced),
+            _ => Err(BalanceError::TooManyCurrencies(self.clone())),
         }
     }
     pub fn is_zero(&self) -> bool {

src/models/transaction.rs

@@ -6,6 +6,7 @@ use std::rc::{Rc, Weak};
 use chrono::NaiveDate;
 use num::rational::BigRational;
 
+use crate::error::BalanceError;
 use crate::models::balance::Balance;
 use crate::models::{Account, Comment, HasName, Money, Payee};
 use crate::{LedgerError, List};
@@ -274,14 +275,14 @@ impl Transaction<Posting> {
         &mut self,
         balances: &mut HashMap<Rc<Account>, Balance>,
         skip_balance_check: bool,
-    ) -> Result<Balance, LedgerError> {
+    ) -> Result<Balance, Box<dyn std::error::Error>> {
         let mut transaction_balance = Balance::new();
 
         // 1. Check the virtual postings
         match total_balance(&*self.postings.borrow(), PostingType::VirtualMustBalance).can_be_zero()
         {
             true => {}
-            false => return Err(LedgerError::TransactionIsNotBalanced),
+            false => return Err(Box::new(BalanceError::TransactionIsNotBalanced)),
         }
 
         // 1. Iterate over postings
@@ -307,7 +308,7 @@ impl Transaction<Posting> {
                                 "Difference:  {}",
                                 expected_balance - Balance::from(balance.clone())
                             );
-                            return Err(LedgerError::TransactionIsNotBalanced);
+                            return Err(Box::new(BalanceError::TransactionIsNotBalanced));
                         }
                     }
                 }
@@ -403,7 +404,7 @@ impl Transaction<Posting> {
             .count()
             - postings.len();
         if empties > 1 {
-            Err(LedgerError::TooManyEmptyPostings(empties))
+            Err(Box::new(LedgerError::TooManyEmptyPostings(empties)))
         } else if empties == 0 {
             match transaction_balance.can_be_zero() {
                 true => {
@@ -420,7 +421,7 @@ impl Transaction<Posting> {
                     self.postings.replace(postings);
                     Ok(transaction_balance)
                 }
-                false => Err(LedgerError::TransactionIsNotBalanced),
+                false => Err(Box::new(BalanceError::TransactionIsNotBalanced)),
             }
         } else {
             // Fill the empty posting