src/check.rs

@@ -29,7 +29,7 @@ fn check_equal_sum(root: &data::Hoard) -> Result<(), DataError> {
             .iter()
             .try_fold(data::Decimal::ZERO, |acc, b| acc.checked_add(*b.amount));
         if net != Some(data::Decimal::ZERO) {
-            let report = ariadne::Report::build(ariadne::ReportKind::Error, tx.span()).with_labels(
+            let report = ariadne::Report::build(ariadne::ReportKind::Error, tx.source.unwrap_or_default()).with_labels(
                 tx.changes.iter().map(|v| {
                     let span = v.amount.span().union(v.unit.span());
                     ariadne::Label::new(span).with_message("change here")
@@ -121,11 +121,11 @@ fn check_balances(root: &data::Hoard) -> Result<(), DataError> {
                 .or_insert_with(|| Spanned::new(data::Decimal::default(), io::Span::default()));
             let last_span = bal.span();
             bal.0 = bal.checked_add(*change.amount).unwrap();
-            bal.1 = change.1;
+            bal.1 = change.source.unwrap();
 
             if let Some(sbal) = change.balance.as_ref() {
                 if **sbal != bal.0 {
-                    let report = ariadne::Report::build(ariadne::ReportKind::Error, txn.span())
+                    let report = ariadne::Report::build(ariadne::ReportKind::Error, txn.source.unwrap_or_default())
                         .with_label(ariadne::Label::new(sbal.span()).with_message(format!(
                             "Calculated balance is {} {}, specified balance is {} {}",
                             bal, change.unit, sbal, change.unit
@@ -133,7 +133,7 @@ fn check_balances(root: &data::Hoard) -> Result<(), DataError> {
                     let report = if !last_span.is_empty() {
                         report.with_label(
                             ariadne::Label::new(last_span)
-                                .with_message(format!("Last balance is from here")),
+                                .with_message("Last balance is from here"),
                         )
                     } else {
                         report

src/cmd.rs

@@ -114,7 +114,7 @@ impl Command {
 
                 let tt = show::TransactionTable::default();
                 if let Some(ld) = data.ledger_data_for(aname) {
-                    tt.show(Some(&data), aname, ld.iter().map(io::Spanned::as_ref));
+                    tt.show(Some(&data), aname, ld.iter());
                 } else {
                     log::error!("account not found!");
                 }
@@ -139,7 +139,7 @@ impl Command {
                         let Some(txn) = le.as_transaction_mut() else {
                             continue;
                         };
-                        if !txn.get_annotation("id").is_some() {
+                        if txn.get_annotation("id").is_none() {
                             // generated unique ID
                             let mut id = nanoid::nanoid!(10);
                             while used_ids.contains(&id) {
@@ -176,11 +176,10 @@ impl Command {
                     let new_source = std::fs::canonicalize(target.as_os_str())?
                         .into_os_string()
                         .into();
-                    let span = io::Span::null_for_file(new_source);
 
                     let new_data = imported
                         .into_iter()
-                        .map(|txn| data::LedgerEntry::Transaction(io::Spanned(txn, span)))
+                        .map(|txn| data::LedgerEntry::Transaction(txn))
                         .collect_vec();
 
                     data::format_ledger(
@@ -218,7 +217,7 @@ impl Command {
                 show::TransactionTable::default().show(
                     Some(&data),
                     *account,
-                    txs.iter().map(|v| &v.0),
+                    txs.into_iter()
                 );
             }
         }

src/cmd/infer.rs

@@ -49,7 +49,7 @@ pub fn do_inference(data: &mut Hoard) -> anyhow::Result<bool> {
                 txn.title
             );
 
-            show_transaction(None, txn.as_ref());
+            show_transaction(None, txn);
 
             println!(
                 "Candidate account: {} (Y/n)",
@@ -58,7 +58,7 @@ pub fn do_inference(data: &mut Hoard) -> anyhow::Result<bool> {
             let answer = console::Term::stdout().read_char().unwrap();
             match answer.to_lowercase().next() {
                 Some('y') | Some('\n') | Some('\r') => {
-                    let new_account = candidate.account.0.clone();
+                    let new_account = *candidate.account;
                     println!(
                         "    Changing to account {} ...",
                         console::style(new_account).green()

src/data.rs

@@ -9,13 +9,12 @@ pub use rust_decimal::Decimal;
 
 use crate::prelude::*;
 
-pub mod spec;
-
+mod format;
 mod parse;
-pub use parse::parse_ledger;
+pub mod spec;
 
-mod format;
 pub use format::format_ledger;
+pub use parse::parse_ledger;
 
 pub struct UnitTag;
 impl stringstore::NamespaceTag for UnitTag {
@@ -50,6 +49,8 @@ impl std::fmt::Debug for Datestamp {
 
 #[derive(Clone, Debug, PartialEq, PartialOrd, Ord, Eq)]
 pub struct Change {
+    pub source: Option<io::Span>,
+
     pub account: Spanned<AccountName>,
     pub amount: Spanned<Decimal>,
     pub balance: Option<Spanned<Decimal>>,
@@ -58,10 +59,12 @@ pub struct Change {
 
 #[derive(Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
 pub struct Transaction {
+    pub source: Option<io::Span>,
+
     pub datestamp: Datestamp,
     pub title: Option<String>,
     pub annotations: Vec<String>,
-    pub changes: Vec<Spanned<Change>>,
+    pub changes: Vec<Change>,
 }
 
 impl Transaction {
@@ -69,14 +72,14 @@ impl Transaction {
         self.changes.iter().any(|b| b.account.as_ref() == &account)
     }
 
-    pub fn change_for(&self, account: AccountName) -> Option<&Spanned<Change>> {
+    pub fn change_for(&self, account: AccountName) -> Option<&Change> {
         self.changes.iter().find(|b| b.account.as_ref() == &account)
     }
 
     pub fn split_changes(
         &self,
         account: AccountName,
-    ) -> Option<(&Spanned<Change>, impl Iterator<Item = &Spanned<Change>>)> {
+    ) -> Option<(&Change, impl Iterator<Item = &Change>)> {
         let index = self
             .changes
             .iter()
@@ -109,21 +112,52 @@ impl Transaction {
     }
 }
 
+pub type TransactionRef = std::rc::Rc<std::cell::RefCell<Transaction>>;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+enum RawLedgerEntry {
+    Transaction(Transaction),
+    Comment(Spanned<String>),
+}
+
+impl RawLedgerEntry {
+    pub fn as_transaction(&self) -> Option<&Transaction> {
+        match self {
+            Self::Transaction(tx) => Some(tx),
+            _ => None,
+        }
+    }
+
+    pub fn as_transaction_mut(&mut self) -> Option<&mut Transaction> {
+        match self {
+            Self::Transaction(tx) => Some(tx),
+            _ => None,
+        }
+    }
+
+    pub fn span(&self) -> io::Span {
+        match self {
+            Self::Transaction(ts) => ts.source.unwrap_or_default(),
+            Self::Comment(c) => c.span(),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum LedgerEntry {
-    Transaction(Spanned<Transaction>),
+    Transaction(TransactionRef),
     Comment(Spanned<String>),
 }
 
 impl LedgerEntry {
-    pub fn as_transaction(&self) -> Option<&Spanned<Transaction>> {
+    pub fn as_transaction(&self) -> Option<&TransactionRef> {
         match self {
             Self::Transaction(tx) => Some(tx),
             _ => None,
         }
     }
 
-    pub fn as_transaction_mut(&mut self) -> Option<&mut Spanned<Transaction>> {
+    pub fn as_transaction_mut(&mut self) -> Option<&mut Transaction> {
         match self {
             Self::Transaction(tx) => Some(tx),
             _ => None,
@@ -132,7 +166,7 @@ impl LedgerEntry {
 
     pub fn span(&self) -> io::Span {
         match self {
-            Self::Transaction(ts) => ts.span(),
+            Self::Transaction(ts) => ts.source.unwrap_or_default(),
             Self::Comment(c) => c.span(),
         }
     }
@@ -143,9 +177,11 @@ pub struct Hoard {
     path: std::path::PathBuf,
     spec_root: spec::SpecRoot,
 
-    ledger_data: Vec<LedgerEntry>,
+    comments: Vec<Spanned<String>>,
+
+    raw_ledger_data: Vec<RawLedgerEntry>,
 
-    account_ledger_data: HashMap<AccountName, Vec<Spanned<Transaction>>>,
+    account_ledger_data: HashMap<AccountName, Vec<Transaction>>,
 }
 
 impl Hoard {
@@ -162,7 +198,8 @@ impl Hoard {
                 let mut r = Self {
                     path: path.into(),
                     spec_root,
-                    ledger_data: vec![],
+                    raw_ledger_data: vec![],
+                    comments: vec![],
                     account_ledger_data: Default::default(),
                 };
 
@@ -225,7 +262,7 @@ impl Hoard {
 
             let sf = io::SourceFile::new_from_string(path.into_os_string());
             if let Ok(data) = fsdata.fetch(&sf) {
-                self.ledger_data
+                self.raw_ledger_data
                     .extend(parse_ledger(sf, &self.spec_root, data.text())?);
             } else {
                 log::error!(
@@ -250,8 +287,8 @@ impl Hoard {
     }
 
     fn preprocess_ledger_data(&mut self) {
-        for entry in &self.ledger_data {
-            let LedgerEntry::Transaction(tx) = &entry else {
+        for entry in &self.raw_ledger_data {
+            let RawLedgerEntry::Transaction(tx) = &entry else {
                 continue;
             };
             for bal in &tx.changes {
@@ -271,14 +308,14 @@ impl Hoard {
         self.ledger_data.as_mut_slice()
     }
 
-    pub fn ledger_data_for(&self, aname: AccountName) -> Option<&[Spanned<Transaction>]> {
+    pub fn ledger_data_for(&self, aname: AccountName) -> Option<&[Transaction]> {
         self.account_ledger_data.get(&aname).map(Vec::as_slice)
     }
 
     pub fn ledger_data_for_mut(
         &mut self,
         aname: AccountName,
-    ) -> Option<&mut [Spanned<Transaction>]> {
+    ) -> Option<&mut [Transaction]> {
         self.account_ledger_data
             .get_mut(&aname)
             .map(Vec::as_mut_slice)

src/data/parse.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 
 use data::{AccountName, DataError, Datestamp, Decimal, Spanned, UnitName, spec::SpecRoot};
 
-use super::{Change, LedgerEntry, Transaction};
+use super::{Change, RawLedgerEntry, Transaction};
 
 use chumsky::{prelude::*, text::inline_whitespace};
 
@@ -11,7 +11,7 @@ type InputWithContext<'a> = chumsky::input::WithContext<io::Span, &'a str>;
 fn ledger_parser<'a>() -> impl Parser<
     'a,
     InputWithContext<'a>,
-    Vec<LedgerEntry>,
+    Vec<RawLedgerEntry>,
     chumsky::extra::Full<
         chumsky::error::Rich<'a, char, io::Span>,
         chumsky::extra::SimpleState<&'a SpecRoot>,
@@ -28,7 +28,7 @@ fn ledger_parser<'a>() -> impl Parser<
         .ignore_then(none_of("\n").repeated())
         .to_slice()
         .padded()
-        .map_with(|s: &str, e| LedgerEntry::Comment(Spanned::new(s.into(), e.span())));
+        .map_with(|s: &str, e| RawLedgerEntry::Comment(Spanned::new(s.into(), e.span())));
 
     let datestamp =
         group((int, just('-').ignored(), int, just('-').ignored(), int)).map(|(y, _, m, _, d)| {
@@ -105,12 +105,13 @@ fn ledger_parser<'a>() -> impl Parser<
             return Err(chumsky::error::Rich::custom(unit.span(), format!("no such unit '{unit}' found")))
         }
 
-        Ok(Spanned::new(Change {
+        Ok(Change {
             account: acc,
             amount,
             balance,
             unit,
-        }, span))
+            source: Some(span),
+        })
     });
 
     let annotation = mark('[')
@@ -139,15 +140,15 @@ fn ledger_parser<'a>() -> impl Parser<
     ))
     .map_with(
         |(_, datestamp, _, _, title, _, annotations, changes, _), e| {
-            LedgerEntry::Transaction(Spanned::new(
+            RawLedgerEntry::Transaction(
                 Transaction {
                     datestamp,
                     title: (!title.is_empty()).then_some(title),
                     annotations,
                     changes,
-                },
-                e.span(),
-            ))
+                    source: Some(e.span()),
+                }
+            )
         },
     );
 
@@ -158,7 +159,7 @@ pub fn parse_ledger(
     source: io::SourceFile,
     spec: &SpecRoot,
     data: &str,
-) -> Result<Vec<LedgerEntry>, DataError> {
+) -> Result<Vec<RawLedgerEntry>, DataError> {
     let parser = ledger_parser();
 
     let (presult, errors) = parser

src/import.rs

@@ -152,8 +152,8 @@ fn import_from_csv(
                     amount: txn_change.unwrap().into(),
                     balance: txn_balance.map(Into::into),
                     unit: txn_unit.or(aspec.unit).map(Into::into).unwrap(),
-                }
-                .into(),
+                    source: None,
+                },
                 data::Change {
                     account: target.into(),
                     amount: data::Decimal::ZERO
@@ -162,9 +162,10 @@ fn import_from_csv(
                         .into(),
                     balance: None,
                     unit: txn_unit.or(aspec.unit).map(Into::into).unwrap(),
-                }
-                .into(),
+                    source: None,
+                },
             ],
+            source: None,
         });
     }
 
@@ -183,7 +184,7 @@ fn recursive_order_search(
 
     let possibles = remaining.iter().cloned().collect::<Vec<_>>();
 
-    if let Some(last) = order.last().as_deref() {
+    if let Some(last) = order.last() {
         let Some(last_balance) = txns[*last].change_for(account).unwrap().balance.as_deref() else {
             return false;
         };

src/io.rs

@@ -7,7 +7,7 @@ impl stringstore::NamespaceTag for SourceTag {
 /// Canonicalized path to a file
 pub type SourceFile = stringstore::StoredOsString<SourceTag>;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Span {
     pub range: (usize, usize),
     pub context: Option<SourceFile>,
@@ -22,15 +22,6 @@ impl Span {
     }
 }
 
-impl Default for Span {
-    fn default() -> Self {
-        Self {
-            range: (0, 0),
-            context: None,
-        }
-    }
-}
-
 impl chumsky::span::Span for Span {
     type Offset = usize;
     type Context = SourceFile;