rename modules more similar to beancount

carderne · Mar 9, 2024 · f6bf5ae · f6bf5ae
1 parent d16f109
commit f6bf5ae
Show file tree

Hide file tree

Showing 6 changed files with 34 additions and 40 deletions.
diff --git a/src/book.rs b/src/book.rs
@@ -4,11 +4,9 @@ use log::debug;
 use rust_decimal::Decimal;
 
 use crate::{
-    directives::{
-        AccBal, AccStatuses, Account, Amount, CcyBal, Directive, Pad, Posting, Transaction,
-    },
+    data::{AccBal, AccStatuses, Account, Amount, CcyBal, Directive, Pad, Posting, Transaction},
     error::{BeanError, ErrorType},
-    parser,
+    loader,
 };
 
 /// Checks postings with no `Amount` and calculates the values
@@ -285,6 +283,6 @@ pub fn get_balances(dirs: &mut Vec<Directive>) -> (AccBal, Vec<BeanError>) {
         }
     }
     dirs.extend(ptxs);
-    parser::sort(dirs);
+    loader::sort(dirs);
     (bals, errs)
 }
diff --git a/src/directives.rs → src/data.rs b/src/directives.rs → src/data.rs
@@ -719,12 +719,12 @@ impl fmt::Display for Directive {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parser;
+    use crate::loader;
     #[test]
     fn test_open() {
         let text = r#"2023-01-01 open Assets:Bank GBP"#;
-        let entries = parser::parse(&text).unwrap();
-        let (dirs, _) = parser::consume(entries);
+        let entries = loader::load(&text).unwrap();
+        let (dirs, _) = loader::consume(entries);
         let date = NaiveDate::parse_from_str("2023-01-01", DATE_FMT).unwrap();
         let a = &Open {
             date,

diff --git a/src/error.rs b/src/error.rs
@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::directives::{DebugLine, Directive};
+use crate::data::{DebugLine, Directive};
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum ErrorType {

diff --git a/src/lib.rs b/src/lib.rs
@@ -3,31 +3,31 @@
 //! `bean-rs` is a [beancount](https://github.com/beancount/beancount) clone (one day...) in Rust
 
 mod book;
-mod directives;
+mod data;
 pub mod error;
 mod grammar;
-mod parser;
+mod loader;
 pub mod utils;
 
-use directives::AccBal;
+use data::AccBal;
 
-use crate::directives::Directive;
+use crate::data::Directive;
 use crate::error::BeanError;
 
 /// Loads the provided text into a Vec of Directives
 /// containing opens, closes, transactions etc
 fn load(text: String) -> (Vec<Directive>, Vec<BeanError>) {
-    let entries = parser::parse(&text);
+    let entries = loader::load(&text);
     let entries = match entries {
         Ok(entries) => entries,
         Err(error) => {
             let empty_dirs: Vec<Directive> = Vec::new();
             return (empty_dirs, vec![error]);
         }
     };
-    let (dirs, errs) = parser::consume(entries);
+    let (dirs, errs) = loader::consume(entries);
     let mut dirs = dirs;
-    parser::sort(&mut dirs);
+    loader::sort(&mut dirs);
     book::balance_transactions(&mut dirs);
     utils::debug_directives(&dirs);
     (dirs, errs)

diff --git a/src/parser.rs → src/loader.rs b/src/parser.rs → src/loader.rs
@@ -5,14 +5,14 @@ use pest::error::LineColLocation;
 use pest::iterators::Pairs;
 use pest::Parser;
 
-use crate::directives::Directive;
-use crate::directives::{self, DebugLine};
+use crate::data::Directive;
+use crate::data::{self, DebugLine};
 use crate::error::{BeanError, ErrorType};
 use crate::grammar::{BeanParser, Rule};
 use crate::utils;
 
 /// Parse the text using Pest
-pub fn parse(data: &str) -> Result<Pairs<'_, Rule>, BeanError> {
+pub fn load(data: &str) -> Result<Pairs<'_, Rule>, BeanError> {
     let mut entries = match BeanParser::parse(Rule::root, data) {
         Ok(pairs) => Ok(pairs),
         Err(error) => {
@@ -46,14 +46,14 @@ pub fn consume(entries: Pairs<'_, Rule>) -> (Vec<Directive>, Vec<BeanError>) {
         debug!("{:?}\t{:?}", entry.as_rule(), entry.as_span(),);
         match entry.as_rule() {
             Rule::option => {
-                dirs.push(Directive::ConfigOption(
-                    directives::ConfigOption::from_entry(entry),
-                ));
+                dirs.push(Directive::ConfigOption(data::ConfigOption::from_entry(
+                    entry,
+                )));
             }
             Rule::custom => {
-                dirs.push(Directive::ConfigCustom(
-                    directives::ConfigCustom::from_entry(entry),
-                ));
+                dirs.push(Directive::ConfigCustom(data::ConfigCustom::from_entry(
+                    entry,
+                )));
             }
             Rule::query => {
                 // TODO do something with queries
@@ -62,27 +62,25 @@ pub fn consume(entries: Pairs<'_, Rule>) -> (Vec<Directive>, Vec<BeanError>) {
                 debug!("Ignoring query {debug}");
             }
             Rule::commodity => {
-                dirs.push(Directive::Commodity(directives::Commodity::from_entry(
-                    entry,
-                )));
+                dirs.push(Directive::Commodity(data::Commodity::from_entry(entry)));
             }
             Rule::open => {
-                dirs.push(Directive::Open(directives::Open::from_entry(entry)));
+                dirs.push(Directive::Open(data::Open::from_entry(entry)));
             }
             Rule::close => {
-                dirs.push(Directive::Close(directives::Close::from_entry(entry)));
+                dirs.push(Directive::Close(data::Close::from_entry(entry)));
             }
             Rule::balance => {
-                dirs.push(Directive::Balance(directives::Balance::from_entry(entry)));
+                dirs.push(Directive::Balance(data::Balance::from_entry(entry)));
             }
             Rule::pad => {
-                dirs.push(Directive::Pad(directives::Pad::from_entry(entry)));
+                dirs.push(Directive::Pad(data::Pad::from_entry(entry)));
             }
             Rule::price => {
-                dirs.push(Directive::Price(directives::Price::from_entry(entry)));
+                dirs.push(Directive::Price(data::Price::from_entry(entry)));
             }
             Rule::document => {
-                dirs.push(Directive::Document(directives::Document::from_entry(entry)));
+                dirs.push(Directive::Document(data::Document::from_entry(entry)));
             }
             Rule::note => {
                 // TODO do something with notes
@@ -91,9 +89,7 @@ pub fn consume(entries: Pairs<'_, Rule>) -> (Vec<Directive>, Vec<BeanError>) {
                 debug!("Ignoring note {debug}");
             }
             Rule::transaction => {
-                dirs.push(Directive::Transaction(directives::Transaction::from_entry(
-                    entry,
-                )));
+                dirs.push(Directive::Transaction(data::Transaction::from_entry(entry)));
             }
             Rule::EOI => {
                 debug!("Hit EOI");
@@ -129,7 +125,7 @@ mod tests {
     #[test]
     fn test_parse() {
         let text = r#"2023-01-01 open Assets:Bank GBP"#;
-        let entries = parse(&text).unwrap();
+        let entries = load(&text).unwrap();
         let (dirs, _) = consume(entries);
         let got = &dirs[0];
         match got {
@@ -143,7 +139,7 @@ mod tests {
         let text = r#"
             2023-01-01 foo
         "#;
-        let entries = parse(&text).unwrap();
+        let entries = load(&text).unwrap();
         let (_, bad) = consume(entries);
         assert!(bad.len() == 1);
     }

diff --git a/src/utils.rs b/src/utils.rs
@@ -1,7 +1,7 @@
 use log::debug;
 use pest::iterators::Pair;
 
-use crate::directives::{AccBal, Directive};
+use crate::data::{AccBal, Directive};
 use crate::error::BeanError;
 use crate::grammar::Rule;