frosklis/issue155 Show the transaction when it is not balanced

src/error.rs

@@ -4,7 +4,7 @@ use std::fmt;
 use std::fmt::{Display, Formatter};
 use std::path::PathBuf;
 
-use crate::models::{Balance, Currency};
+use crate::models::{Balance, Currency, Transaction, Posting};
 
 #[derive(Debug)]
 pub struct EmptyLedgerFileError;
@@ -73,16 +73,16 @@ impl Display for LedgerError {
 }
 #[derive(Debug)]
 pub enum BalanceError {
-    TransactionIsNotBalanced,
+    TransactionIsNotBalanced(Transaction<Posting>),
     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::TransactionIsNotBalanced(t) => {
+                write!(f, "{}\n{:?}", "Transaction is not balanced".red(), t)
             }
 
             BalanceError::TooManyCurrencies(bal) => write!(
@@ -134,14 +134,14 @@ mod tests {
     use structopt::StructOpt;
 
     use super::{EmptyLedgerFileError, LedgerError};
-    use crate::{parser::Tokenizer, CommonOpts};
+    use crate::{error::BalanceError, parser::Tokenizer, CommonOpts};
 
     #[test]
     fn error_empty_posting_last() {
         let mut tokenizer = Tokenizer::from(
             "2021-06-05 Flight
         Assets:Checking
-        Expenses:Comissions
+        Expenses:Commissions
         Expenses:Travel      200 EUR"
                 .to_string(),
         );
@@ -173,4 +173,36 @@ mod tests {
             "The journal file does not have any information"
         );
     }
+
+    #[test]
+    fn not_balanced() {
+        let mut tokenizer = Tokenizer::from(
+            "2022-05-13 ! We know this is wrong
+            Income:Salary      -2000 EUR
+            Assets:Checking     1000 EUR
+            "
+            .to_string(),
+        );
+
+        let options = CommonOpts::from_iter(["", "-f", ""].iter());
+        let parsed = tokenizer.tokenize(&options);
+        let ledger = parsed.to_ledger(&options);
+        assert!(ledger.is_err());
+        let mut output: String = String::new();
+        if let Err(err) = ledger {
+            let ledger_error = err.downcast_ref::<BalanceError>().unwrap();
+            match ledger_error {
+                BalanceError::TransactionIsNotBalanced(_t) => (),
+                other => {
+                    dbg!(other);
+                    panic!("Not balanced");
+                }
+            }
+            output = err.to_string();
+        }
+
+        // "Transaction is not balanced".red()
+        assert!(output.starts_with("\u{1b}[31mTransaction is not balanced\u{1b}[0m"));
+        assert!(output.lines().into_iter().count() > 1);
+    }
 }

src/models/transaction.rs

@@ -282,7 +282,7 @@ impl Transaction<Posting> {
         match total_balance(&*self.postings.borrow(), PostingType::VirtualMustBalance).can_be_zero()
         {
             true => {}
-            false => return Err(Box::new(BalanceError::TransactionIsNotBalanced)),
+            false => return Err(Box::new(BalanceError::TransactionIsNotBalanced(self.clone()))),
         }
 
         // 1. Iterate over postings
@@ -308,7 +308,7 @@ impl Transaction<Posting> {
                                 "Difference:  {}",
                                 expected_balance - Balance::from(balance.clone())
                             );
-                            return Err(Box::new(BalanceError::TransactionIsNotBalanced));
+                            return Err(Box::new(BalanceError::TransactionIsNotBalanced(self.clone())));
                         }
                     }
                 }
@@ -421,7 +421,7 @@ impl Transaction<Posting> {
                     self.postings.replace(postings);
                     Ok(transaction_balance)
                 }
-                false => Err(Box::new(BalanceError::TransactionIsNotBalanced)),
+                false => Err(Box::new(BalanceError::TransactionIsNotBalanced(self.clone()))),
             }
         } else {
             // Fill the empty posting

src/parser/tokenizers/transaction.rs

@@ -9,6 +9,7 @@ use pest::iterators::Pair;
 impl<'a> Tokenizer<'a> {
     /// Parses a transaction
     pub(crate) fn parse_transaction(&self, element: Pair<Rule>) -> Transaction<RawPosting> {
+
         let mut transaction = Transaction::<RawPosting>::new(match element.as_rule() {
             Rule::transaction => TransactionType::Real,
             Rule::automated_transaction => TransactionType::Automated,
@@ -239,14 +240,13 @@ mod tests {
     use crate::{parser::Tokenizer, CommonOpts};
 
     #[test]
-
     fn difficult_transaction_head() {
         let mut tokenizer = Tokenizer::from(
-            "2022-05-13 ! (8760) Intereses | EstateGuru
+            "2022-05-13 ! (8760) Interests | EstateGuru
             ; a transaction comment
             EstateGuru               1.06 EUR
             ; a posting comment
-            Ingresos:Rendimientos
+            Income:Earnings
             "
             .to_string(),
         );
@@ -257,7 +257,7 @@ mod tests {
         assert_eq!(transaction.status, TransactionStatus::NotChecked);
         assert_eq!(transaction.code, Some(String::from("8760")));
         assert_eq!(transaction.payee, Some(String::from("EstateGuru")));
-        assert_eq!(transaction.description, String::from("Intereses"));
+        assert_eq!(transaction.description, String::from("Interests"));
         for p in transaction.postings.borrow().iter() {
             assert_eq!(p.kind, PostingType::Real);
         }