Changed structopt dependency to clap and updated to latest version.

.gitignore

@@ -4,5 +4,6 @@
 .DS_Store
 .vscode/*
 rls*
-Cargo.lock
-.env
+crptls/Cargo.lock
+.env
+crptls/target

Cargo.toml

@@ -1,31 +1,34 @@
 [package]
 name = "cryptools"
-version = "0.10.0"
+version = "0.12.7"
 authors = ["scoobybejesus <scoobybejesus@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"
 description = "Command-line utility for processing cryptocurrency transactions into 'lots' and 'movements'."
 
-[lib]
-name = "crptls"
-path = "src/lib.rs"
+[features]
+# The default optional package. Many people will want to use this feature,
+# but it is optional because Windows doesn't support it.
+default = ["print_menu"]
+
+print_menu = ["ratatui", "termion"]
 
 [[bin]]
 name = "cryptools"
 path = "src/main.rs"
 
+[workspace]
+
 [dependencies]
-csv = "1.0.0"
-serde = { version = "1.0.75", features = ["derive"] }
-serde_derive = "1.0.75"
-decimal = "2.0.4"
-chrono = { version = "0.4", features = ["serde"] }
-chrono-tz = "0.5"
-time = "0.1.42"
-structopt = "0.2.10"
-rustyline = "5.0.0"
-tui = "0.5"
-termion = "1.5"
-dotenv = "0.14.1"
+crptls = { path = "crptls" }
+csv = "1.3.0"
+rust_decimal = "1.32.0"
+rust_decimal_macros = "1.32.0"
+chrono = { version = "0.4.31", features = ["serde"] }
+clap = { version = "4.4.6", features = ["derive", "wrap_help"] }
+rustyline = "12.0.0"
+ratatui = { version = "0.24.0", optional = true, features = ['termion'] }
+termion = { version = "2.0.1", optional = true }
+dotenv = "0.15.0"
 
 [profile.release]
-lto = true
+lto = true

InputFile_CSV.md

@@ -61,11 +61,12 @@ The rules for successfully preparing and maintaining the input file can generall
 
 1. The first account must be given number `1`, and each additional account must count up sequentially.
 2. `Proceeds` is the value of the transaction (measured in the home currency), whether spent, received, or exchanged.
-It is **required** in order to properly calculate income/expense/gain/loss.
+It is **required** in order to properly calculate income/expense/gain/loss, and it's always a positive number.
 3. `Proceeds` must have a period as the decimal separator (`1,000.00` not `1.000,00`) and must not contain the ticker or symbol (USD or $).
 4. Margin quote account `ticker`s must be followed by an underscore and the base account ticker (i.e., `BTC_xmr`).
 5. Only home currency accounts can have negative balances. Non-margin crypto accounts may not go negative at any time.
 (Exception: crypto margin accounts may go negative.)
+6. There is now experimental support for values/quantities being in 'Accounting'/'comma' format, meaning negative numbers may be surrounded in parentheses.
 
 As you can see, most of the rules can generally be ignored.
 In fact, the only tricky field is the `proceeds` column, but even that becomes second nature soon enough.
@@ -200,13 +201,12 @@ but be sure not to include the ticker or symbol of the currency
 (i.e., for `$14,567.27 USD`, enter `14567.27` or `14,567.27`).
 
 * **memo**: This can be a string of characters of any length, though fewer than 20-30 characters is advised.
-Currently, **commas** in the memo field are **not** supported.
 
 * *quantity*: This is similar to **proceeds**, in that the **decimal separator** must be a **period**,
 and you *cannot* include the ticker or symbol of the currency in that field.
 It is different from **proceeds** in that this will be parsed into a 128-bit precision decimal floating point number,
-and a negative value can be indicated via a preceding `-`.
-Negative values currently cannot be parsed if they are instead wrapped in parentheses (i.e., `(123.00)`).
+and a negative value should be indicated via a preceding minus sign (`-`),
+though experimental support now exists to parse negative values wrapped in parentheses (i.e., `(123.00)`).
 
 ##### Rows
 

LEGAL.txt

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 //
 // All rights reserved.
 //

README.md

@@ -34,7 +34,7 @@ so it can be successfully imported into `cryptools`.
 
 * Two methods each of LIFO or FIFO (compatible w/ the concept of "specific identification")
 
-* Ability to perform like-kind exchange treatment through a particular date
+* Ability to perform like-kind exchange treatment through a particular date (must use wizard or `.env` file)
 
 * Compatible with any (single) home currency
 
@@ -58,21 +58,16 @@ when appreciated cryptocurrency was used to make a tax-deductible charitable con
 import and may cause unintended rounding issues.
 
 * Microsoft Excel.  Don't let Excel cause you to bang your head against a wall.
-Picture this scenario.  You keep your transactions for your input file in a Google Sheet,
-and you're meticulous about making sure it's perfect.
-You then download it as a CSV file and import it into `cryptools`.
-It works perfectly, and you have all your reports.
-Then you realize you'd like to quickly change a memo and re-run the reports, so you open the CSV file in Excel and edit it.
-Then you import it into `cryptools` again and the program panics!
-What happened is most likely that Excel changed the rounding of your precise decimals underneath you!
-Depending on the rounding, `cryptools` may think your input file has been incorrectly prepared
-because you've supposedly spent more coins than you actually owned at that time.
-`Cryptools` does not let you spend coins you don't own, and it will exit upon finding such a condition.
-The program is right, and your data is right, but Excel modified your data, so the program crashed for "no reason."
-The solution is to have Excel already open, then in the ribbon's Data tab, you'll import your CSV file "From Text."
-You'll choose Delimited, and Comma, and then highlight every column and choose Text as the data type.
-
-* Currently, does not build on Windows due to the Termion crate (used for the print menu).
+`Cryptools` does not let you spend coins you don't own, and it will panic/exit upon discovering such a condition.
+You may believe your data is perfect, but Excel will change the precision of your numbers from underneath you if you're not careful.
+If automatic rounding causes your values/quantities to change, the data may then suggest you *are* spending coins you don't have.
+You must take steps to account for this.
+    - All your transaction values/quantity must **not** be kept in 'General' formatting. Using 'numeric' or 'comma' is recommended.
+    - If opening a "correct" CSV that isn't otherwise formatted, instead go to the Data tab and import the CSV "From Text," avoiding 'General' as the data type.
+        - In either of these cases, for every cell with crypto transaction quantities/amounts, adjust rounding to view **8** decimal places.
+    - Excel writes numeric values to a CSV file as they appear in the cell, not their underlying actual value, so:
+        - Go into options and choose to "Set precision as displayed."  This is found in different places in Mac and Windows.
+    - If your CSV Input File has MM-dd-YY date format, opening in Excel will change it to MM/dd/YY, so you'll have to pass the -d flag (or related `.env` variable).
 
 ## Installation
 
@@ -82,10 +77,15 @@ You'll choose Delimited, and Comma, and then highlight every column and choose T
 
 This will build `./target/debug/cryptools` (or `./target/release/cryptools` for a non-debug build).
 
+### Note on Windows
+
+Windows won't build with the current TUI print menu.  To build on Windows, try with `cargo build --no-default-features`.
+
 ## Usage
 
 Run `./target/debug/cryptools` with no arguments (or with `--help`, or `-h`) to see usage.
-Alternatively, run `cargo run`, in which case command-line options for `cryptools` may be entered following `--`, e.g., `cargo run -- -h`.
+Alternatively, run `cargo run`, in which case command-line parameters for `cryptools` may be entered following `--`,
+e.g., `cargo run -- -h` or `cargo run -- my_input_file.csv -ai`.
 
 Running with no options/arguments will lead the user through a wizard.
 To skip the wizard, there are three requirements:
@@ -96,7 +96,9 @@ To skip the wizard, there are three requirements:
 `cryptools` will spit out an error message and then exit/panic if your CSV input file is malformed.
 The error message will generally tell you why.
 Consider using the python script (root directory of the repo) to sanitize your input file,
-in case the file contains negative numbers in parentheses, numbers with commas, or extra rows/columns.
+in case the file contains negative numbers in parentheses, numbers with commas, or extra rows/columns
+(though now there is experimental support for 'Accounting'/'comma' number formatting,
+meaning negative quantities can now be parsed even if indicated by parentheses instead of a minus sign).
 
 See `/examples/` directory for further guidance,
 or jump directly to the [examples.md](https://github.com/scoobybejesus/cryptools/blob/master/examples/examples.md) file.
@@ -105,7 +107,8 @@ or jump directly to the [examples.md](https://github.com/scoobybejesus/cryptools
 See [.env.example](https://github.com/scoobybejesus/cryptools/blob/master/examples/.env.example) for those defaults.
 If you wish to skip the wizard but require changes to default settings, copy `.env.example` to `.env` and make your changes.
 The `.env` file must be placed in the directory from which `cryptools` is run or a parent directory.
-Alternatively, the respective environment variables may be set manually.
+Alternatively, the respective environment variables may be set manually,
+or it may be easier to choose the proper command line flag (such as `-d` for `date_separator_is_slash` or `-i` for `iso_date`.).
 
 #### Pro Tip
 

crptls/AUTHORS

@@ -0,0 +1 @@
+scoobybejesus <scoobybejesus@gmail.com>

crptls/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "crptls"
+version = "0.2.3"
+authors = ["scoobybejesus <scoobybejesus@users.noreply.github.com>"]
+edition = "2021"
+
+[dependencies]
+rust_decimal = "1.32.0"
+rust_decimal_macros = "1.32.0"
+chrono = { version = "0.4.31", features = ["serde"] }
+csv = "1.3.0"
+serde = { version = "1.0.189", features = ["derive"] }
+serde_derive = "1.0.189"
+time = "0.3.30"

crptls/LEGAL.txt

@@ -0,0 +1,27 @@
+// Copyright (c) 2017-2023, scoobybejesus
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions, and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

crptls/src/account.rs

@@ -1,17 +1,18 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::rc::{Rc, Weak};
 use std::cell::{Cell, RefCell};
 use std::fmt;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 use std::error::Error;
 
-use chrono::{NaiveDate};
-use decimal::d128;
+use chrono::NaiveDate;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 use serde_derive::{Serialize, Deserialize};
 
-use crate::crptls_lib::transaction::{Transaction, ActionRecord, Polarity, TxType};
+use crate::transaction::{Transaction, ActionRecord, Polarity, TxType};
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub struct RawAccount {
@@ -44,9 +45,9 @@ pub struct Account {
 
 impl Account {
 
-	pub fn get_sum_of_amts_in_lots(&self) -> d128 {
+	pub fn get_sum_of_amts_in_lots(&self) -> Decimal {
 		let lots = self.list_of_lots.borrow();
-		let mut total_amount = d128!(0);
+		let mut total_amount = dec!(0);
 			for lot in lots.iter() {
 				let sum = lot.get_sum_of_amts_in_lot();
 				total_amount += sum;
@@ -54,9 +55,9 @@ impl Account {
 		total_amount
 	}
 
-	pub fn get_sum_of_lk_basis_in_lots(&self) -> d128 {
+	pub fn get_sum_of_lk_basis_in_lots(&self) -> Decimal {
 		let lots = self.list_of_lots.borrow();
-		let mut total_amount = d128!(0);
+		let mut total_amount = dec!(0);
 			for lot in lots.iter() {
 				let sum = lot.get_sum_of_lk_basis_in_lot();
 				total_amount += sum;
@@ -64,9 +65,9 @@ impl Account {
 		total_amount
 	}
 
-	pub fn get_sum_of_orig_basis_in_lots(&self) -> d128 {
+	pub fn get_sum_of_orig_basis_in_lots(&self) -> Decimal {
 		let lots = self.list_of_lots.borrow();
-		let mut total_amount = d128!(0);
+		let mut total_amount = dec!(0);
 			for lot in lots.iter() {
 				let sum = lot.get_sum_of_orig_basis_in_lot();
 				total_amount += sum;
@@ -79,7 +80,7 @@ impl Account {
         let mut count = 0;
 
         for lot in self.list_of_lots.borrow().iter() {
-            if lot.get_sum_of_amts_in_lot() > d128!(0) {
+            if lot.get_sum_of_amts_in_lot() > dec!(0) {
                 count += 1
             }
         }
@@ -102,20 +103,20 @@ pub struct Lot {
 }
 
 impl Lot {
-	pub fn get_sum_of_amts_in_lot(&self) -> d128 {
-		let mut amts = d128!(0);
+	pub fn get_sum_of_amts_in_lot(&self) -> Decimal {
+		let mut amts = dec!(0);
 		self.movements.borrow().iter().for_each(|movement| amts += movement.amount);
 		amts
 	}
 
-	pub fn get_sum_of_lk_basis_in_lot(&self) -> d128 {
-		let mut amts = d128!(0);
+	pub fn get_sum_of_lk_basis_in_lot(&self) -> Decimal {
+		let mut amts = dec!(0);
 		self.movements.borrow().iter().for_each(|movement| amts += movement.cost_basis_lk.get());
 		amts
 	}
 
-	pub fn get_sum_of_orig_basis_in_lot(&self) -> d128 {
-		let mut amts = d128!(0);
+	pub fn get_sum_of_orig_basis_in_lot(&self) -> Decimal {
+		let mut amts = dec!(0);
 		self.movements.borrow().iter().for_each(|movement| amts += movement.cost_basis.get());
 		amts
 	}
@@ -123,18 +124,18 @@ impl Lot {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Movement {
-	pub amount: d128,
+	pub amount: Decimal,
 	pub date_as_string: String,
 	pub date: NaiveDate,
 	pub transaction_key: u32,
 	pub action_record_key: u32,
-	pub cost_basis: Cell<d128>,	//	Initialized with 0. Set in add_cost_basis_to_movements()
-	pub ratio_of_amt_to_incoming_mvmts_in_a_r: d128,	//	Set in process_multiple_incoming_lots_and_mvmts() and incoming flow dual actionrecord transactions
-	pub ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell<d128>,	//	Set in wrap_mvmt_and_push()
+	pub cost_basis: Cell<Decimal>,	//	Initialized with 0. Set in add_cost_basis_to_movements()
+	pub ratio_of_amt_to_incoming_mvmts_in_a_r: Decimal,	//	Set in process_multiple_incoming_lots_and_mvmts() and incoming flow dual actionrecord transactions
+	pub ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell<Decimal>,	//	Set in wrap_mvmt_and_push()
 	pub lot_num: u32,
-	pub proceeds: Cell<d128>,	//	Initialized with 0. Set in add_proceeds_to_movements()
-    pub proceeds_lk: Cell<d128>,
-    pub cost_basis_lk: Cell<d128>,
+	pub proceeds: Cell<Decimal>,	//	Initialized with 0. Set in add_proceeds_to_movements()
+    pub proceeds_lk: Cell<Decimal>,
+    pub cost_basis_lk: Cell<Decimal>,
 }
 
 impl Movement {
@@ -154,7 +155,7 @@ impl Movement {
         &self,
         acct_map: &HashMap<u16, Account>,
         ar_map: &HashMap<u32, ActionRecord>
-    ) -> d128 {
+    ) -> Decimal {
 
         let lot = self.get_lot(acct_map, ar_map);
 		let list_of_lot_mvmts = lot.movements.borrow();
@@ -167,7 +168,7 @@ impl Movement {
         &self,
         acct_map: &HashMap<u16, Account>,
         ar_map: &HashMap<u32, ActionRecord>
-    ) -> d128 {
+    ) -> Decimal {
 
         let lot = self.get_lot(acct_map, ar_map);
 		let list_of_lot_mvmts = lot.movements.borrow();
@@ -180,7 +181,7 @@ impl Movement {
         &self,
         acct_map: &HashMap<u16, Account>,
         ar_map: &HashMap<u32, ActionRecord>
-    ) -> d128 {
+    ) -> Decimal {
 
         let lot = self.get_lot(acct_map, ar_map);
 		let list_of_lot_mvmts = lot.movements.borrow();
@@ -189,11 +190,11 @@ impl Movement {
 		cost_basis
 	}
 
-	pub fn get_lk_gain_or_loss(&self) -> d128 {
+	pub fn get_lk_gain_or_loss(&self) -> Decimal {
 		self.proceeds_lk.get() + self.cost_basis_lk.get()
 	}
 
-    pub fn get_orig_gain_or_loss(&self) -> d128 {
+    pub fn get_orig_gain_or_loss(&self) -> Decimal {
 		self.proceeds.get() + self.cost_basis.get()
 	}
 
@@ -207,7 +208,6 @@ impl Movement {
 		txns_map: &HashMap<u32, Transaction>
 	) -> Term {
 
-    	use time::Duration;
 		let ar = ar_map.get(&self.action_record_key).unwrap();
 		let lot = Self::get_lot(&self, acct_map, ar_map);
 
@@ -220,7 +220,7 @@ impl Movement {
 				let txn = txns_map.get(&self.transaction_key).unwrap();
 				if txn.action_record_idx_vec.len() == 2 {
 					let lot_date_for_basis_purposes = lot.date_for_basis_purposes;
-					if self.date.signed_duration_since(lot_date_for_basis_purposes) > Duration::days(365) {
+					if self.date.signed_duration_since(lot_date_for_basis_purposes) > chrono::Duration::days(365) {
 						return Term::LT
 					}
 					return Term::ST
@@ -229,7 +229,7 @@ impl Movement {
 				// For a single-`action record` `transaction`, term is meaningless, but it is being shown
 				// in the context of the holding period, in the event it were sold "today".
 				let today: NaiveDate = chrono::Local::now().naive_utc().date();
-				if today.signed_duration_since(lot.date_for_basis_purposes) > Duration::days(365) {
+				if today.signed_duration_since(lot.date_for_basis_purposes) > chrono::Duration::days(365) {
 					Term::LT
 				}
 				else {
@@ -241,7 +241,7 @@ impl Movement {
 
 				let lot_date_for_basis_purposes = lot.date_for_basis_purposes;
 
-                if self.date.signed_duration_since(lot_date_for_basis_purposes) > Duration::days(365) {
+                if self.date.signed_duration_since(lot_date_for_basis_purposes) > chrono::Duration::days(365) {
 					return Term::LT
 				}
 				Term::ST
@@ -256,7 +256,7 @@ impl Movement {
 		raw_accts: &HashMap<u16, RawAccount>,
 		acct_map: &HashMap<u16, Account>,
 		txns_map: &HashMap<u32, Transaction>,
-	)-> Result<d128, Box<dyn Error>> {  //  Returns 0 or positive number
+	)-> Result<Decimal, Box<dyn Error>> {  //  Returns 0 or positive number
 
 		let txn = txns_map.get(&self.transaction_key).expect("Couldn't get txn. Tx num invalid?");
 
@@ -269,10 +269,10 @@ impl Movement {
                 if ar.direction() == Polarity::Incoming {
 					Ok(-self.proceeds_lk.get())
 				}
-				else { Ok(d128!(0)) }
+				else { Ok(dec!(0)) }
 			}
-			TxType::Exchange => { Ok(d128!(0)) }
-			TxType::ToSelf => { Ok(d128!(0)) }
+			TxType::Exchange => { Ok(dec!(0)) }
+			TxType::ToSelf => { Ok(dec!(0)) }
 		}
 	}
 
@@ -282,7 +282,7 @@ impl Movement {
 		raw_accts: &HashMap<u16, RawAccount>,
 		acct_map: &HashMap<u16, Account>,
 		txns_map: &HashMap<u32, Transaction>,
-	)-> Result<d128, Box<dyn Error>> {  //  Returns 0 or negative number
+	)-> Result<Decimal, Box<dyn Error>> {  //  Returns 0 or negative number
 
 		let txn = txns_map.get(&self.transaction_key).expect("Couldn't get txn. Tx num invalid?");
 
@@ -299,7 +299,7 @@ impl Movement {
 
                     if raw_acct.is_margin {
 
-                       Ok(d128!(0))
+                       Ok(dec!(0))
 
                     } else {
 
@@ -307,10 +307,10 @@ impl Movement {
                         Ok(expense)
                     }
 				}
-				else { Ok(d128!(0)) }
+				else { Ok(dec!(0)) }
 			}
-			TxType::Exchange => { Ok(d128!(0)) }
-			TxType::ToSelf => { Ok(d128!(0)) }
+			TxType::Exchange => { Ok(dec!(0)) }
+			TxType::ToSelf => { Ok(dec!(0)) }
 		}
     }
 
@@ -326,7 +326,7 @@ impl Movement {
 
                 let direction: String;
 
-                if self.amount > d128!(0) {
+                if self.amount > dec!(0) {
                     direction = "In".to_string();
                 } else {
                     direction = "Out".to_string()

crptls/src/core_functions.rs

@@ -1,19 +1,19 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::path::PathBuf;
 use std::error::Error;
 
-use std::collections::{HashMap};
+use std::collections::HashMap;
 
 use chrono::NaiveDate;
 
-use crate::crptls_lib::account::{Account, RawAccount, Lot};
-use crate::crptls_lib::transaction::{Transaction, ActionRecord};
-use crate::crptls_lib::csv_import_accts_txns;
-use crate::crptls_lib::import_cost_proceeds_etc;
-use crate::crptls_lib::create_lots_mvmts;
-use crate::crptls_lib::costing_method::InventoryCostingMethod;
+use crate::account::{Account, RawAccount, Lot};
+use crate::transaction::{Transaction, ActionRecord};
+use crate::csv_import_accts_txns;
+use crate::import_cost_proceeds_etc;
+use crate::create_lots_mvmts;
+use crate::costing_method::InventoryCostingMethod;
 
 
 /// `ImportProcessParameters` are determined from command-line args, environment variables, and/or wizard input from the user.
@@ -31,7 +31,6 @@ pub struct ImportProcessParameters {
     pub lk_basis_date_preserved: bool,
     pub should_export: bool,
     pub export_path: PathBuf,
-    pub print_menu: bool,
     pub journal_entry_export: bool,
 }
 
@@ -53,14 +52,15 @@ pub fn import_and_process_final(
 
     csv_import_accts_txns::import_from_csv(
         input_file_path,
-        settings,
+        settings.input_file_uses_iso_date_style,
+        &settings.input_file_date_separator,
         &mut raw_account_map,
         &mut account_map,
         &mut action_records_map,
         &mut transactions_map,
     )?;
 
-    println!("  Successfully imported csv file.");
+    println!("  Successfully imported CSV Input File.");
     println!("Processing the data...");
 
     transactions_map = create_lots_mvmts::create_lots_and_movements(
@@ -75,7 +75,7 @@ pub fn import_and_process_final(
     println!("  Created lots and movements.");
 
     import_cost_proceeds_etc::add_cost_basis_to_movements(
-        &settings,
+        &settings.home_currency,
         &raw_account_map,
         &account_map,
         &action_records_map,
@@ -98,7 +98,8 @@ pub fn import_and_process_final(
         println!(" Applying like-kind treatment through cut-off date: {}.", settings.lk_cutoff_date);
 
         import_cost_proceeds_etc::apply_like_kind_treatment(
-            &settings,
+            &settings.home_currency,
+            settings.lk_cutoff_date,
             &raw_account_map,
             &account_map,
             &action_records_map,

crptls/src/costing_method.rs

@@ -1,13 +1,11 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::fmt;
 
-use structopt::StructOpt;
-
 /// An `InventoryMethod` determines the order in which a `Lot` is chosen when posting
 /// `ActionRecord` amounts as individual `Movement`s.
-#[derive(Clone, Debug, PartialEq, StructOpt)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum InventoryCostingMethod {
     /// 1. LIFO according to the order the lot was created.
     LIFObyLotCreationDate,

crptls/src/create_lots_mvmts.rs

@@ -1,18 +1,19 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use std::rc::{Rc};
+use std::rc::Rc;
 use std::cell::{RefCell, Ref, Cell};
-use std::collections::{HashMap};
+use std::collections::HashMap;
 use std::error::Error;
 
-use decimal::d128;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 
-use crate::crptls_lib::core_functions::{ImportProcessParameters};
-use crate::crptls_lib::transaction::{Transaction, ActionRecord, TxType, Polarity, TxHasMargin};
-use crate::crptls_lib::account::{Account, RawAccount, Lot, Movement};
-use crate::crptls_lib::costing_method::{InventoryCostingMethod};
-use crate::crptls_lib::decimal_utils::{round_d128_1e8};
+use crate::core_functions::ImportProcessParameters;
+use crate::transaction::{Transaction, ActionRecord, TxType, Polarity, TxHasMargin};
+use crate::account::{Account, RawAccount, Lot, Movement};
+use crate::costing_method::InventoryCostingMethod;
+use crate::decimal_utils::round_d128_1e8;
 
 /// This is probably the most important function in the whole program.  Based on the data in the CSV Input File,
 /// the `account`s and `transaction`s will be created.  Once the `account`s and `transaction`s have been created, both
@@ -118,8 +119,8 @@ pub(crate) fn create_lots_and_movements(
             if !base_acct_lot_list.is_empty() && !quote_acct_lot_list.is_empty() {
                 // Since we know there has been activity, we set the bool variable above according to whether the `account`
                 // balances are both zero.
-                let base_balance_is_zero = base_acct_lot_list.last().unwrap().get_sum_of_amts_in_lot() == d128!(0);
-                let quote_balance_is_zero = quote_acct_lot_list.last().unwrap().get_sum_of_amts_in_lot() == d128!(0);
+                let base_balance_is_zero = base_acct_lot_list.last().unwrap().get_sum_of_amts_in_lot() == dec!(0);
+                let quote_balance_is_zero = quote_acct_lot_list.last().unwrap().get_sum_of_amts_in_lot() == dec!(0);
                 if base_balance_is_zero && quote_balance_is_zero {
                     acct_balances_are_zero = true
                 } else {
@@ -180,15 +181,22 @@ pub(crate) fn create_lots_and_movements(
                 date: txn.date,
                 transaction_key: txn_num,
                 action_record_key: base_ar_idx,
-                cost_basis: Cell::new(d128!(0.0)),
-                ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                cost_basis: Cell::new(dec!(0.0)),
+                ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                 lot_num: base_lot.lot_number,
-                proceeds: Cell::new(d128!(0.0)),
-                proceeds_lk: Cell::new(d128!(0.0)),
-                cost_basis_lk: Cell::new(d128!(0.0)),
+                proceeds: Cell::new(dec!(0.0)),
+                proceeds_lk: Cell::new(dec!(0.0)),
+                cost_basis_lk: Cell::new(dec!(0.0)),
             };
-            wrap_mvmt_and_push(base_mvmt, &base_ar, &base_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+            let raw_base_acct = raw_acct_map.get(&base_acct.raw_key).unwrap();
+            wrap_mvmt_and_push(
+                base_mvmt,
+                &base_ar,
+                &base_lot,
+                &chosen_home_currency,
+                &raw_base_acct,
+            );
 
             let quote_mvmt = Movement {
                 amount: quote_ar.amount,
@@ -196,15 +204,22 @@ pub(crate) fn create_lots_and_movements(
                 date: txn.date,
                 transaction_key: txn_num,
                 action_record_key: quote_ar_idx,
-                cost_basis: Cell::new(d128!(0.0)),
-                ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                cost_basis: Cell::new(dec!(0.0)),
+                ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                 lot_num: quote_lot.lot_number,
-                proceeds: Cell::new(d128!(0.0)),
-                proceeds_lk: Cell::new(d128!(0.0)),
-                cost_basis_lk: Cell::new(d128!(0.0)),
+                proceeds: Cell::new(dec!(0.0)),
+                proceeds_lk: Cell::new(dec!(0.0)),
+                cost_basis_lk: Cell::new(dec!(0.0)),
             };
-            wrap_mvmt_and_push(quote_mvmt, &quote_ar, &quote_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+            let raw_quote_acct = raw_acct_map.get(&quote_acct.raw_key).unwrap();
+            wrap_mvmt_and_push(
+                quote_mvmt,
+                &quote_ar,
+                &quote_lot,
+                &chosen_home_currency,
+                &raw_quote_acct,
+            );
 
             // Self-explanatory.  If new `lot`s were created, those `lot`s need to be pushed onto the `account`s.
             if acct_balances_are_zero {
@@ -260,15 +275,21 @@ pub(crate) fn create_lots_and_movements(
                         date: txn.date,
                         transaction_key: txn_num,
                         action_record_key: *ar_num,
-                        cost_basis: Cell::new(d128!(0.0)),
-                        ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                        cost_basis: Cell::new(dec!(0.0)),
+                        ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                         lot_num: lot.lot_number,
-                        proceeds: Cell::new(d128!(0.0)),
-                        proceeds_lk: Cell::new(d128!(0.0)),
-                        cost_basis_lk: Cell::new(d128!(0.0)),
+                        proceeds: Cell::new(dec!(0.0)),
+                        proceeds_lk: Cell::new(dec!(0.0)),
+                        cost_basis_lk: Cell::new(dec!(0.0)),
                     };
-                    wrap_mvmt_and_push(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+                    wrap_mvmt_and_push(
+                        whole_mvmt,
+                        &ar,
+                        &lot,
+                        &chosen_home_currency,
+                        &raw_acct,
+                    );
 
                     // If there is a new `lot`, push it onto the `account`
                     if new_lot_created { acct.list_of_lots.borrow_mut().push(lot); }
@@ -308,15 +329,21 @@ pub(crate) fn create_lots_and_movements(
                                 date: txn.date,
                                 transaction_key: txn_num,
                                 action_record_key: *ar_num,
-                                cost_basis: Cell::new(d128!(0.0)),
-                                ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                cost_basis: Cell::new(dec!(0.0)),
+                                ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                 lot_num: lot.lot_number,
-                                proceeds: Cell::new(d128!(0.0)),
-                                proceeds_lk: Cell::new(d128!(0.0)),
-                                cost_basis_lk: Cell::new(d128!(0.0)),
+                                proceeds: Cell::new(dec!(0.0)),
+                                proceeds_lk: Cell::new(dec!(0.0)),
+                                cost_basis_lk: Cell::new(dec!(0.0)),
                             };
-                            wrap_mvmt_and_push(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+                            wrap_mvmt_and_push(
+                                whole_mvmt,
+                                &ar,
+                                &lot,
+                                &chosen_home_currency,
+                                &raw_acct,
+                            );
                             continue
 
                         // For an outgoing `action record` with a non-margin `account`, this is where it is determined how to split
@@ -342,6 +369,8 @@ pub(crate) fn create_lots_and_movements(
                                     get_fifo_by_lot_basis_date(&list_of_lots_to_use.borrow())}
                             };
 
+                            assert_eq!(vec_of_ordered_index_values.len(), list_of_lots_to_use.borrow().len());
+
                             fn get_lifo_by_creation_date(list_of_lots: &Ref<Vec<Rc<Lot>>>) -> Vec<usize> {
                                 let mut vec_of_indexes = [].to_vec(); // TODO: Add with_capacity()
                                 for (idx, _lot) in list_of_lots.iter().enumerate() {
@@ -350,6 +379,7 @@ pub(crate) fn create_lots_and_movements(
                                 vec_of_indexes
                             }
 
+                            #[allow(suspicious_double_ref_op)]
                             fn get_lifo_by_lot_basis_date(list_of_lots: &Ref<Vec<Rc<Lot>>>) -> Vec<usize> {
                                 let mut reordered_vec = list_of_lots.clone().to_vec();
                                 let length = reordered_vec.len();
@@ -375,6 +405,7 @@ pub(crate) fn create_lots_and_movements(
                                 vec_of_indexes
                             }
 
+                            #[allow(suspicious_double_ref_op)]
                             fn get_fifo_by_lot_basis_date(list_of_lots: &Ref<Vec<Rc<Lot>>>) -> Vec<usize> {
                                 let mut reordered_vec = list_of_lots.clone().to_vec();
                                 let length = reordered_vec.len();
@@ -411,27 +442,29 @@ pub(crate) fn create_lots_and_movements(
                                 date: txn.date,
                                 transaction_key: txn_num,
                                 action_record_key: *ar_num,
-                                cost_basis: Cell::new(d128!(0.0)),
-                                ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                cost_basis: Cell::new(dec!(0.0)),
+                                ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                 lot_num: lot_to_use.lot_number,
-                                proceeds: Cell::new(d128!(0.0)),
-                                proceeds_lk: Cell::new(d128!(0.0)),
-                                cost_basis_lk: Cell::new(d128!(0.0)),
+                                proceeds: Cell::new(dec!(0.0)),
+                                proceeds_lk: Cell::new(dec!(0.0)),
+                                cost_basis_lk: Cell::new(dec!(0.0)),
                             };
 
+                            // Just a last minute check that a home currency `action record` isn't being handled here
+                            assert_eq!(raw_acct.is_home_currency(&chosen_home_currency), false);
+
                             // Beginning here, it will recursively attempt to fit the outgoing amount into `lot`s.
                             fit_into_lots(
-                                txn_num,
-                                *ar_num,
                                 whole_mvmt,
+                                ar.amount,
                                 list_of_lots_to_use,
                                 vec_of_ordered_index_values,
                                 index_position,
                                 &chosen_home_currency,
-                                &ar_map,
-                                &raw_acct_map,
-                                &acct_map,
+                                &ar,
+                                &raw_acct,
+                                &acct,
                             );
 
                             // Once the `action record`'s outgoing amount has been "consumed", the recording of this
@@ -475,15 +508,21 @@ pub(crate) fn create_lots_and_movements(
                                         date: txn.date,
                                         transaction_key: txn_num,
                                         action_record_key: *ar_num,
-                                        cost_basis: Cell::new(d128!(0.0)),
-                                        ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                        cost_basis: Cell::new(dec!(0.0)),
+                                        ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                         lot_num: lot.lot_number,
-                                        proceeds: Cell::new(d128!(0.0)),
-                                        proceeds_lk: Cell::new(d128!(0.0)),
-                                        cost_basis_lk: Cell::new(d128!(0.0)),
+                                        proceeds: Cell::new(dec!(0.0)),
+                                        proceeds_lk: Cell::new(dec!(0.0)),
+                                        cost_basis_lk: Cell::new(dec!(0.0)),
                                     };
-                                    wrap_mvmt_and_push(mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+                                    wrap_mvmt_and_push(
+                                        mvmt,
+                                        &ar,
+                                        &lot,
+                                        &chosen_home_currency,
+                                        &raw_acct,
+                                    );
 
                                     // Since a margin account is being posted new, a new lot is not created.  Once the `movement`
                                     // has been pushed to the `lot`, the recording of the `action record` is complete, and it's
@@ -515,13 +554,13 @@ pub(crate) fn create_lots_and_movements(
                                             date: txn.date,
                                             transaction_key: txn_num,
                                             action_record_key: *ar_num,
-                                            cost_basis: Cell::new(d128!(0.0)),
-                                            ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                            cost_basis: Cell::new(dec!(0.0)),
+                                            ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                             lot_num: lot.lot_number,
-                                            proceeds: Cell::new(d128!(0.0)),
-                                            proceeds_lk: Cell::new(d128!(0.0)),
-                                            cost_basis_lk: Cell::new(d128!(0.0)),
+                                            proceeds: Cell::new(dec!(0.0)),
+                                            proceeds_lk: Cell::new(dec!(0.0)),
+                                            cost_basis_lk: Cell::new(dec!(0.0)),
                                         };
 
                                     // The more complicated case is the dual-`action record` `flow` `transaction`.
@@ -544,7 +583,7 @@ pub(crate) fn create_lots_and_movements(
                                             // of the margin trade that is now ending in a profit.  And `total_positive_amounts` accounts for the total
                                             // amount of those margin-buys.
                                             let mut positive_mvmt_list: Vec<Rc<Movement>> = [].to_vec();
-                                            let mut total_positive_amounts = d128!(0);
+                                            let mut total_positive_amounts = dec!(0);
 
                                             // This is necessary to find the base account, because the margin-buys are reflected in this account.
                                             let (base_acct_key, quote_acct_key) = get_base_and_quote_acct_for_dual_actionrecord_flow_tx(
@@ -560,7 +599,7 @@ pub(crate) fn create_lots_and_movements(
                                             // It should be apparent that the relevant `lot` has been selected, and its `movement` are now iterated
                                             // over for capturing its `movement`s (for their date) and adding up their amounts.
                                             for base_acct_mvmt in base_acct_lot.movements.borrow().iter() {
-                                                if base_acct_mvmt.amount > d128!(0) {
+                                                if base_acct_mvmt.amount > dec!(0) {
                                                     // println!("In lot# {}, positive mvmt amount: {} {},",
                                                     //     base_acct_lot.lot_number,
                                                     //     mvmt.borrow().amount,
@@ -572,8 +611,8 @@ pub(crate) fn create_lots_and_movements(
 
                                             // These variables track relevant usage in the following for-loop.  These are used after the for-loop
                                             // when creating the final `movement`.
-                                            let mut amounts_used = d128!(0);
-                                            let mut percentages_used = d128!(0);
+                                            let mut amounts_used = dec!(0);
+                                            let mut percentages_used = dec!(0);
 
                                             // Here, the margin-buys are iterated over while creating proportionally-sized new `movement`s.
                                             // Note that this for-loop excludes the final positive `movement` because rounding must be taken into
@@ -599,15 +638,21 @@ pub(crate) fn create_lots_and_movements(
                                                     date: txn.date,
                                                     transaction_key: txn_num,
                                                     action_record_key: *ar_num,
-                                                    cost_basis: Cell::new(d128!(0.0)),
+                                                    cost_basis: Cell::new(dec!(0.0)),
                                                     ratio_of_amt_to_incoming_mvmts_in_a_r: percentage_used,
-                                                    ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                                    ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                                     lot_num: inner_lot.lot_number,
-                                                    proceeds: Cell::new(d128!(0.0)),
-                                                    proceeds_lk: Cell::new(d128!(0.0)),
-                                                    cost_basis_lk: Cell::new(d128!(0.0)),
+                                                    proceeds: Cell::new(dec!(0.0)),
+                                                    proceeds_lk: Cell::new(dec!(0.0)),
+                                                    cost_basis_lk: Cell::new(dec!(0.0)),
                                                 };
-                                                wrap_mvmt_and_push(inner_mvmt, &ar, &inner_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+                                                wrap_mvmt_and_push(
+                                                    inner_mvmt,
+                                                    &ar,
+                                                    &inner_lot,
+                                                    &chosen_home_currency,
+                                                    &raw_acct,
+                                                );
                                                 acct.list_of_lots.borrow_mut().push(inner_lot);
                                                 amounts_used += amount_used;
                                                 percentages_used += percentage_used;
@@ -633,13 +678,13 @@ pub(crate) fn create_lots_and_movements(
                                                 date: txn.date,
                                                 transaction_key: txn_num,
                                                 action_record_key: *ar_num,
-                                                cost_basis: Cell::new(d128!(0.0)),
-                                                ratio_of_amt_to_incoming_mvmts_in_a_r: round_d128_1e8(&(d128!(1.0) - percentages_used)),
-                                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                                cost_basis: Cell::new(dec!(0.0)),
+                                                ratio_of_amt_to_incoming_mvmts_in_a_r: round_d128_1e8(&(dec!(1.0) - percentages_used)),
+                                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                                 lot_num: lot.lot_number,
-                                                proceeds: Cell::new(d128!(0.0)),
-                                                proceeds_lk: Cell::new(d128!(0.0)),
-                                                cost_basis_lk: Cell::new(d128!(0.0)),
+                                                proceeds: Cell::new(dec!(0.0)),
+                                                proceeds_lk: Cell::new(dec!(0.0)),
+                                                cost_basis_lk: Cell::new(dec!(0.0)),
                                             };
 
                                         // Back to "base case" style treatment, if this is an incoming dual-`action record` `flow` `transaction`, but either
@@ -662,20 +707,26 @@ pub(crate) fn create_lots_and_movements(
                                                 date: txn.date,
                                                 transaction_key: txn_num,
                                                 action_record_key: *ar_num,
-                                                cost_basis: Cell::new(d128!(0.0)),
-                                                ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                                cost_basis: Cell::new(dec!(0.0)),
+                                                ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                                 lot_num: lot.lot_number,
-                                                proceeds: Cell::new(d128!(0.0)),
-                                                proceeds_lk: Cell::new(d128!(0.0)),
-                                                cost_basis_lk: Cell::new(d128!(0.0)),
+                                                proceeds: Cell::new(dec!(0.0)),
+                                                proceeds_lk: Cell::new(dec!(0.0)),
+                                                cost_basis_lk: Cell::new(dec!(0.0)),
                                             };
                                         }
                                     }
 
                                     // Here, finally, the lot and movement allocated at the top of `match TxType::Flow` have been set
                                     // and can be wrapped/pushed, at which point this `action record` is complete and it's onto the next.
-                                    wrap_mvmt_and_push(mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+                                    wrap_mvmt_and_push(
+                                        mvmt,
+                                        &ar,
+                                        &lot,
+                                        &chosen_home_currency,
+                                        &raw_acct,
+                                    );
                                     acct.list_of_lots.borrow_mut().push(lot);
                                     continue
                                 }
@@ -706,11 +757,10 @@ pub(crate) fn create_lots_and_movements(
                                             &og_ar,
                                             &ic_ar,
                                             &chosen_home_currency,
-                                            *ar_num,
-                                            &raw_acct_map,
                                             &acct_map,
                                             &txns_map,
                                             &ar_map,
+                                            &raw_acct,
                                         );
                                         continue
 
@@ -732,13 +782,13 @@ pub(crate) fn create_lots_and_movements(
                                             date: txn.date,
                                             transaction_key: txn_num,
                                             action_record_key: *ar_num,
-                                            cost_basis: Cell::new(d128!(0.0)),
-                                            ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                            cost_basis: Cell::new(dec!(0.0)),
+                                            ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                             lot_num: lot.lot_number,
-                                            proceeds: Cell::new(d128!(0.0)),
-                                            proceeds_lk: Cell::new(d128!(0.0)),
-                                            cost_basis_lk: Cell::new(d128!(0.0)),
+                                            proceeds: Cell::new(dec!(0.0)),
+                                            proceeds_lk: Cell::new(dec!(0.0)),
+                                            cost_basis_lk: Cell::new(dec!(0.0)),
                                         };
                                     }
                                 }
@@ -762,17 +812,23 @@ pub(crate) fn create_lots_and_movements(
                                         date: txn.date,
                                         transaction_key: txn_num,
                                         action_record_key: *ar_num,
-                                        cost_basis: Cell::new(d128!(0.0)),
-                                        ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0),
-                                        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+                                        cost_basis: Cell::new(dec!(0.0)),
+                                        ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0),
+                                        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
                                         lot_num: lot.lot_number,
-                                        proceeds: Cell::new(d128!(0.0)),
-                                        proceeds_lk: Cell::new(d128!(0.0)),
-                                        cost_basis_lk: Cell::new(d128!(0.0)),
+                                        proceeds: Cell::new(dec!(0.0)),
+                                        proceeds_lk: Cell::new(dec!(0.0)),
+                                        cost_basis_lk: Cell::new(dec!(0.0)),
                                     };
                                 }
                                 // The `lot` and `whole_mvmt` variables have been initialized/assigned
-                                wrap_mvmt_and_push(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+                                wrap_mvmt_and_push(
+                                    whole_mvmt,
+                                    &ar,
+                                    &lot,
+                                    &chosen_home_currency,
+                                    &raw_acct,
+                                );
                                 acct.list_of_lots.borrow_mut().push(lot);
                                 continue
                             }
@@ -792,11 +848,10 @@ pub(crate) fn create_lots_and_movements(
                                         &ar_map.get(txn.action_record_idx_vec.first().unwrap()).unwrap(), // outgoing
                                         &ar, // incoming
                                         &chosen_home_currency,
-                                        *ar_num,
-                                        &raw_acct_map,
                                         &acct_map,
                                         &txns_map,
                                         &ar_map,
+                                        &raw_acct,
                                     );
                                 }
                                 continue
@@ -874,13 +929,9 @@ fn wrap_mvmt_and_push(
     ar: &ActionRecord,
     lot: &Lot,
     chosen_home_currency: &str,
-    raw_acct_map: &HashMap<u16, RawAccount>,
-    acct_map: &HashMap<u16, Account>,
+    raw_acct: &RawAccount,
 ) {
 
-    let acct = acct_map.get(&ar.account_key).unwrap();
-    let raw_acct = raw_acct_map.get(&acct.raw_key).unwrap();
-
     // For outgoing `action record`s, this is an optimal spot for setting this struct field. Interestingly,
     // at the time of writing this note, this ratio isn't actually used.  The `ratio_of_amt_to_incoming_mvmts_in_a_r`
     // field, by contrast, is extremely important when deterministically setting basis and proceeds.
@@ -909,160 +960,112 @@ fn wrap_mvmt_and_push(
 /// then select the next `lot` and replace the `mvmt_to_fit` with a new `mvmt_to_fit` (reduced by the one
 /// that was pushed to the previous `lot`), and recursively check...
 fn fit_into_lots(
-    txn_num: u32,
-    spawning_ar_key: u32,
     mvmt_to_fit: Movement,
+    amt_to_fit: Decimal,
     list_of_lots_to_use: RefCell<Vec<Rc<Lot>>>,
     vec_of_ordered_index_values: Vec<usize>,
     index_position: usize,
     chosen_home_currency: &str,
-    ar_map: &HashMap<u32, ActionRecord>,
-    raw_acct_map: &HashMap<u16, RawAccount>,
-    acct_map: &HashMap<u16, Account>,
+    ar: &ActionRecord,
+    raw_acct: &RawAccount,
+    acct: &Account,
 ) {
 
-    let spawning_ar = ar_map.get(&spawning_ar_key).unwrap();
-
-    let acct = acct_map.get(&spawning_ar.account_key).unwrap();
-    let raw_acct = raw_acct_map.get(&acct.raw_key).unwrap();
-    assert_eq!(raw_acct.is_home_currency(&chosen_home_currency), false);
-
     let mut current_index_position = index_position;
 
-    // Get the `lot`, and then get its balance to see how much room there is
-    let lot = mvmt_to_fit.get_lot(acct_map, ar_map);
-    let mut mut_sum_of_mvmts_in_lot: d128 = d128!(0.0);
-    for movement in lot.movements.borrow().iter() {
-        mut_sum_of_mvmts_in_lot += movement.amount;
-    }
-    let sum_of_mvmts_in_lot = mut_sum_of_mvmts_in_lot;
-    assert!(sum_of_mvmts_in_lot >= d128!(0.0));
-
-    //  If the `lot` is "full", try the next
-    if sum_of_mvmts_in_lot == d128!(0.0) {
-        current_index_position += 1;
-        assert!(current_index_position < vec_of_ordered_index_values.len());
-        let lot_index = vec_of_ordered_index_values[current_index_position];
-        let newly_chosen_lot = list_of_lots_to_use.borrow()[lot_index].clone();
-        let possible_mvmt_to_fit = Movement {
-            amount: mvmt_to_fit.amount,
-            date_as_string: mvmt_to_fit.date_as_string.clone(),
-            date: mvmt_to_fit.date,
-            transaction_key: mvmt_to_fit.transaction_key,
-            action_record_key: mvmt_to_fit.action_record_key,
-            cost_basis: mvmt_to_fit.cost_basis,
-            ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0), //  Outgoing mvmt, so it's irrelevant
-            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
-            lot_num: newly_chosen_lot.lot_number,
-            proceeds: Cell::new(d128!(0.0)),
-            proceeds_lk: Cell::new(d128!(0.0)),
-            cost_basis_lk: Cell::new(d128!(0.0)),
-        };
-        fit_into_lots(
-            txn_num,
-            spawning_ar_key,
-            possible_mvmt_to_fit,
-            list_of_lots_to_use,
-            vec_of_ordered_index_values,
-            current_index_position,
-            &chosen_home_currency,
-            &ar_map,
-            &raw_acct_map,
-            &acct_map,
-        );
-        return;
-    }
-
-    // There is a balance in the `lot`, so check if the tentative amount of the `movement` will fit
-    assert!(sum_of_mvmts_in_lot > d128!(0.0));
-    let remainder_amt = mvmt_to_fit.amount;
-    let does_remainder_fit: bool = (sum_of_mvmts_in_lot + remainder_amt) >= d128!(0.0);
-
-    // If the remainder fits, the `movement` is wrapped/pushed, and the recursion is complete
-    if does_remainder_fit {
-        let remainder_that_fits = Movement {
-            amount: mvmt_to_fit.amount,
-            date_as_string: mvmt_to_fit.date_as_string.clone(),
-            date: mvmt_to_fit.date,
-            transaction_key: mvmt_to_fit.transaction_key,
-            action_record_key: mvmt_to_fit.action_record_key,
-            cost_basis: mvmt_to_fit.cost_basis,
-            ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0), //  Outgoing mvmt, so it's irrelevant
-            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
-            lot_num: lot.lot_number,
-            proceeds: Cell::new(d128!(0.0)),
-            proceeds_lk: Cell::new(d128!(0.0)),
-            cost_basis_lk: Cell::new(d128!(0.0)),
-        };
-        wrap_mvmt_and_push(remainder_that_fits, &spawning_ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-        return
-    }
-
-    // The `movement` doesn't fit in the present single `lot`, but some does. Create a `movement` that will fit,
-    // wrap/push it, and then continue to handle the remainder.
-    let mvmt = RefCell::new(mvmt_to_fit);
-    let mvmt_rc = Rc::from(mvmt);
-
-    let mvmt_that_fits_in_lot = Movement {
-        amount: (-sum_of_mvmts_in_lot).reduce(),
-        date_as_string: mvmt_rc.borrow().date_as_string.clone(),
-        date: mvmt_rc.borrow().date,
-        transaction_key: txn_num,
-        action_record_key: spawning_ar_key,
-        cost_basis: Cell::new(d128!(0.0)),
-        ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0), //  Outgoing mvmt, so it's irrelevant
-        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
-        lot_num: lot.lot_number,
-        proceeds: Cell::new(d128!(0.0)),
-        proceeds_lk: Cell::new(d128!(0.0)),
-        cost_basis_lk: Cell::new(d128!(0.0)),
-    };
-    wrap_mvmt_and_push(mvmt_that_fits_in_lot, &spawning_ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-
-    if vec_of_ordered_index_values.len() == current_index_position + 1 {
+    // Here is a check to make sure the `lot` will exist. If it won't, then there will be an index
+    // out of bounds error. The account balance should be zero in that case, but it is checked
+    // anyway before printing the error message for the user and exiting.
+    if vec_of_ordered_index_values.len() == current_index_position {
         println!("FATAL: Txn {} on {} spending {} {} has run out of lots to spend from.",
-            txn_num, lot.date_as_string, spawning_ar.amount, raw_acct.ticker);
-            let bal = if acct.get_sum_of_amts_in_lots() == d128!(0) { "0.00000000".to_string() } 
-                else { acct.get_sum_of_amts_in_lots().to_string() };
+            mvmt_to_fit.transaction_key, mvmt_to_fit.date_as_string, ar.amount, raw_acct.ticker);
+        let bal = if acct.get_sum_of_amts_in_lots() == dec!(0) { "0.00000000".to_string() }
+            else { acct.get_sum_of_amts_in_lots().to_string() };
         println!("Account balance is only: {}", bal);
         std::process::exit(1);
     }
 
-    current_index_position += 1;
+    // Get the `lot`, and then get its balance to see how much room there is
     let lot_index = vec_of_ordered_index_values[current_index_position];
-    let newly_chosen_lot = list_of_lots_to_use.borrow()[lot_index].clone();
+    let lot = acct.list_of_lots.borrow()[lot_index].clone();
+    let mut sum_of_mvmts_in_lot: Decimal = dec!(0.0);
+    for movement in lot.movements.borrow().iter() {
+        sum_of_mvmts_in_lot += movement.amount;
+    }
 
-    // Take tentative `movement` amount (negative) and sum with the amount just used from the
-    // `mvmt_that_fits_in_lot` to come up with the unused portion of this `action record` amount.
-    let remainder_amt_to_recurse = remainder_amt + sum_of_mvmts_in_lot;
-    // println!("Remainder amount to recurse: {}", remainder_amt_to_recurse);
-    let remainder_mvmt_to_recurse = Movement {
-        amount: remainder_amt_to_recurse.reduce(),
-        date_as_string: mvmt_rc.borrow().date_as_string.clone(),
-        date: mvmt_rc.borrow().date,
-        transaction_key: txn_num,
-        action_record_key: spawning_ar_key,
-        cost_basis: Cell::new(d128!(0.0)), //  This acts as a dummy value.
-        ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0), //  Outgoing mvmt, so it's irrelevant
-        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)), //  This acts as a dummy value.
-        lot_num: newly_chosen_lot.lot_number,
-        proceeds: Cell::new(d128!(0.0)),
-        proceeds_lk: Cell::new(d128!(0.0)),
-        cost_basis_lk: Cell::new(d128!(0.0)),
+    assert!(sum_of_mvmts_in_lot >= dec!(0.0));
+
+    //  If the `lot` is "full", try the next.
+    if sum_of_mvmts_in_lot == dec!(0.0) {
+
+        current_index_position += 1;
+
+        fit_into_lots(
+            mvmt_to_fit,
+            amt_to_fit,
+            list_of_lots_to_use,
+            vec_of_ordered_index_values,
+            current_index_position,
+            chosen_home_currency,
+            ar,
+            raw_acct,
+            acct,
+        );
+        return;
+    }
+
+    assert!(sum_of_mvmts_in_lot > dec!(0.0));
+
+    // If `remainder_amt_to_recurse` is positive, it means the `lot` balance exceeded `amt_to_fit`,
+    // therefore, the amount completely fits in the `lot`.  If negative, it is passed as the `amt_to_fit`
+    // for the next round of recursion.
+    let remainder_amt_to_recurse = (amt_to_fit + sum_of_mvmts_in_lot).round_dp(8);
+
+    // If the remainder fits, the `movement` is wrapped/pushed, and the recursion is complete.
+    if remainder_amt_to_recurse >= dec!(0.0) {
+
+        let remainder_mvmt_that_fits: Movement = Movement {
+            amount: amt_to_fit,
+            lot_num: lot.lot_number,
+            ..mvmt_to_fit
+        };
+        wrap_mvmt_and_push(
+            remainder_mvmt_that_fits,
+            &ar,
+            &lot,
+            &chosen_home_currency,
+            &raw_acct
+        );
+        return
+    }
+
+    // The amt_to_fit doesn't completely fit in the present `lot`, but some does. Create a `movement` that will fit.
+    let mvmt_that_fits_in_lot: Movement = Movement {
+        amount: (-sum_of_mvmts_in_lot).round_dp(8),
+        lot_num: lot.lot_number,
+        ..mvmt_to_fit.clone()
     };
+    wrap_mvmt_and_push(
+        mvmt_that_fits_in_lot,
+        &ar,
+        &lot,
+        &chosen_home_currency,
+        &raw_acct
+    );
 
-    // After applying some of the `action record`'s amount to another `lot`, take the remainder and recurse
+    current_index_position += 1;
+
+    // After applying some of the `amt_to_fit` to the `lot`, increment the index, take the remainder, and recurse
     fit_into_lots(
-        txn_num,
-        spawning_ar_key,
-        remainder_mvmt_to_recurse,
+        mvmt_to_fit,
+        remainder_amt_to_recurse.round_dp(8),  //  This was updated before recursing
         list_of_lots_to_use,
         vec_of_ordered_index_values,
-        current_index_position,
-        &chosen_home_currency,
-        &ar_map,
-        &raw_acct_map,
-        &acct_map,
+        current_index_position,     //  This was updated before recursing
+        chosen_home_currency,
+        ar,
+        raw_acct,
+        acct,
     );
 }
 
@@ -1074,20 +1077,18 @@ fn process_multiple_incoming_lots_and_mvmts(
     outgoing_ar: &ActionRecord,
     incoming_ar: &ActionRecord,
     chosen_home_currency: &str,
-    incoming_ar_key: u32,
-    raw_acct_map: &HashMap<u16, RawAccount>,
     acct_map: &HashMap<u16, Account>,
     txns_map: &HashMap<u32, Transaction>,
     ar_map: &HashMap<u32, ActionRecord>,
+    raw_acct: &RawAccount,
 ) {
 
-    let round_to_places = d128::from(1).scaleb(d128::from(-8));
     let txn = txns_map.get(&txn_num).expect("Couldn't get txn. Tx num invalid?");
 
     let acct_of_incoming_ar = acct_map.get(&incoming_ar.account_key).unwrap();
 
-    let mut all_but_last_incoming_mvmt_amt = d128!(0.0);
-    let mut all_but_last_incoming_mvmt_ratio = d128!(0.0);
+    let mut all_but_last_incoming_mvmt_amt = dec!(0.0);
+    let mut all_but_last_incoming_mvmt_ratio = dec!(0.0);
     // println!("Txn date: {}. Outgoing mvmts: {}, Outgoing amount: {}", txn.date, outgoing_ar.movements.borrow().len(), outgoing_ar.amount);
     let list_of_mvmts_of_outgoing_ar = outgoing_ar.get_mvmts_in_ar_in_lot_date_order(acct_map, txns_map);
     let list_of_mvmts_of_outgoing_ar_len = list_of_mvmts_of_outgoing_ar.len();
@@ -1098,10 +1099,10 @@ fn process_multiple_incoming_lots_and_mvmts(
         // println!("Ratio of outgoing amt to total actionrecord amt: {:.8}", ratio_of_outgoing_to_total_ar);
         let tentative_incoming_amt = ratio_of_outgoing_mvmt_to_total_ar * incoming_ar.amount;
         // println!("Unrounded incoming amt: {}", tentative_incoming_amt);
-        let corresponding_incoming_amt = tentative_incoming_amt.quantize(round_to_places);
+        let corresponding_incoming_amt = tentative_incoming_amt.round_dp(8);
         // println!("Rounded incoming amt: {}", corresponding_incoming_amt);
-        if corresponding_incoming_amt == d128!(0) { continue }  //  Due to rounding, this could be zero.
-        assert!(corresponding_incoming_amt > d128!(0.0));
+        if corresponding_incoming_amt == dec!(0) { continue }  //  Due to rounding, this could be zero.
+        assert!(corresponding_incoming_amt > dec!(0.0));
         let this_acct = acct_of_incoming_ar;
         let length_of_list_of_lots: usize = this_acct.list_of_lots.borrow().len();
         let inherited_date = outgoing_mvmt.get_lot(acct_map, ar_map).date_of_first_mvmt_in_lot;
@@ -1118,29 +1119,35 @@ fn process_multiple_incoming_lots_and_mvmts(
         )
         ;
         let incoming_mvmt = Movement {
-            amount: corresponding_incoming_amt.reduce(),
+            amount: corresponding_incoming_amt.round_dp(8),
             date_as_string: txn.date_as_string.clone(),
             date: txn.date,
             transaction_key: txn_num,
-            action_record_key: incoming_ar_key,
-            cost_basis: Cell::new(d128!(0.0)),
+            action_record_key: incoming_ar.self_ar_key,
+            cost_basis: Cell::new(dec!(0.0)),
             ratio_of_amt_to_incoming_mvmts_in_a_r: round_d128_1e8(&ratio_of_outgoing_mvmt_to_total_ar),
-            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+            ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
             lot_num: inner_lot.lot_number,
-            proceeds: Cell::new(d128!(0.0)),
-            proceeds_lk: Cell::new(d128!(0.0)),
-            cost_basis_lk: Cell::new(d128!(0.0)),
+            proceeds: Cell::new(dec!(0.0)),
+            proceeds_lk: Cell::new(dec!(0.0)),
+            cost_basis_lk: Cell::new(dec!(0.0)),
         };
         // println!("From first set of incoming movements, amount: {} {} to account: {}",
         //     incoming_mvmt.amount, acct_incoming_ar.ticker, acct_incoming_ar.account_num);
         all_but_last_incoming_mvmt_ratio += round_d128_1e8(&ratio_of_outgoing_mvmt_to_total_ar);
         all_but_last_incoming_mvmt_amt += incoming_mvmt.amount;
-        wrap_mvmt_and_push(incoming_mvmt, &incoming_ar, &inner_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+        wrap_mvmt_and_push(
+            incoming_mvmt,
+            &incoming_ar,
+            &inner_lot,
+            &chosen_home_currency,
+            &raw_acct,
+        );
         this_acct.list_of_lots.borrow_mut().push(inner_lot);
     }
     //  Second iteration, for final movement
     let corresponding_incoming_amt = incoming_ar.amount - all_but_last_incoming_mvmt_amt;
-    assert!(corresponding_incoming_amt > d128!(0.0));
+    assert!(corresponding_incoming_amt > dec!(0.0));
     let this_acct = acct_of_incoming_ar;
     let length_of_list_of_lots = this_acct.list_of_lots.borrow().len();
     let inherited_date = final_og_mvmt.get_lot(acct_map, ar_map).date_of_first_mvmt_in_lot;
@@ -1157,21 +1164,27 @@ fn process_multiple_incoming_lots_and_mvmts(
     )
     ;
     let incoming_mvmt = Movement {
-        amount: corresponding_incoming_amt.reduce(),
+        amount: corresponding_incoming_amt.round_dp(8),
         date_as_string: txn.date_as_string.clone(),
         date: txn.date,
         transaction_key: txn_num,
-        action_record_key: incoming_ar_key,
-        cost_basis: Cell::new(d128!(0.0)),
-        ratio_of_amt_to_incoming_mvmts_in_a_r: d128!(1.0) - all_but_last_incoming_mvmt_ratio,
-        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(1.0)),
+        action_record_key: incoming_ar.self_ar_key,
+        cost_basis: Cell::new(dec!(0.0)),
+        ratio_of_amt_to_incoming_mvmts_in_a_r: dec!(1.0) - all_but_last_incoming_mvmt_ratio,
+        ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(dec!(1.0)),
         lot_num: lot.lot_number,
-        proceeds: Cell::new(d128!(0.0)),
-        proceeds_lk: Cell::new(d128!(0.0)),
-        cost_basis_lk: Cell::new(d128!(0.0)),
+        proceeds: Cell::new(dec!(0.0)),
+        proceeds_lk: Cell::new(dec!(0.0)),
+        cost_basis_lk: Cell::new(dec!(0.0)),
     };
     // println!("Final incoming mvmt for this actionrecord, amount: {} {} to account: {}",
     //     incoming_mvmt.amount, acct_incoming_ar.ticker, acct_incoming_ar.account_num);
-    wrap_mvmt_and_push(incoming_mvmt, &incoming_ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
+    wrap_mvmt_and_push(
+        incoming_mvmt,
+        &incoming_ar,
+        &lot,
+        &chosen_home_currency,
+        &raw_acct,
+    );
     this_acct.list_of_lots.borrow_mut().push(lot);
 }

crptls/src/csv_import_accts_txns.rs

@@ -1,25 +1,26 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::error::Error;
 use std::process;
 use std::fs::File;
-use std::cell::{RefCell};
-use std::collections::{HashMap};
+use std::cell::RefCell;
+use std::collections::HashMap;
 use std::path::PathBuf;
 
 use chrono::NaiveDate;
-use decimal::d128;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 
-use crate::crptls_lib::core_functions::{ImportProcessParameters};
-use crate::crptls_lib::transaction::{Transaction, ActionRecord};
-use crate::crptls_lib::account::{Account, RawAccount};
-use crate::crptls_lib::decimal_utils::{round_d128_1e8};
+use crate::transaction::{Transaction, ActionRecord};
+use crate::account::{Account, RawAccount};
+use crate::decimal_utils::round_d128_1e8;
 
 
-pub(crate) fn import_from_csv(
+pub fn import_from_csv(
     import_file_path: PathBuf,
-    settings: &ImportProcessParameters,
+    iso_date_style: bool,
+    separator: &String,
     raw_acct_map: &mut HashMap<u16, RawAccount>,
     acct_map: &mut HashMap<u16, Account>,
     action_records: &mut HashMap<u32, ActionRecord>,
@@ -28,7 +29,7 @@ pub(crate) fn import_from_csv(
 
     let file = match File::open(import_file_path) {
         Ok(x) => {
-            println!("\nCSV ledger file opened successfully.\n");
+            // println!("\nCSV ledger file opened successfully.\n");
             x
         },
         Err(e) => {
@@ -46,7 +47,8 @@ pub(crate) fn import_from_csv(
 
     import_transactions(
         &mut rdr,
-        settings,
+        iso_date_style,
+        &separator,
         action_records,
         transactions_map,
     )?;
@@ -82,17 +84,14 @@ fn import_accounts(
             // println!("Assigned last header, record: {:?}", record);
 
             // A StringRecord doesn't accept the same range indexing needed below, so a Vec of Strings will be used
-            let mut headerstrings: Vec<String> = Vec::with_capacity(header1.len());
-            for field in header1.into_iter() {
-                headerstrings.push(field.to_string())
-            }
+            let headerstrings: Vec<String> = header1.into_iter().map(|field| field.to_string()).collect();
 
             let acct_num_warn = "Transactions will not import correctly if account numbers in the CSV import file aren't
 ordered chronologically (i.e., beginning in column 4 - the 1st account column - the value should be 1.
 The next column's value should be 2, then 3, etc, until the final account).";
 
             // Header row variables have been set.  It's now time to set up the accounts.
-            println!("Attempting to create accounts...");
+            println!("\nCreating accounts...");
 
             let length = &headerstrings.len();
 
@@ -111,7 +110,7 @@ The next column's value should be 2, then 3, etc, until the final account).";
                 let ticker:String = header3[ind].trim().to_string();   //  no .to_uppercase() b/c margin...
                 let margin_string = &header4.clone()[ind];
 
-                let is_margin:bool = match margin_string.trim().to_lowercase().as_str() {
+                let is_margin:bool = match margin_string.to_lowercase().trim() {
                     "no" | "non" | "false" => false,
                     "yes" | "margin" | "true" => true,
                     _ => {
@@ -144,7 +143,8 @@ The next column's value should be 2, then 3, etc, until the final account).";
 
 fn import_transactions(
     rdr: &mut csv::Reader<File>,
-    settings: &ImportProcessParameters,
+    iso_date_style: bool,
+    separator: &String,
     action_records: &mut HashMap<u32, ActionRecord>,
     txns_map: &mut HashMap<u32, Transaction>,
 ) -> Result<(), Box<dyn Error>> {
@@ -154,7 +154,7 @@ fn import_transactions(
     let mut changed_action_records = 0;
     let mut changed_txn_num = Vec::new();
 
-    println!("Attempting to create transactions...");
+    println!("Creating transactions...");
 
     for result in rdr.records() {
 
@@ -166,7 +166,6 @@ fn import_transactions(
         let mut this_tx_date: &str = "";
         let mut this_proceeds: &str;
         let mut this_memo: &str = "";
-        let mut this: String;
         let mut proceeds_parsed = 0f32;
 
         //  Next, create action_records.
@@ -181,10 +180,10 @@ fn import_transactions(
             //  Set metadata fields on first three fields.
             if idx == 0 { this_tx_date = field; }
             else if idx == 1 {
-                this = field.replace(",", "");
-                this_proceeds = this.as_str();
-                proceeds_parsed = this_proceeds.parse::<f32>()?;
+                let no_comma_string = field.replace(",", "");
+                proceeds_parsed = no_comma_string.parse::<f32>()?;
             }
+
             else if idx == 2 { this_memo = field; }
 
             //  Check for empty strings. If not empty, it's a value for an action_record.
@@ -194,9 +193,32 @@ fn import_transactions(
                 let acct_idx = ind - 2; //  acct_num and acct_key would be idx + 1, so subtract 2 from ind to get 1
                 let account_key = acct_idx as u16;
 
-                // TODO: implement conversion for negative numbers surrounded in parentheses
                 let amount_str = field.replace(",", "");
-                let amount = amount_str.parse::<d128>().unwrap();
+                let amount = match amount_str.parse::<Decimal>() {
+                    Ok(x) => x,
+                    Err(e) => {
+                        println!("FATAL: Couldn't convert amount to d128 for transaction:\n{:#?}", record);
+                        println!("Error: {}", e);
+                        std::process::exit(1);}
+                };
+
+                // When parsing to a d128, it won't error; rather it'll return a NaN. It must now check for NaN,
+                // and, if found, attempt to sanitize.  These checks will convert accounting/comma format to the expected
+                // format by removing parentheses from negatives and adding a minus sign in the front. It will also
+                // attempt to remove empty spaces and currency symbols or designations (e.g. $ or USD).
+                // if amount.is_none() {
+                //     let b = sanitize_string_for_d128_parsing_basic(field).parse::<Decimal>().unwrap();
+                //     amount = b;
+                // };
+                // if amount.is_none() {
+                //     let c = sanitize_string_for_d128_parsing_full(field).parse::<Decimal>().unwrap();
+                //     amount = c;
+                // };
+                // if amount.is_none() {
+                //     println!("FATAL: Couldn't convert amount to d128 for transaction:\n{:#?}", record);
+                //     std::process::exit(1);
+                // }
+
                 let amount_rounded = round_d128_1e8(&amount);
                 if amount != amount_rounded { changed_action_records += 1; changed_txn_num.push(this_tx_number); }
 
@@ -208,7 +230,7 @@ fn import_transactions(
                     movements: RefCell::new([].to_vec()),
                 };
 
-                if amount > d128!(0.0) {
+                if amount > dec!(0.0) {
                     incoming_ar = Some(action_record);
                     incoming_ar_num = Some(this_ar_number);
                     action_records_map_keys_vec.push(incoming_ar_num.unwrap())
@@ -220,6 +242,73 @@ fn import_transactions(
             }
         }
 
+        // Note: the rust Trait implementation of FromStr for f32 is capable of parsing:
+            // '3.14'
+            // '-3.14'
+            // '2.5E10', or equivalently, '2.5e10'
+            // '2.5E-10'
+            // '5.'
+            // '.5', or, equivalently, '0.5'
+            // 'inf', '-inf', 'NaN'
+        // Notable observations from the list:
+            // (a) scientific notation is accepted
+            // (b) accounting format (numbers in parens representing negative numbers) is not explicitly accepted
+        // Additionally notable:
+            // (a) the decimal separator must be a period
+            // (b) there can be no commas
+            // (c) there can be no currency info ($120 or 120USD, etc. will fail to parse)
+        // In summary, it appears to only allow: (i) numeric chars, (ii) a period, and/or (iii) a minus sign
+        //
+        // The Decimal::d128 implementation of FromStr calls into a C library, and that lib hasn't
+        // been reviewed (by me), but it is thought/hoped to follow similar parsing conventions,
+        // though there's no guarantee.  Nevertheless, the above notes *appear* to hold true for d128.
+        // fn sanitize_string_for_d128_parsing_basic(field: &str) -> String {
+
+        //     // First, remove commas.
+        //     let no_comma_string = field.replace(",", "");
+        //     let almost_done = no_comma_string.replace(" ", "");
+
+        //     // Next, if ASCII (better be), check for accounting formatting
+        //     if almost_done.is_ascii() {
+        //         if almost_done.as_bytes()[0] == "(".as_bytes()[0] {
+        //             let half_fixed = almost_done.replace("(", "-");
+        //             let negative_with_minus = half_fixed.replace(")", "");
+        //             return negative_with_minus
+        //         }
+        //     }
+        //     almost_done
+        // }
+
+        // fn sanitize_string_for_d128_parsing_full(field: &str) -> String {
+
+        //     let mut near_done = "".to_string();
+        //     // First, remove commas.
+        //     let no_comma_string = field.replace(",", "");
+        //     let almost_done = no_comma_string.replace(" ", "");
+
+        //     // Next, if ASCII (better be), check for accounting formating
+        //     if almost_done.is_ascii() {
+        //         if almost_done.as_bytes()[0] == "(".as_bytes()[0] {
+        //             let half_fixed = almost_done.replace("(", "-");
+        //             let negative_with_minus = half_fixed.replace(")", "");
+        //             near_done = negative_with_minus;
+        //         } else {
+        //             near_done = almost_done;
+        //         }
+        //     } else {
+        //         near_done = almost_done;
+        //     }
+
+        //     // Strip non-numeric and non-period characters
+        //     let all_done: String = near_done.chars()
+        //         .filter(|x|
+        //             x.is_numeric() |
+        //             (x == &(".".as_bytes()[0] as char)) |
+        //             (x == &("-".as_bytes()[0] as char)))
+        //             .collect();
+        //     all_done
+        // }
+
         if let Some(incoming_ar) = incoming_ar {
             let x = incoming_ar_num.unwrap();
             action_records.insert(x, incoming_ar);
@@ -233,9 +322,6 @@ fn import_transactions(
         let format_yy: String;
         let format_yyyy: String;
 
-        let iso_date_style = settings.input_file_uses_iso_date_style;
-        let separator = &settings.input_file_date_separator;
-
         if iso_date_style {
             format_yyyy = "%Y".to_owned() + separator + "%m" + separator + "%d";
             format_yy = "%y".to_owned() + separator + "%m" + separator + "%d";
@@ -247,8 +333,9 @@ fn import_transactions(
         let tx_date = NaiveDate::parse_from_str(this_tx_date, &format_yy)
             .unwrap_or_else(|_| NaiveDate::parse_from_str(this_tx_date, &format_yyyy)
             .expect("
-Failed to parse date in input file. Check date the separator character, which is expected to be a hyphen \
-    unless otherwise set via environment variable or .env file. See `.env.example.`\n")
+FATAL: Transaction date parsing failed. You must tell the program the format of the date in your CSV Input File. The date separator \
+is expected to be a hyphen. The dating format is expected to be \"American\" (%m-%d-%y), not ISO 8601 (%y-%m-%d). You may set different \
+date format options via command line flag, environment variable or .env file. Perhaps first run with `--help` or see `.env.example.`\n")
         );
 
         let transaction = Transaction {
@@ -264,7 +351,7 @@ Failed to parse date in input file. Check date the separator character, which is
     };
 
     if changed_action_records > 0 {
-        println!("  Changed actionrecord amounts: {}. Changed txn numbers: {:?}.", changed_action_records, changed_txn_num);
+        println!("  Changed actionrecord amounts due to rounding precision: {}. Changed txn numbers: {:?}.", changed_action_records, changed_txn_num);
     }
 
     Ok(())

crptls/src/decimal_utils.rs

@@ -1,26 +1,24 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use decimal::d128;
+use rust_decimal::Decimal;
 
-
-pub fn round_d128_generalized(to_round: &d128, places_past_decimal: d128) -> d128 {
-    let rounded: d128 = ((to_round * d128!(10).scaleb(places_past_decimal)).quantize(d128!(1e1))) / d128!(10).scaleb(places_past_decimal);
+pub fn round_d128_generalized(to_round: &Decimal, places_past_decimal: u32) -> Decimal {
+    let rounded: Decimal = to_round.round_dp(places_past_decimal);
     rounded//.reduce()
 }
 
-pub fn round_d128_1e2(to_round: &d128) -> d128 {
-    let rounded: d128 = ((to_round * d128!(10).scaleb(d128!(2))).quantize(d128!(1e1))) / d128!(10).scaleb(d128!(2));
+pub fn round_d128_1e2(to_round: &Decimal) -> Decimal {
+    let rounded: Decimal = to_round.round_dp(2);
     rounded//.reduce()
 }
 
-pub fn round_d128_1e8(to_round: &d128) -> d128 {
-    let rounded: d128 = ((to_round * d128!(10).scaleb(d128!(8))).quantize(d128!(1e1))) / d128!(10).scaleb(d128!(8));
+pub fn round_d128_1e8(to_round: &Decimal) -> Decimal {
+    let rounded: Decimal = to_round.round_dp(8);
     rounded//.reduce()
         //  Note: quantize() rounds the number to the right of decimal and keeps it, discarding the rest to the right (it appears). See test.
         //  In other words, it's off by one. If you raise 0.123456789 by 10e8, quantize to 1e1 (which is 10), it'll get 12345678.9, round off to 12345679, and end up .12345679
         //  If you quantize the same number to 1e2 (which is 100), it starts back toward the left, so it'll get 12345678.9, round off to 12345680
         //  If you quantize the same number to 1e3 (which is 1000), it starts back toward the left, so it'll get 12345678.9, round off to 12345700
         //  As you can see, the quantize is off by one.  Quantizing to 10 rounds off the nearest one.  Quantizing to 100 rounds off to nearest 10, etc.
-}
-
+}

crptls/src/import_cost_proceeds_etc.rs

@@ -1,18 +1,19 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use std::collections::{HashMap};
+use std::collections::HashMap;
 use std::error::Error;
 
-use decimal::d128;
+use chrono::NaiveDate;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 
-use crate::crptls_lib::transaction::{Transaction, TxType, ActionRecord, Polarity};
-use crate::crptls_lib::account::{Account, RawAccount};
-use crate::crptls_lib::decimal_utils::{round_d128_1e2};
-use crate::crptls_lib::core_functions::{ImportProcessParameters};
+use crate::transaction::{Transaction, TxType, ActionRecord, Polarity};
+use crate::account::{Account, RawAccount};
+use crate::decimal_utils::round_d128_1e2;
 
 pub(crate) fn add_cost_basis_to_movements(
-    settings: &ImportProcessParameters,
+    home_currency: &String,
     raw_acct_map: &HashMap<u16, RawAccount>,
     acct_map: &HashMap<u16, Account>,
     ars: &HashMap<u32, ActionRecord>,
@@ -37,7 +38,7 @@ pub(crate) fn add_cost_basis_to_movements(
 
                 let polarity = ar.direction();
                 let tx_type = txn.transaction_type(ars, raw_acct_map, acct_map)?;
-                let is_home_curr = raw_acct.is_home_currency(&settings.home_currency);
+                let is_home_curr = raw_acct.is_home_currency(home_currency);
                 let mvmt_copy = mvmt.clone();
                 let borrowed_mvmt = mvmt_copy.clone();
                 // println!("Txn: {} on {} of type: {:?}",
@@ -66,8 +67,8 @@ pub(crate) fn add_cost_basis_to_movements(
                                 mvmt.cost_basis.set(rounded_basis);
                                 mvmt.cost_basis_lk.set(rounded_basis);
                             }
-                            assert!(mvmt.cost_basis.get() <= d128!(0));
-                            // assert!(mvmt.cost_basis_lk.get() <= d128!(0));   //  Same as above assert.
+                            assert!(mvmt.cost_basis.get() <= dec!(0));
+                            // assert!(mvmt.cost_basis_lk.get() <= dec!(0));   //  Same as above assert.
                             continue
                         }
 
@@ -90,7 +91,7 @@ pub(crate) fn add_cost_basis_to_movements(
                                         let other_acct = acct_map.get(&other_ar.account_key).unwrap();
                                         let raw_other_acct = raw_acct_map.get(&other_acct.raw_key).unwrap();
                                         assert_eq!(other_ar.direction(), Polarity::Outgoing);
-                                        let other_ar_is_home_curr = raw_other_acct.is_home_currency(&settings.home_currency);
+                                        let other_ar_is_home_curr = raw_other_acct.is_home_currency(home_currency);
 
                                         if other_ar_is_home_curr {
                                             mvmt.cost_basis.set(-(other_ar.amount));
@@ -102,7 +103,7 @@ pub(crate) fn add_cost_basis_to_movements(
                                                 borrowed_mvmt.ratio_of_amt_to_incoming_mvmts_in_a_r;
                                             let txn_proceeds = txn.proceeds
                                                 .to_string()
-                                                .parse::<d128>()
+                                                .parse::<Decimal>()
                                                 .unwrap();
                                             let unrounded_basis = txn_proceeds * ratio_of_amt_to_incoming_mvmts_in_a_r;
                                             let rounded_basis = round_d128_1e2(&unrounded_basis);
@@ -133,7 +134,7 @@ pub(crate) fn add_cost_basis_to_movements(
 
                                     TxType::Flow => {
 
-                                        let txn_proceeds = txn.proceeds.to_string().parse::<d128>().unwrap();
+                                        let txn_proceeds = txn.proceeds.to_string().parse::<Decimal>().unwrap();
                                         let mvmt_proceeds = round_d128_1e2(
                                             &(txn_proceeds *
                                             borrowed_mvmt.ratio_of_amt_to_incoming_mvmts_in_a_r)
@@ -144,8 +145,8 @@ pub(crate) fn add_cost_basis_to_movements(
                                     }
                                 }
                             }
-                            assert!(mvmt.cost_basis.get() >= d128!(0));
-                            // assert!(mvmt.cost_basis_lk.get() >= d128!(0));   //  Same as above assert.
+                            assert!(mvmt.cost_basis.get() >= dec!(0));
+                            // assert!(mvmt.cost_basis_lk.get() >= dec!(0));   //  Same as above assert.
                             continue
                         }
                     }
@@ -162,7 +163,7 @@ pub(crate) fn add_cost_basis_to_movements(
         ars: &HashMap<u32, ActionRecord>,
         txns_map: &HashMap<u32, Transaction>,
         acct_map: &HashMap<u16, Account>,
-    ) -> Vec<d128> {
+    ) -> Vec<Decimal> {
 
         let txn = txns_map.get(&txn_num).unwrap();
         let other_ar_borrowed = &ars.get(&txn.action_record_idx_vec[0]).unwrap();
@@ -177,7 +178,7 @@ pub(crate) fn add_cost_basis_to_movements(
         }
 
         vec
-    };
+    }
 
     Ok(())
 }
@@ -227,7 +228,7 @@ pub(crate) fn add_proceeds_to_movements(
                                     }
 
                                     let ratio = borrowed_mvmt.amount / ar.amount;
-                                    let proceeds_unrounded = txn.proceeds.to_string().parse::<d128>().unwrap() * ratio;
+                                    let proceeds_unrounded = txn.proceeds.to_string().parse::<Decimal>().unwrap() * ratio;
                                     let proceeds_rounded = round_d128_1e2(&proceeds_unrounded);
 
                                     mvmt.proceeds.set(proceeds_rounded);
@@ -265,7 +266,8 @@ pub(crate) fn add_proceeds_to_movements(
 }
 
 pub(crate) fn apply_like_kind_treatment(
-    settings: &ImportProcessParameters,
+    home_currency: &String,
+    cutoff_date: NaiveDate,
     raw_acct_map: &HashMap<u16, RawAccount>,
     acct_map: &HashMap<u16, Account>,
     ars: &HashMap<u32, ActionRecord>,
@@ -273,16 +275,16 @@ pub(crate) fn apply_like_kind_treatment(
 ) -> Result<(), Box<dyn Error>> {
 
     let length = txns_map.len();
-    let cutoff_date = settings.lk_cutoff_date;
+
     for txn_num in 1..=length {
 
         let txn_num = txn_num as u32;
         let txn = txns_map.get(&(txn_num)).unwrap();
 
-        update_current_txn_for_prior_likekind_treatment(txn_num, &settings, &raw_acct_map, &acct_map, &ars, &txns_map)?;
+        update_current_txn_for_prior_likekind_treatment(txn_num, home_currency, &raw_acct_map, &acct_map, &ars, &txns_map)?;
 
         if txn.date <= cutoff_date {
-            perform_likekind_treatment_on_txn(txn_num, &settings, &raw_acct_map, &acct_map, &ars, &txns_map)?;
+            perform_likekind_treatment_on_txn(txn_num, home_currency, &raw_acct_map, &acct_map, &ars, &txns_map)?;
         }
     }
 
@@ -291,14 +293,14 @@ pub(crate) fn apply_like_kind_treatment(
 
 fn update_current_txn_for_prior_likekind_treatment(
     txn_num: u32,
-    settings: &ImportProcessParameters,
+    home_currency: &String,
     raw_acct_map: &HashMap<u16, RawAccount>,
     acct_map: &HashMap<u16, Account>,
     ars: &HashMap<u32, ActionRecord>,
     txns_map: &HashMap<u32, Transaction>,
 ) -> Result<(), Box<dyn Error>> {
 
-    let mut sum_of_outgoing_lk_cost_basis_in_ar = d128!(0);
+    let mut sum_of_outgoing_lk_cost_basis_in_ar = dec!(0);
     let txn = txns_map.get(&txn_num).unwrap();
 
     for ar_num in txn.action_record_idx_vec.iter() {
@@ -312,7 +314,7 @@ fn update_current_txn_for_prior_likekind_treatment(
 
             let polarity = ar.direction();
             let tx_type = txn.transaction_type(ars, raw_acct_map, acct_map)?;
-            let is_home_curr = raw_acct.is_home_currency(&settings.home_currency);
+            let is_home_curr = raw_acct.is_home_currency(home_currency);
 
             let mvmt_copy = mvmt.clone();
             let borrowed_mvmt = mvmt_copy.clone();
@@ -350,8 +352,8 @@ fn update_current_txn_for_prior_likekind_treatment(
                             }
                             TxType::Flow => {
                                 if txn.action_record_idx_vec.len() == 2 {
-                                    mvmt.cost_basis_lk.set(d128!(0));
-                                    mvmt.proceeds_lk.set(d128!(0));
+                                    mvmt.cost_basis_lk.set(dec!(0));
+                                    mvmt.proceeds_lk.set(dec!(0));
                                 }
                                 // Do nothing for non-margin txns.
                             }
@@ -381,7 +383,7 @@ fn update_current_txn_for_prior_likekind_treatment(
 
 fn perform_likekind_treatment_on_txn(
     txn_num: u32,
-    settings: &ImportProcessParameters,
+    home_currency: &String,
     raw_acct_map: &HashMap<u16, RawAccount>,
     acct_map: &HashMap<u16, Account>,
     ars: &HashMap<u32, ActionRecord>,
@@ -390,7 +392,6 @@ fn perform_likekind_treatment_on_txn(
 
     let txn = txns_map.get(&txn_num).unwrap();
     let tx_type = txn.transaction_type(ars, raw_acct_map, acct_map)?;
-    let home_currency = &settings.home_currency;
 
     match tx_type {
 
@@ -398,7 +399,7 @@ fn perform_likekind_treatment_on_txn(
 
             if txn.both_exch_ars_are_non_home_curr(ars, raw_acct_map, acct_map, home_currency)? {
 
-                let mut sum_of_outgoing_lk_cost_basis_in_ar = d128!(0);
+                let mut sum_of_outgoing_lk_cost_basis_in_ar = dec!(0);
 
                 for ar_num in txn.action_record_idx_vec.iter() {
 
@@ -464,8 +465,8 @@ fn perform_likekind_treatment_on_txn(
 
                             Polarity::Incoming => {
                                 //  Reminder: May need extra logic here if margin exchange trades get cost_basis and proceeds
-                                mvmt.cost_basis.set(d128!(0));
-                                mvmt.proceeds.set(d128!(0));
+                                mvmt.cost_basis.set(dec!(0));
+                                mvmt.proceeds.set(dec!(0));
                             }
                         }
                     }

crptls/src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 #![allow(dead_code)]
@@ -8,10 +8,10 @@
 pub mod account;
 pub mod transaction;
 pub mod core_functions;
-pub mod string_utils;
-pub mod decimal_utils;
 pub mod costing_method;
+pub mod csv_import_accts_txns;
+pub mod create_lots_mvmts;
 
-mod csv_import_accts_txns;
-mod create_lots_mvmts;
-mod import_cost_proceeds_etc;
+mod decimal_utils;
+mod import_cost_proceeds_etc;
+mod tests;

crptls/src/tests/mod.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 pub mod test;

crptls/src/tests/test.rs

@@ -1,14 +1,15 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::fs;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 
-use decimal::d128;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 
-use crptls::account::{Account};
-use crptls::transaction::{Transaction, ActionRecord};
-use crptls::decimal_utils::*;
+use crate::account::Account;
+use crate::transaction::{Transaction, ActionRecord};
+use crate::decimal_utils::*;
 
 pub fn _run_tests(
     transactions_map: &HashMap<u32, Transaction>,
@@ -30,8 +31,8 @@ pub fn _run_tests(
         &account_map
     );
 
-    _test_quantize_from_incoming_multiple_lots_fn(d128!(20), d128!(200), d128!(50));
-    _test_quantize_from_incoming_multiple_lots_fn(d128!(1), d128!(6), d128!(1234567.1234567896));
+    _test_quantize_from_incoming_multiple_lots_fn(dec!(20), dec!(200), dec!(50));
+    _test_quantize_from_incoming_multiple_lots_fn(dec!(1), dec!(6), dec!(1234567.1234567896));
     // test_dec_rounded("123456789.123456789");
     // test_dec_rounded("123456.123456");
     // test_dec_rounded("1234567891234.1234567891234");
@@ -68,7 +69,7 @@ fn _compare_movements_across_implementations(
                 + &ar.amount.to_string() + &"\n".to_string()
             );
             let mvmts = ar.get_mvmts_in_ar_in_lot_date_order(&account_map, &transactions_map);
-            let mut amts = d128!(0);
+            let mut amts = dec!(0);
             for mvmt in mvmts {
                 amts += mvmt.amount;
                 line += &("Movement ".to_string() +
@@ -78,7 +79,7 @@ fn _compare_movements_across_implementations(
                                     &"\n".to_string());
             }
             line += &("Amount total: ".to_string() + &amts.to_string() + &"\n".to_string());
-            if amts - ar.amount != d128!(0) {
+            if amts - ar.amount != dec!(0) {
                 line += &("&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&".to_string());
                 println!("Movement amounts via get_mvmts_in_ar() different from actionRecord.amount.  Aborting.");
                 use std::process::exit; exit(1)
@@ -104,7 +105,7 @@ fn _compare_movements_across_implementations(
                 + &"\n".to_string()
             );
             // let mvmts = ar.get_mvmts_in_ar(&account_map);
-            let mut amts = d128!(0);
+            let mut amts = dec!(0);
             for mvmt in ar.movements.borrow().iter() {
                 amts += mvmt.amount;
                 line2 += &("Movement ".to_string() +
@@ -114,7 +115,7 @@ fn _compare_movements_across_implementations(
                                     &"\n".to_string());
             }
             line2 += &("Amount total: ".to_string() + &amts.to_string() + &"\n".to_string());
-            if amts - ar.amount != d128!(0) {
+            if amts - ar.amount != dec!(0) {
                 line2 += &("&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&".to_string());
                 println!("Movement amounts via ar.movements different from actionRecord.amount.  Aborting.");
                 use std::process::exit; exit(1)
@@ -144,9 +145,9 @@ pub fn _test_action_records_amts_vs_mvmt_amts(
     account_map: &HashMap<u16, Account>,
 ) {
 
-    let mut mvmt_amt_acct_lot: d128 = d128!(0);
-    let mut mvmt_amt_ar: d128 = d128!(0);
-    let mut ar_amts: d128 = d128!(0);
+    let mut mvmt_amt_acct_lot: Decimal = dec!(0);
+    let mut mvmt_amt_ar: Decimal = dec!(0);
+    let mut ar_amts: Decimal = dec!(0);
 
     for tx_num in 1..=transactions_map.len() {
 
@@ -195,18 +196,18 @@ pub fn _test_action_records_amts_vs_mvmt_amts(
 }
 
 fn _test_quantize_from_incoming_multiple_lots_fn (
-    outgoing_mvmt_amt: d128,
-    outgoing_ar_amt: d128,
-    incoming_ar_amt: d128,
+    outgoing_mvmt_amt: Decimal,
+    outgoing_ar_amt: Decimal,
+    incoming_ar_amt: Decimal,
 ) {
-    let rounded_example = d128::from(1).scaleb(d128::from(-8));
+    let rounded_example = Decimal::new(1,8);
     //
     println!("Og mvmt amt: {:?}, Og ar amt: {:?}, Ic ar amt: {:?}", outgoing_mvmt_amt, outgoing_ar_amt, incoming_ar_amt);
     let ratio_of_outgoing_to_total_ar = outgoing_mvmt_amt / outgoing_ar_amt; //  Negative divided by negative is positive
     println!("ratio_of_outgoing: {:.20}", ratio_of_outgoing_to_total_ar);
     let tentative_incoming_amt = ratio_of_outgoing_to_total_ar * incoming_ar_amt;
     println!("tentative_inc_amt: {:.20}", tentative_incoming_amt);
-    let corresponding_incoming_amt = tentative_incoming_amt.quantize(rounded_example);
+    let corresponding_incoming_amt = tentative_incoming_amt.round_dp(8);
     println!("corresponding_inc_amt: {}", corresponding_incoming_amt);
 }
 
@@ -221,23 +222,23 @@ fn _test_quantize_from_incoming_multiple_lots_fn (
 //     corresponding_inc_amt: 205761.18724280
 
 fn _test_dec_rounded(random_float_string: &str) {
-    let places_past_decimal = d128!(8);
-    let amt = random_float_string.parse::<d128>().unwrap();
+    let places_past_decimal = 8;
+    let amt = random_float_string.parse::<Decimal>().unwrap();
     let amt2 = round_d128_generalized(&amt, places_past_decimal);
-    println!("Float into d128: {:?}; d128 rounded to {}: {:?}", amt, places_past_decimal, amt2);
-    //  Results of this test suggest that quantize() is off by one.  round_d128_1e8() was adjusted accordingly.
+    println!("Float into dec: {:?}; dec rounded to {}: {:?}", amt, places_past_decimal, amt2);
+    //  Results of this test suggest that quantize() is off by one.  round_dec_1e8() was adjusted accordingly.
 }
 
 fn _test_dec_rounded_1e8(random_float_string: &str) {
-    let amt = random_float_string.parse::<d128>().unwrap();
+    let amt = random_float_string.parse::<Decimal>().unwrap();
     let amt2 = round_d128_1e8(&amt);
-    println!("Float into d128: {:?}; d128 rounded to 8 places: {:?}", amt, amt2);
-    //  Results of this test suggest that quantize() is off by one.  round_d128_1e8() was adjusted accordingly.
+    println!("Float into dec: {:?}; dec rounded to 8 places: {:?}", amt, amt2);
+    //  Results of this test suggest that quantize() is off by one.  round_dec_1e8() was adjusted accordingly.
 }
 
 fn _test_dec_rounded_1e2(random_float_string: &str) {
-    let amt = random_float_string.parse::<d128>().unwrap();
+    let amt = random_float_string.parse::<Decimal>().unwrap();
     let amt2 = round_d128_1e2(&amt);
-    println!("String into d128: {:?}; d128 rounded to 2 places: {:?}", amt, amt2);
-    //  Results of this test suggest that quantize() is off by one.  round_d128_1e8() was adjusted accordingly.
+    println!("String into dec: {:?}; dec rounded to 2 places: {:?}", amt, amt2);
+    //  Results of this test suggest that quantize() is off by one.  round_dec_1e8() was adjusted accordingly.
 }

crptls/src/transaction.rs

@@ -1,18 +1,19 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use std::rc::{Rc};
-use std::cell::{RefCell};
+use std::rc::Rc;
+use std::cell::RefCell;
 use std::process;
 use std::fmt;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 use std::error::Error;
 
-use decimal::d128;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 use chrono::NaiveDate;
 use serde_derive::{Serialize, Deserialize};
 
-use crate::crptls_lib::account::{Account, Movement, RawAccount};
+use crate::account::{Account, Movement, RawAccount};
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Transaction {
@@ -297,7 +298,7 @@ impl Transaction {
             let raw_acct = raw_accts.get(&acct.raw_key).unwrap();
             let ticker = &raw_acct.ticker;
 
-            if amt > d128!(0.0) {
+            if amt > dec!(0.0) {
 
                 format!("Received {} {} valued at {:.2} {}.", amt, ticker,
                 self.proceeds.to_string().as_str().parse::<f32>()?, home_currency)
@@ -317,7 +318,7 @@ impl Transaction {
 #[derive(Clone, Debug)]
 pub struct ActionRecord {
 	pub account_key: u16,
-	pub amount: d128,
+	pub amount: Decimal,
     pub tx_key: u32,
     pub self_ar_key: u32,
 	pub movements: RefCell<Vec<Rc<Movement>>>,
@@ -326,13 +327,13 @@ pub struct ActionRecord {
 impl ActionRecord {
 
 	pub fn direction(&self) -> Polarity {
-		if self.amount < d128!(0.0) { Polarity::Outgoing}
+		if self.amount < dec!(0.0) { Polarity::Outgoing}
 		else { Polarity::Incoming }
     }
 
-    pub fn cost_basis_in_ar(&self) -> d128 {
+    pub fn cost_basis_in_ar(&self) -> Decimal {
 
-        let mut cb = d128!(0);
+        let mut cb = dec!(0);
 
         for mvmt in self.movements.borrow().iter() {
             cb += mvmt.cost_basis.get()
@@ -373,7 +374,7 @@ impl ActionRecord {
         let acct = acct_map.get(&self.account_key).unwrap();
 
         let target = self.amount;
-        let mut measure = d128!(0);
+        let mut measure = dec!(0);
 
         for lot in acct.list_of_lots.borrow().iter() {
 

examples/.env.example

@@ -1,6 +1,6 @@
 ## CONFIGURATION
 ##
-## If the defaults below are not suitable, copy this .env.example into a new .env file,
+## The defaults are shown below.  If the defaults are not suitable, copy this .env.example into a new .env file,
 ## uncomment the respective enviroment variable, and set the value according to your needs.
 ## Alternatively, command line flags are available for ISO_DATE and DATE_SEPARATOR_SWITCH.
 ## Command line flags will override enviroment variables.
@@ -26,6 +26,7 @@
 # (Optional; default is not set)
 #LK_CUTOFF_DATE=YYYY-mm-DD
 
+# These are the options available for choosing in which order lots are chosen for disposals.
 #1. LIFO according to the order the lot was created.
 #2. LIFO according to the basis date of the lot.
 #3. FIFO according to the order the lot was created.

src/cli_user_choices.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::error::Error;
@@ -9,14 +9,13 @@ use std::fs::File;
 
 use chrono::NaiveDate;
 use rustyline::completion::{Completer, FilenameCompleter, Pair};
+use rustyline::validate::Validator;
 use rustyline::{CompletionType, Config, Context, EditMode, Editor, Helper};
-use rustyline::config::OutputStreamType;
-use rustyline::hint::{Hinter};
+use rustyline::hint::{Hinter, Hint};
 use rustyline::error::ReadlineError;
-use rustyline::highlight::{Highlighter};
+use rustyline::highlight::Highlighter;
 
 use crptls::costing_method::InventoryCostingMethod;
-use crptls::string_utils;
 
 
 pub fn choose_file_for_import(flag_to_accept_cli_args: bool) -> Result<PathBuf, Box<dyn Error>> {
@@ -73,9 +72,16 @@ fn _get_path() -> Result<(String, bool), Box<dyn Error>> {
         }
     }
 
-    impl Hinter for MyHelper {}
+    impl Hint for MyHelper {
+        fn display(&self) -> &str { todo!() }
+        fn completion(&self) -> Option<&str> { todo!() }
+    }
+    impl Hinter for MyHelper {
+        type Hint = MyHelper;
+    }
     impl Highlighter for MyHelper {}
     impl Helper for MyHelper {}
+    impl Validator for MyHelper {}
 
     let h = MyHelper {
         completer: FilenameCompleter::new(),
@@ -86,11 +92,10 @@ fn _get_path() -> Result<(String, bool), Box<dyn Error>> {
         .history_ignore_space(true)
         .completion_type(CompletionType::Circular)
         .edit_mode(EditMode::Vi)
-        .output_stream(OutputStreamType::Stdout)
         .build();
 
     let count = 1;
-    let mut rl = Editor::with_config(config);
+    let mut rl = Editor::with_config(config)?;
     let p = format!("{}> ", count);
     rl.set_helper(Some(h));
     rl.helper_mut().unwrap().colored_prompt = format!("\x1b[1;32m{}\x1b[0m", p);
@@ -256,7 +261,7 @@ pub(crate) fn elect_like_kind_treatment(cutoff_date_arg: &mut Option<String>) ->
         let mut input = String::new();
         let stdin = io::stdin();
         stdin.lock().read_line(&mut input)?;
-        string_utils::trim_newline(&mut input);
+        trim_newline(&mut input);
 
         let successfully_parsed_naive_date = test_naive_date_from_user_string(&mut input)?;
 
@@ -281,7 +286,7 @@ pub(crate) fn elect_like_kind_treatment(cutoff_date_arg: &mut Option<String>) ->
         let mut input2 = String::new();
         let stdin = io::stdin();
         stdin.lock().read_line(&mut input2)?;
-        string_utils::trim_newline(&mut input2);
+        trim_newline(&mut input2);
         *input = input2;
 
         let successfully_parsed_naive_date = NaiveDate::parse_from_str(&input, "%y-%m-%d")
@@ -291,3 +296,12 @@ pub(crate) fn elect_like_kind_treatment(cutoff_date_arg: &mut Option<String>) ->
         Ok(successfully_parsed_naive_date)
     }
 }
+
+fn trim_newline(s: &mut String) {
+    if s.ends_with('\n') {
+        s.pop();
+        if s.ends_with('\r') {
+            s.pop();
+        }
+    }
+}

src/crptls_lib/string_utils.rs

@@ -1,11 +0,0 @@
-// Copyright (c) 2017-2019, scoobybejesus
-// Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
-
-pub fn trim_newline(s: &mut String) {
-    if s.ends_with('\n') {
-        s.pop();
-        if s.ends_with('\r') {
-            s.pop();
-        }
-    }
-}

src/export/export_all.rs

@@ -1,15 +1,13 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::error::Error;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 
 use crptls::transaction::{Transaction, ActionRecord};
 use crptls::account::{Account, RawAccount};
-use crptls::core_functions::{ImportProcessParameters};
-use crate::export_csv;
-use crate::export_txt;
-use crate::export_je;
+use crptls::core_functions::ImportProcessParameters;
+use crate::export::{export_csv, export_txt, export_je};
 
 
 pub fn export(

src/export/export_csv.rs

@@ -1,17 +1,17 @@
-// Copyright (c) 2017-2019, scoobybejesus;
+// Copyright (c) 2017-2023, scoobybejesus;
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::fs::File;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::error::Error;
 
-use decimal::d128;
+use rust_decimal_macros::dec;
 use chrono::NaiveDate;
 
 use crptls::transaction::{ActionRecord, Polarity, Transaction, TxType};
 use crptls::account::{Account, RawAccount, Term};
-use crptls::core_functions::{ImportProcessParameters};
+use crptls::core_functions::ImportProcessParameters;
 
 
 pub fn _1_account_sums_to_csv(
@@ -47,7 +47,7 @@ pub fn _1_account_sums_to_csv(
         let balance: String;
         let tentative_balance = acct.get_sum_of_amts_in_lots();
 
-        if tentative_balance == d128!(0) {
+        if tentative_balance == dec!(0) {
             balance = "0.00".to_string()
         } else { balance = tentative_balance.to_string() }
 
@@ -56,7 +56,7 @@ pub fn _1_account_sums_to_csv(
 
         if raw_acct.is_margin { lk_cost_basis = "0.00".to_string() } else {
             let tentative_lk_cost_basis = acct.get_sum_of_lk_basis_in_lots();
-            if tentative_lk_cost_basis == d128!(0) {
+            if tentative_lk_cost_basis == dec!(0) {
                 lk_cost_basis = "0.00".to_string()
             } else { lk_cost_basis = tentative_lk_cost_basis.to_string() }
         }
@@ -121,10 +121,10 @@ pub fn _2_account_sums_nonzero_to_csv(
         let name = raw_acct.name.to_string();
 
         let balance: String;
-        let mut balance_d128 = d128!(0);
+        let mut balance_d128 = dec!(0);
         let tentative_balance = acct.get_sum_of_amts_in_lots();
 
-        if tentative_balance == d128!(0) {
+        if tentative_balance == dec!(0) {
             balance = "0.00".to_string()
         } else { balance_d128 += tentative_balance; balance = tentative_balance.to_string() }
 
@@ -132,7 +132,7 @@ pub fn _2_account_sums_nonzero_to_csv(
 
         if raw_acct.is_margin { lk_cost_basis = "0.00".to_string() } else {
             let tentative_lk_cost_basis = acct.get_sum_of_lk_basis_in_lots();
-            if tentative_lk_cost_basis == d128!(0) {
+            if tentative_lk_cost_basis == dec!(0) {
                 lk_cost_basis = "0.00".to_string()
             } else { lk_cost_basis = tentative_lk_cost_basis.to_string() }
         }
@@ -142,7 +142,7 @@ pub fn _2_account_sums_nonzero_to_csv(
 
         let nonzero_lots = acct.get_num_of_nonzero_lots();
 
-        if balance_d128 != d128!(0) {
+        if balance_d128 != dec!(0) {
             row.push(name);
             row.push(balance);
             row.push(raw_acct.ticker.to_string());
@@ -200,7 +200,7 @@ pub fn _3_account_sums_to_csv_with_orig_basis(
         let balance: String;
         let tentative_balance = acct.get_sum_of_amts_in_lots();
 
-        if tentative_balance == d128!(0) {
+        if tentative_balance == dec!(0) {
             balance = "0.00".to_string()
         } else { balance = tentative_balance.to_string() }
 
@@ -217,11 +217,11 @@ pub fn _3_account_sums_to_csv_with_orig_basis(
             let tentative_lk_cost_basis = acct.get_sum_of_lk_basis_in_lots();
             let tentative_orig_cost_basis = acct.get_sum_of_orig_basis_in_lots();
 
-            if tentative_lk_cost_basis == d128!(0) {
+            if tentative_lk_cost_basis == dec!(0) {
                 lk_cost_basis = "0.00".to_string()
             } else { lk_cost_basis = tentative_lk_cost_basis.to_string() }
 
-            if tentative_orig_cost_basis == d128!(0) {
+            if tentative_orig_cost_basis == dec!(0) {
                 orig_cost_basis = "0.00".to_string()
             } else { orig_cost_basis = tentative_orig_cost_basis.to_string() }
         }
@@ -312,7 +312,7 @@ pub fn _4_transaction_mvmt_detail_to_csv(
             let tx_type = txn.transaction_type(&ars, &raw_acct_map, &acct_map)?;
             let tx_type_string = mvmt.friendly_tx_type(&tx_type);
             let memo = txn.user_memo.to_string();
-            let mut amount = d128!(0);
+            let mut amount = dec!(0);
             amount += mvmt.amount;   //  To prevent printing -5E+1 instead of 50, for example
             let ticker = raw_acct.ticker.to_string();
             let term = mvmt.get_term(acct_map, ars, txns_map).to_string();
@@ -323,10 +323,10 @@ pub fn _4_transaction_mvmt_detail_to_csv(
             let expense = mvmt.get_expense(ars, &raw_acct_map, &acct_map, &txns_map)?;
 
 
-            if tx_type == TxType::Flow && amount > d128!(0) {
-                proceeds_lk = d128!(0);
-                cost_basis_lk = d128!(0);
-                gain_loss = d128!(0);
+            if tx_type == TxType::Flow && amount > dec!(0) {
+                proceeds_lk = dec!(0);
+                cost_basis_lk = dec!(0);
+                gain_loss = dec!(0);
             }
 
             let mut row: Vec<String> = Vec::with_capacity(total_columns);
@@ -410,19 +410,19 @@ pub fn _5_transaction_mvmt_summaries_to_csv(
         let mut ticker: Option<String> = None;
         let mut polarity: Option<Polarity> = None;
 
-        let mut amount_st = d128!(0);
-        let mut proceeds_st = d128!(0);
-        let mut cost_basis_st = d128!(0);
+        let mut amount_st = dec!(0);
+        let mut proceeds_st = dec!(0);
+        let mut cost_basis_st = dec!(0);
 
-        let mut income_st = d128!(0);
-        let mut expense_st = d128!(0);
+        let mut income_st = dec!(0);
+        let mut expense_st = dec!(0);
 
-        let mut amount_lt = d128!(0);
-        let mut proceeds_lt = d128!(0);
-        let mut cost_basis_lt = d128!(0);
+        let mut amount_lt = dec!(0);
+        let mut proceeds_lt = dec!(0);
+        let mut cost_basis_lt = dec!(0);
 
-        let mut income_lt = d128!(0);
-        let mut expense_lt = d128!(0);
+        let mut income_lt = dec!(0);
+        let mut expense_lt = dec!(0);
 
         let flow_or_outgoing_exchange_movements = txn.get_outgoing_exchange_and_flow_mvmts(
             &settings.home_currency,
@@ -444,7 +444,7 @@ pub fn _5_transaction_mvmt_summaries_to_csv(
             if ticker.is_none() { ticker = Some(raw_acct.ticker.clone()) };
 
             if polarity.is_none() {
-                polarity = if mvmt.amount > d128!(0) {
+                polarity = if mvmt.amount > dec!(0) {
                     Some(Polarity::Incoming)
                     } else { Some(Polarity::Outgoing)
                 };
@@ -474,11 +474,11 @@ pub fn _5_transaction_mvmt_summaries_to_csv(
             &acct_map)? == TxType::Flow
         ) & (polarity == Some(Polarity::Incoming)) {
             income_st = -proceeds_st;   //  Proceeds are negative for incoming txns
-            proceeds_st = d128!(0);
-            cost_basis_st = d128!(0);
+            proceeds_st = dec!(0);
+            cost_basis_st = dec!(0);
             income_lt = -proceeds_lt;   //  Proceeds are negative for incoming txns
-            proceeds_lt = d128!(0);
-            cost_basis_lt = d128!(0);
+            proceeds_lt = dec!(0);
+            cost_basis_lt = dec!(0);
         }
 
         if (txn.transaction_type(
@@ -620,7 +620,7 @@ pub fn _6_transaction_mvmt_detail_to_csv_w_orig(
             let tx_type_string = mvmt.friendly_tx_type(&tx_type);
             let user_memo = txn.user_memo.to_string();
             let auto_memo = txn.get_auto_memo(ars, raw_acct_map,acct_map, &settings.home_currency)?;
-            let mut amount = d128!(0);
+            let mut amount = dec!(0);
             amount += mvmt.amount;   //  To prevent printing -5E+1 instead of 50, for example
             let ticker = raw_acct.ticker.to_string();
             let term = mvmt.get_term(acct_map, ars, txns_map).to_string();
@@ -633,13 +633,13 @@ pub fn _6_transaction_mvmt_detail_to_csv_w_orig(
             let mut orig_cost = mvmt.cost_basis.get();
             let mut orig_gain_loss = mvmt.get_orig_gain_or_loss();
 
-            if tx_type == TxType::Flow && amount > d128!(0) {
-                proceeds_lk = d128!(0);
-                cost_basis_lk = d128!(0);
-                gain_loss = d128!(0);
-                orig_proc = d128!(0);
-                orig_cost = d128!(0);
-                orig_gain_loss = d128!(0);
+            if tx_type == TxType::Flow && amount > dec!(0) {
+                proceeds_lk = dec!(0);
+                cost_basis_lk = dec!(0);
+                gain_loss = dec!(0);
+                orig_proc = dec!(0);
+                orig_cost = dec!(0);
+                orig_gain_loss = dec!(0);
             }
 
             let mut row: Vec<String> = Vec::with_capacity(total_columns);
@@ -723,17 +723,17 @@ pub fn _7_gain_loss_8949_to_csv(
         let mut ticker: Option<String> = None;
         let mut polarity: Option<Polarity> = None;
 
-        let mut amount_st = d128!(0);
-        let mut proceeds_st = d128!(0);
-        let mut cost_basis_st = d128!(0);
+        let mut amount_st = dec!(0);
+        let mut proceeds_st = dec!(0);
+        let mut cost_basis_st = dec!(0);
 
-        let mut expense_st = d128!(0);
+        let mut expense_st = dec!(0);
 
-        let mut amount_lt = d128!(0);
-        let mut proceeds_lt = d128!(0);
-        let mut cost_basis_lt = d128!(0);
+        let mut amount_lt = dec!(0);
+        let mut proceeds_lt = dec!(0);
+        let mut cost_basis_lt = dec!(0);
 
-        let mut expense_lt = d128!(0);
+        let mut expense_lt = dec!(0);
 
         let flow_or_outgoing_exchange_movements = txn.get_outgoing_exchange_and_flow_mvmts(
             &settings.home_currency,
@@ -757,7 +757,7 @@ pub fn _7_gain_loss_8949_to_csv(
             if ticker.is_none() { ticker = Some(raw_acct.ticker.clone()) };
 
             if polarity.is_none() {
-                polarity = if mvmt.amount > d128!(0) {
+                polarity = if mvmt.amount > dec!(0) {
                     Some(Polarity::Incoming)
                     } else { Some(Polarity::Outgoing)
                 };
@@ -804,9 +804,9 @@ pub fn _7_gain_loss_8949_to_csv(
             // The only incoming flow transaction to report would be margin profit, which is a dual-`action record` `transaction`
             if txn.action_record_idx_vec.len() == 2 {
                 proceeds_st = -proceeds_st;   //  Proceeds are negative for incoming txns
-                cost_basis_st = d128!(0);
+                cost_basis_st = dec!(0);
                 proceeds_lt = -proceeds_lt;   //  Proceeds are negative for incoming txns
-                cost_basis_lt = d128!(0);
+                cost_basis_lt = dec!(0);
             } else {
                 continue    // Plain, old income isn't reported on form 8949
             }

src/export/export_je.rs

@@ -1,17 +1,18 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use std::fs::{OpenOptions};
-use std::collections::{HashMap};
+use std::fs::OpenOptions;
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::error::Error;
 use std::io::prelude::Write;
 
-use decimal::d128;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 
 use crptls::transaction::{Transaction, ActionRecord, Polarity, TxType};
 use crptls::account::{Account, RawAccount, Term};
-use crptls::core_functions::{ImportProcessParameters};
+use crptls::core_functions::ImportProcessParameters;
 
 
 pub fn prepare_non_lk_journal_entries(
@@ -65,8 +66,8 @@ depending on the bookkeeping practices you employ.";
 
         writeln!(file, "\n====================================================================================================\n")?;
 
-        let mut cost_basis_ic: Option<d128> = None;
-        let mut cost_basis_og: Option<d128> = None;
+        let mut cost_basis_ic: Option<Decimal> = None;
+        let mut cost_basis_og: Option<Decimal> = None;
 
         let mut acct_string_ic = "".to_string();
         let mut acct_string_og = "".to_string();
@@ -101,16 +102,16 @@ depending on the bookkeeping practices you employ.";
 
         let mut polarity: Option<Polarity> = None;
 
-        let mut amount_st = d128!(0);
-        let mut proceeds_st = d128!(0);
-        let mut cost_basis_st = d128!(0);
+        let mut amount_st = dec!(0);
+        let mut proceeds_st = dec!(0);
+        let mut cost_basis_st = dec!(0);
 
-        let mut amount_lt = d128!(0);
-        let mut proceeds_lt = d128!(0);
-        let mut cost_basis_lt = d128!(0);
+        let mut amount_lt = dec!(0);
+        let mut proceeds_lt = dec!(0);
+        let mut cost_basis_lt = dec!(0);
 
-        let mut income = d128!(0);
-        let mut expense = d128!(0);
+        let mut income = dec!(0);
+        let mut expense = dec!(0);
 
         let flow_or_outgoing_exchange_movements = txn.get_outgoing_exchange_and_flow_mvmts(
             &settings.home_currency,
@@ -123,7 +124,7 @@ depending on the bookkeeping practices you employ.";
         for mvmt in flow_or_outgoing_exchange_movements.iter() {
 
             if polarity.is_none() {
-                polarity = if mvmt.amount > d128!(0) {
+                polarity = if mvmt.amount > dec!(0) {
                     Some(Polarity::Incoming)
                     } else { Some(Polarity::Outgoing)
                 };
@@ -155,18 +156,18 @@ depending on the bookkeeping practices you employ.";
             &acct_map)? == TxType::Flow
         ) & (polarity == Some(Polarity::Incoming)) {
 
-            proceeds_st = d128!(0);
-            cost_basis_st = d128!(0);
+            proceeds_st = dec!(0);
+            cost_basis_st = dec!(0);
 
-            proceeds_lt = d128!(0);
-            cost_basis_lt = d128!(0);
+            proceeds_lt = dec!(0);
+            cost_basis_lt = dec!(0);
         }
 
         let lt_gain_loss = proceeds_lt + cost_basis_lt;
         let st_gain_loss = proceeds_st + cost_basis_st;
 
-        let mut debits = d128!(0);
-        let mut credits = d128!(0);
+        let mut debits = dec!(0);
+        let mut credits = dec!(0);
 
         if let Some(cb) = cost_basis_ic {
             debits += cb;
@@ -190,9 +191,9 @@ depending on the bookkeeping practices you employ.";
             )?;
         }
 
-        if lt_gain_loss != d128!(0) {
+        if lt_gain_loss != dec!(0) {
 
-            if lt_gain_loss > d128!(0) {
+            if lt_gain_loss > dec!(0) {
                 credits += lt_gain_loss.abs();
                 let ltg_string = format!("Long-term gain disposing {}", amount_lt.abs());
                 writeln!(file, "{:50}{:5}{:>20}{:5}{:>20.2}",
@@ -215,9 +216,9 @@ depending on the bookkeeping practices you employ.";
             }
         }
 
-        if st_gain_loss != d128!(0) {
+        if st_gain_loss != dec!(0) {
 
-            if st_gain_loss > d128!(0) {
+            if st_gain_loss > dec!(0) {
                 credits += st_gain_loss.abs();
                 let stg_string = format!("Short-term gain disposing {}", amount_st.abs());
                 writeln!(file, "{:50}{:5}{:>20}{:5}{:>20.2}",
@@ -240,7 +241,7 @@ depending on the bookkeeping practices you employ.";
             }
         }
 
-        if income != d128!(0) {
+        if income != dec!(0) {
             credits += income;
             writeln!(file, "{:50}{:5}{:>20}{:5}{:>20.2}",
             "Income",
@@ -251,7 +252,7 @@ depending on the bookkeeping practices you employ.";
             )?;
         }
 
-        if expense != d128!(0) {
+        if expense != dec!(0) {
             debits += expense.abs();
             writeln!(file, "{:50}{:5}{:>20.2}{:5}{:>20}",
             "Expense",
@@ -285,7 +286,7 @@ depending on the bookkeeping practices you employ.";
             auto_memo,
         )?;
 
-        // if (debits - credits) != d128!(0) {
+        // if (debits - credits) != dec!(0) {
         //     println!("Rounding issue on transaction #{}", txn_num);
         // }
 

src/export/export_txt.rs

@@ -1,17 +1,18 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use std::fs::{OpenOptions};
-use std::collections::{HashMap};
+use std::fs::OpenOptions;
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::error::Error;
 use std::io::prelude::Write;
 
-use decimal::d128;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
 
 use crptls::transaction::{Transaction, ActionRecord};
 use crptls::account::{Account, RawAccount};
-use crptls::core_functions::{ImportProcessParameters};
+use crptls::core_functions::ImportProcessParameters;
 
 
 pub fn _1_account_lot_detail_to_txt(
@@ -129,14 +130,14 @@ Enable like-kind treatment: {}",
             let lk_lot_basis = lot.get_sum_of_lk_basis_in_lot();
 
             let formatted_basis: String;
-            if lk_lot_basis == d128!(0) {
+            if lk_lot_basis == dec!(0) {
                 formatted_basis = "0.00".to_string()
             } else { formatted_basis = lk_lot_basis.to_string() }
 
             let movements_sum = lot.get_sum_of_amts_in_lot();
 
             let formatted_sum: String;
-            if movements_sum == d128!(0) {
+            if movements_sum == dec!(0) {
                 formatted_sum = "0.00".to_string()
             } else { formatted_sum = movements_sum.to_string() }
 
@@ -200,15 +201,15 @@ Enable like-kind treatment: {}",
 
                     let lk_proceeds = mvmt.proceeds_lk.get();
                     let lk_cost_basis = mvmt.cost_basis_lk.get();
-                    let gain_loss: d128;
+                    let gain_loss: Decimal;
 
-                    // if mvmt.amount > d128!(0) { // Can't have a gain on an incoming txn
-                    //     gain_loss = d128!(0)
+                    // if mvmt.amount > dec!(0) { // Can't have a gain on an incoming txn
+                    //     gain_loss = dec!(0)
                     // } else
                     if raw_acct.is_home_currency(home_currency) {  //  Can't have a gain disposing home currency
-                        gain_loss = d128!(0)
+                        gain_loss = dec!(0)
                     // } else if tx_type == TxType::ToSelf {   //  Can't have a gain sending to yourself
-                    //     gain_loss = d128!(0)
+                    //     gain_loss = dec!(0)
                     } else {
                         gain_loss = lk_proceeds + lk_cost_basis;
                     }
@@ -305,14 +306,14 @@ Enable like-kind treatment: {}",
             let lk_lot_basis = lot.get_sum_of_lk_basis_in_lot();
 
             let formatted_basis: String;
-            if lk_lot_basis == d128!(0) {
+            if lk_lot_basis == dec!(0) {
                 formatted_basis = "0.00".to_string()
             } else { formatted_basis = lk_lot_basis.to_string() }
 
             let movements_sum = lot.get_sum_of_amts_in_lot();
 
             let formatted_sum: String;
-            if movements_sum == d128!(0) {
+            if movements_sum == dec!(0) {
                 formatted_sum = "0.00".to_string()
             } else { formatted_sum = movements_sum.to_string() }
 
@@ -384,7 +385,7 @@ Enable like-kind treatment: {}",
         let amt_in_acct = acct.get_sum_of_amts_in_lots();
 
         if acct.list_of_lots.borrow().len() > 0 {
-            if amt_in_acct > d128!(0) {
+            if amt_in_acct > dec!(0) {
 
                 writeln!(file, "\n=====================================")?;
                 writeln!(file, "{} {}", raw_acct.name, raw_acct.ticker)?;
@@ -404,13 +405,13 @@ Enable like-kind treatment: {}",
             let lk_lot_basis = lot.get_sum_of_lk_basis_in_lot();
 
             let formatted_basis: String;
-            if lk_lot_basis == d128!(0) {
+            if lk_lot_basis == dec!(0) {
                 formatted_basis = "0.00".to_string()
             } else { formatted_basis = lk_lot_basis.to_string() }
 
             let movements_sum = lot.get_sum_of_amts_in_lot();
 
-            if acct.list_of_lots.borrow().len() > 0 && movements_sum > d128!(0) {
+            if acct.list_of_lots.borrow().len() > 0 && movements_sum > dec!(0) {
 
                 writeln!(file, "  Lot {:>3} created {} w/ basis date {} • Σ: {:>12}, and cost basis of {:>10.2}",
                     (lot_idx+1),

src/export/mod.rs

@@ -0,0 +1,7 @@
+// Copyright (c) 2017-2023, scoobybejesus
+// Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
+
+pub mod export_all;
+pub mod export_je;
+pub mod export_csv;
+pub mod export_txt;

src/lib.rs

@@ -1,11 +0,0 @@
-// Copyright (c) 2017-2019, scoobybejesus
-// Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
-
-pub use self::crptls_lib::account;
-pub use self::crptls_lib::transaction;
-pub use self::crptls_lib::core_functions;
-pub use self::crptls_lib::string_utils;
-pub use self::crptls_lib::decimal_utils;
-pub use self::crptls_lib::costing_method;
-
-pub mod crptls_lib;

src/main.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 // #![allow(dead_code)]
@@ -11,72 +11,73 @@
 use std::path::PathBuf;
 use std::error::Error;
 
-use structopt::StructOpt;
+use clap::Parser;
 
 mod setup;
 mod cli_user_choices;
 mod wizard;
 mod skip_wizard;
+mod export;
+
+#[cfg(feature = "print_menu")]
 mod mytui;
-mod export_csv;
-mod export_txt;
-mod export_je;
-mod export_all;
-mod tests;
+
+use export::{export_all, export_je};
 
 
-#[derive(StructOpt, Debug)]
-#[structopt(name = "cryptools")]
+#[derive(Parser, Debug)]
+#[command(name = "cryptools")]
 pub struct Cli {
 
     /// User is instructing the program to skip the data entry wizard.
     /// When set, default settings will be assumed if they are not set by 
     /// environment variables (or .env file) or certain command line flags.
-    #[structopt(name = "accept args", short = "a", long = "accept")]
+    #[arg(id = "accept args", short, long = "accept")]
     accept_args: bool,
 
     /// Suppresses the printing of "all" reports, except that it *will* trigger the
     /// exporting of a txt file containing an accounting journal entry for every transaction.
     /// Individual account and transaction reports may still be printed via the print_menu
     /// with the -p flag. Note: the journal entries are not suitable for like-kind transactions.
-    #[structopt(name = "journal entries", short, long = "journal-entries")]
+    #[arg(id = "journal entries", short, long = "journal-entries")]
     journal_entries_only: bool,
 
     /// Once the file_to_import has been fully processed, the user will be presented
     /// with a menu for manually selecting which reports to print/export. If this flag is not
     /// set, the program will print/export all available reports.
-    #[structopt(name = "print menu", short, long = "print-menu")]
+    #[cfg(feature = "print_menu")]
+    #[arg(id = "print menu", short, long = "print-menu")]
     print_menu: bool,
 
     /// Prevents the program from writing reports to files.
     /// This will be ignored if -a is not set (the wizard will always ask to output).
-    #[structopt(name = "suppress reports", short, long = "suppress")]
+    #[arg(id = "suppress reports", short, long = "suppress")]
     suppress_reports: bool,
 
     /// Output directory for exported reports.
-    #[structopt(name = "output directory", short, long = "output", default_value = ".", parse(from_os_str))]
+    #[arg(id = "output directory", short, long = "output", default_value = ".")]
     output_dir_path: PathBuf,
 
     /// Causes the program to expect the `txDate` field in the file_to_import to use the format YYYY-MM-dd
     /// or YY-MM-dd (or YYYY/MM/dd or YY/MM/dd) instead of the default US-style MM-dd-YYYY or MM-dd-YY 
     /// (or MM/dd/YYYY or MM/dd/YY).
     /// NOTE: this flag overrides the ISO_DATE environment variable, including if set in the .env file.
-    #[structopt(name = "imported file uses ISO 8601 date format", short = "i", long = "iso")]
+    #[arg(id = "imported file uses ISO 8601 date format", short, long = "iso")]
     iso_date: bool,
 
     /// Tells the program a non-default date separator (instead of a hyphen "-", a slash "/") was used
     /// in the file_to_import `txDate` column (i.e. 2017-12-31 instead of 2017/12/31).
     /// NOTE: this flag overrides the DATE_SEPARATOR_IS_SLASH environment variable, including if set in the .env file.
-    #[structopt(name = "date separator character is slash", short = "d", long = "date-separator-is-slash")]
+    #[arg(id = "date separator character is slash", short, long = "date-separator-is-slash")]
     date_separator_is_slash: bool,
 
     /// File to be imported.  Some notes on the columns: (a) by default, the program expects the `txDate` column to 
     /// be formatted as %m-%d-%y. You may alter this with ISO_DATE and DATE_SEPARATOR_IS_SLASH flags or environment
     /// variables; (b) the `proceeds` column and any values in transactions must have a period (".") as the decimal
-    /// separator; and (c) any transactions with negative values must not be wrapped in parentheses (use the python
-    /// script for sanitizing/converting negative values).
+    /// separator; and (c) there is now experimental support for negative values being wrapped in parentheses. Use
+    /// the python script for sanitizing/converting negative values if they are a problem.
     /// See .env.example for further details on environment variables.
-    #[structopt(name = "file_to_import", parse(from_os_str))]
+    #[arg(id = "file_to_import")]
     file_to_import: Option<PathBuf>,
 }
 
@@ -108,7 +109,7 @@ pub struct Cfg {
 
 fn main() -> Result<(), Box<dyn Error>> {
 
-    let args = Cli::from_args();
+    let args = Cli::parse();
 
     println!(
         "\
@@ -118,15 +119,14 @@ This software will import your csv file's ledger of cryptocurrency transactions.
 It will then process it by creating 'lots' and posting 'movements' to those lots.
 Along the way, it will keep track of income, expenses, gains, and losses.
 
-See .env.example for environment variables that may be set in a .env file in order to
-change default program behavior.
+See examples/.env.example or run with --help to learn how to change default program behavior.
 
   Note: The software is designed to import a full history. Gains and losses may be incorrect otherwise.
     ");
 
     let cfg = setup::get_env(&args)?;
 
-    let (input_file_path, settings) = setup::run_setup(args, cfg)?;
+    let (input_file_path, settings) = setup::run_setup(&args, cfg)?;
 
     let (
         raw_acct_map,
@@ -136,10 +136,14 @@ change default program behavior.
     ) = crptls::core_functions::import_and_process_final(input_file_path, &settings)?;
 
     let mut should_export_all = settings.should_export;
-    let present_print_menu_tui = settings.print_menu;
-    let print_journal_entries_only = settings.journal_entry_export;
 
+    #[cfg(feature = "print_menu")]
+    let present_print_menu_tui: bool = args.print_menu.to_owned();
+
+    #[cfg(feature = "print_menu")]
     if present_print_menu_tui { should_export_all = false }
+
+    let print_journal_entries_only = settings.journal_entry_export;
     if print_journal_entries_only { should_export_all = false }
 
     if should_export_all {
@@ -164,6 +168,7 @@ change default program behavior.
         )?;
     }
 
+    #[cfg(feature = "print_menu")]
     if present_print_menu_tui {
 
         mytui::print_menu_tui::print_menu_tui(

src/mytui/app.rs

@@ -1,17 +1,15 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::error::Error;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 
 use crptls::transaction::{Transaction, ActionRecord};
 use crptls::account::{Account, RawAccount};
-use crptls::core_functions::{ImportProcessParameters};
-
-use crate::export_csv;
-use crate::export_txt;
-use crate::export_je;
+use crptls::core_functions::ImportProcessParameters;
+use ratatui::widgets::ListState;
 
+use crate::export::{export_csv, export_je, export_txt};
 
 pub (crate) const REPORTS: [&'static str; 11] = [
     "1. CSV: Account Sums",
@@ -27,36 +25,51 @@ pub (crate) const REPORTS: [&'static str; 11] = [
     "11. TXT: Bookkeeping journal entries",
 ];
 
-pub struct ListState<I> {
+pub struct StatefulList<I> {
     pub items: Vec<I>,
-    pub selected: usize,
+    pub state: ListState,
 }
 
-impl<I> ListState<I> {
+impl<T> StatefulList<T> {
 
-    fn new(items: Vec<I>) -> ListState<I> {
-        ListState { items, selected: 0 }
+    fn new(items: Vec<T>) -> StatefulList<T> {
+        StatefulList { items, state: ListState::default() }
     }
 
     fn select_previous(&mut self) {
-
-        if self.selected > 0 {
-            self.selected -= 1;
-        }
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
     }
 
     fn select_next(&mut self) {
-
-        if self.selected < self.items.len() - 1 {
-            self.selected += 1
-        }
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
     }
+
 }
 
 pub struct PrintWindow<'a> {
     pub title: &'a str,
     pub should_quit: bool,
-    pub tasks: ListState<&'a str>,
+    pub tasks: StatefulList<&'a str>,
     pub to_print_by_idx: Vec<usize>,
     pub to_print_by_title: Vec<&'a str>,
 }
@@ -64,10 +77,13 @@ pub struct PrintWindow<'a> {
 impl<'a> PrintWindow<'a> {
 
     pub fn new(title: &'a str) -> PrintWindow<'a> {
+        let mut tasks = StatefulList::new(REPORTS.to_vec());
+        tasks.state.select(Some(0));
+
         PrintWindow {
             title,
             should_quit: false,
-            tasks: ListState::new(REPORTS.to_vec()),
+            tasks,
             to_print_by_idx: Vec::with_capacity(REPORTS.len()),
             to_print_by_title: Vec::with_capacity(REPORTS.len()),
         }
@@ -81,7 +97,7 @@ impl<'a> PrintWindow<'a> {
         self.tasks.select_next();
     }
 
-    pub fn on_key(&mut self, c: char) {
+    pub fn on_key(&mut self, c: char) -> Result<(), Box<dyn Error>> {
 
         match c {
 
@@ -93,7 +109,7 @@ impl<'a> PrintWindow<'a> {
                 self.should_quit = true;
             }
             'x' => {
-                let selected = self.tasks.selected;
+                let selected = self.tasks.state.selected().unwrap();
                 if self.to_print_by_idx.contains(&selected) {} else {
                     self.to_print_by_idx.push(selected);
                     self.to_print_by_title.push(self.tasks.items[selected])
@@ -102,7 +118,7 @@ impl<'a> PrintWindow<'a> {
                 self.tasks.select_next();
             }
             'd' => {
-                let selected_idx = self.tasks.selected;
+                let selected_idx = self.tasks.state.selected().unwrap();
                 self.to_print_by_idx.retain(|&x| x != selected_idx );
                 let selected_str = self.tasks.items[selected_idx];
                 self.to_print_by_title.retain(|&x| x != selected_str );
@@ -110,6 +126,7 @@ impl<'a> PrintWindow<'a> {
             }
             _ => {}
         }
+        Ok(())
     }
 
     fn change_vecs_to_chrono_order(vec: &mut Vec<usize>, strvec: &mut Vec<&str>) {
@@ -140,6 +157,11 @@ pub fn export(
 
     println!("Attempting to export:");
 
+    if app.to_print_by_idx.is_empty() {
+        println!("  None selected.");
+        return Ok(())
+    }
+
     for report_idx in app.to_print_by_idx.iter() {
 
         println!("    {}", reports[*report_idx]);

src/mytui/event.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 // TODO: cite source?

src/mytui/mod.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 pub mod print_menu_tui;

src/mytui/print_menu_tui.rs

@@ -1,21 +1,21 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::io;
 use std::time::Duration;
-use std::collections::{HashMap};
+use std::collections::HashMap;
 use std::error::Error;
 
-use tui::Terminal;
-use tui::backend::TermionBackend;
+use ratatui::Terminal;
+use ratatui::backend::TermionBackend;
 use termion::raw::IntoRawMode;
-use termion::screen::AlternateScreen;
+use termion::screen::IntoAlternateScreen;
 use termion::input::MouseTerminal;
 use termion::event::Key;
 
 use crptls::transaction::{Transaction, ActionRecord};
 use crptls::account::{Account, RawAccount};
-use crptls::core_functions::{ImportProcessParameters};
+use crptls::core_functions::ImportProcessParameters;
 
 use crate::mytui::event::{Events, Event, Config};
 use crate::mytui::ui as ui;
@@ -32,7 +32,7 @@ pub (crate) fn print_menu_tui(
 
     let stdout = io::stdout().into_raw_mode()?;
     let stdout = MouseTerminal::from(stdout);
-    let stdout = AlternateScreen::from(stdout);
+    let stdout = stdout.into_raw_mode()?.into_alternate_screen()?;
     let backend = TermionBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
     terminal.hide_cursor()?;
@@ -46,14 +46,14 @@ pub (crate) fn print_menu_tui(
 
     loop {
 
-        ui::draw(&mut terminal, &app)?;
+        ui::draw(&mut terminal, &mut app)?;
 
         if let Event::Input(key) = events.next()? {
 
             match key {
 
                 Key::Char(c) => {
-                    app.on_key(c);
+                    app.on_key(c)?;
                 }
                 Key::Up => {
                     app.on_up();

src/mytui/ui.rs

@@ -1,35 +1,57 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
-use std::io;
+use std::error::Error;
 
-use ::tui::Terminal;
-use ::tui::style::{Color, Modifier, Style};
-use ::tui::widgets::{Widget, Block, Borders, SelectableList, Text, Paragraph, List};
-use ::tui::layout::{Layout, Constraint, Direction};
-use ::tui::backend::Backend;
+use ::ratatui::Terminal;
+use ::ratatui::style::{Color, Modifier, Style};
+use ::ratatui::text::{Text, Span, Line};
+use ratatui::widgets::{Wrap, ListItem};
+use ::ratatui::widgets::{Block, Borders, Paragraph, List};
+use ::ratatui::layout::{Layout, Constraint, Direction};
+use ::ratatui::backend::Backend;
 
 use crate::mytui::app::{PrintWindow, REPORTS};
 
 
-pub fn draw<B: Backend>(terminal: &mut Terminal<B>, app: &PrintWindow) -> Result<(), io::Error> {
+pub fn draw<B: Backend>(terminal: &mut Terminal<B>, app: &mut PrintWindow) -> Result<(), Box<dyn Error>> {
 
-    terminal.draw(|mut f| {
+    terminal.draw(|f| {
 
-        let instructions = [
-            Text::raw("\nPress '"),
-            Text::styled("x", Style::default().fg(Color::Cyan).modifier(Modifier::BOLD)),
-            Text::raw("' to add the selected report to the list of reports to print/export.\n"),
-            Text::raw("\nPress '"),
-            Text::styled("d", Style::default().fg(Color::Yellow).modifier(Modifier::BOLD)),
-            Text::raw("' to delete the selected report from the list of reports to print/export.\n"),
-            Text::raw("\nPress '"),
-            Text::styled("p", Style::default().fg(Color::Green).modifier(Modifier::BOLD)),
-            Text::raw("' to print/export the selected reports.\n"),
-            Text::raw("\nPress '"),
-            Text::styled("q", Style::default().fg(Color::Red).modifier(Modifier::BOLD)),
-            Text::raw("' to quit without printing.\n\n"),
+        let instructions = vec![
+            Line::from(vec![Span::raw("")]),
+
+            Line::from(vec![
+                Span::raw("  Press '"),
+                Span::styled("x", Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)),
+                Span::raw("' to add the selected report to the list of reports to print/export."),
+            ]),
+
+            Line::from(vec![Span::raw("")]),
+            
+            Line::from(vec![
+                Span::raw("  Press '"),
+                Span::styled("d", Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)),
+                Span::raw("' to delete the selected report from the list of reports to print/export."),
+            ]),
+            
+            Line::from(vec![Span::raw("")]),
+            
+            Line::from(vec![
+                Span::raw("  Press '"),
+                Span::styled("p", Style::default().fg(Color::Green).add_modifier(Modifier::BOLD)),
+                Span::raw("' to print/export the selected reports."),
+            ]),
+            
+            Line::from(vec![Span::raw("")]),
+            
+            Line::from(vec![
+                Span::raw("  Press '"),
+                Span::styled("q", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD)),
+                Span::raw("' to quit without printing."),
+            ]),
         ];
+
         let rpts_to_prnt = app.to_print_by_title.iter().map(|&rpt_to_prnt| {
             Text::styled(
                 format!("{}", rpt_to_prnt),
@@ -40,53 +62,60 @@ pub fn draw<B: Backend>(terminal: &mut Terminal<B>, app: &PrintWindow) -> Result
         let top_level_chunks = Layout::default()
             .constraints([
                 Constraint::Length(1),
-                Constraint::Length(2 + (instructions.len() as u16 / 3 * 2)), // 2 for title "Instructions", plus 3 TEXT array elements/instruction
+                Constraint::Length(instructions.len() as u16 + 2),
                 Constraint::Length(REPORTS.len() as u16 + 2),
                 Constraint::Length(rpts_to_prnt.len() as u16 + 2),
                 Constraint::Length(1),
             ].as_ref())
             .split(f.size());
 
-        Paragraph::new(instructions.iter())
-            .block(
-                Block::default()
-                    .borders(Borders::NONE)
-                    .title("Instructions")
-                    .title_style(Style::default().fg(Color::Blue).modifier(Modifier::BOLD).modifier(Modifier::UNDERLINED)),
+        let pg1 = Paragraph::new(instructions)
+            .block(Block::default()
+                .borders(Borders::NONE)
+                .title(Span::styled(
+                    "Instructions",
+                    Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD).add_modifier(Modifier::UNDERLINED)
+                ))
             )
-            .wrap(true)
-            .render(&mut f, top_level_chunks[1]);
+            .wrap(Wrap {trim: false});
+        f.render_widget(pg1, top_level_chunks[1]);
 
         let level_2_chunks = Layout::default()
             .constraints([Constraint::Percentage(10), Constraint::Percentage(80),Constraint::Percentage(10),].as_ref())
             .direction(Direction::Horizontal)
             .split(top_level_chunks[2]);
 
-        SelectableList::default()
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .title("Reports available for exporting")
-                    .title_style(Style::default().fg(Color::White).modifier(Modifier::BOLD).modifier(Modifier::UNDERLINED))
+        let report_list_items: Vec<_> = app.tasks.items.iter().map(|i| ListItem::new(*i)).collect();
+
+        let items = List::new(report_list_items)
+            .block(Block::default()
+                .borders(Borders::ALL)
+                .title(Span::styled(
+                    "Reports available for exporting",
+                    Style::default().fg(Color::White).add_modifier(Modifier::BOLD).add_modifier(Modifier::UNDERLINED)
+                ))
             )
-            .items(&app.tasks.items)
-            .select(Some(app.tasks.selected))
-            .highlight_style(Style::default().fg(Color::Yellow).modifier(Modifier::BOLD))
-            .highlight_symbol(">")
-            .render(&mut f, level_2_chunks[1]);
+            .highlight_style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD))
+            .highlight_symbol(">");
+        f.render_stateful_widget(items, level_2_chunks[1], &mut app.tasks.state);
 
         let level_2_chunks = Layout::default()
             .constraints([Constraint::Percentage(10), Constraint::Percentage(80),Constraint::Percentage(10),].as_ref())
             .direction(Direction::Horizontal)
             .split(top_level_chunks[3]);
 
-        List::new(rpts_to_prnt)
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .title("Reports to be exported")
-                    .title_style(Style::default().fg(Color::LightYellow).modifier(Modifier::BOLD).modifier(Modifier::UNDERLINED))
-            )
-            .render(&mut f, level_2_chunks[1]);
-    })
+        let rpts_to_prnt: Vec<_> = app.to_print_by_title.iter().map(|i| ListItem::new(*i)).collect();
+
+        let to_print = List::new(rpts_to_prnt)
+            .block(Block::default()
+                .borders(Borders::ALL)
+                .title(Span::styled(
+                    "Reports to be exported",
+                    Style::default().fg(Color::LightYellow).add_modifier(Modifier::BOLD).add_modifier(Modifier::UNDERLINED)
+                ))
+            );
+        f.render_widget(to_print, level_2_chunks[1]);
+    })?;
+
+    Ok(())
 }

src/setup.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::path::PathBuf;
@@ -20,47 +20,49 @@ use crate::wizard;
 pub fn get_env(cmd_args: &super::Cli) -> Result<super::Cfg, Box<dyn Error>> {
 
     match dotenv::dotenv() {
-        Ok(_path) => { println!("Setting environment variables from .env file.") },
+        Ok(_path) => { println!("Exporting temporary environment variables from .env file.") },
         Err(_e) => println!("Did not find .env file.")
     }
 
+    println!("  Setting runtime variables according to command line options or environment variables (the former take precedent).");
+
     let iso_date: bool = if cmd_args.iso_date {
-        println!("  Command line flag for ISO_DATE was set. Using YY-mm-dd or YY/mm/dd.");
+        println!("    Command line flag for ISO_DATE was set. Using YY-mm-dd or YY/mm/dd.");
         true
     } else {
         match env::var("ISO_DATE") {
             Ok(val) => {
                 if val == "1" || val.to_lowercase() == "true" {
-                    println!("  Found ISO_DATE env var: {}. Using YY-mm-dd or YY/mm/dd.", val);
+                    println!("    Found ISO_DATE env var: {}. Using YY-mm-dd or YY/mm/dd.", val);
                     true
                 } else {
-                    println!("  Found ISO_DATE env var: {} (not 1 or true). Using MM-dd-YY or MM/dd/YY.", val);
+                    println!("    Found ISO_DATE env var: {} (not 1 or true). Using MM-dd-YY or MM/dd/YY.", val);
                     false
                 }
             },
             Err(_e) => {
-                println!("  Using default dating convention (MM-dd-YY or MM/dd/YY).");
+                println!("    Using default dating convention (MM-dd-YY or MM/dd/YY).");
                 false
             },
         }
     };
 
     let date_separator_is_slash: bool = if cmd_args.date_separator_is_slash {
-        println!("  Command line flag for DATE_SEPARATOR_IS_SLASH was set. Date separator set to slash (\"/\").");
+        println!("    Command line flag for DATE_SEPARATOR_IS_SLASH was set. Date separator set to slash (\"/\").");
         true
     } else {
         match env::var("DATE_SEPARATOR_IS_SLASH") {
             Ok(val) => {
                 if val == "1" || val.to_ascii_lowercase() == "true" {
-                    println!("  Found DATE_SEPARATOR_IS_SLASH env var: {}. Date separator set to slash (\"/\").", val);
+                    println!("    Found DATE_SEPARATOR_IS_SLASH env var: {}. Date separator set to slash (\"/\").", val);
                     true
                 } else {
-                    println!("  Found DATE_SEPARATOR_IS_SLASH env var: {} (not 1 or true). Date separator set to hyphen (\"-\").", val);
+                    println!("    Found DATE_SEPARATOR_IS_SLASH env var: {} (not 1 or true). Date separator set to hyphen (\"-\").", val);
                     false
                 }
             }
             Err(_e) => {
-                println!("  Using default date separator, hyphen (\"-\").");
+                println!("    Using default date separator, hyphen (\"-\").");
                 false
             },
         }
@@ -68,26 +70,26 @@ pub fn get_env(cmd_args: &super::Cli) -> Result<super::Cfg, Box<dyn Error>> {
 
     let home_currency = match env::var("HOME_CURRENCY") {
         Ok(val) => {
-            println!("  Found HOME_CURRENCY env var: {}", val);
+            println!("    Found HOME_CURRENCY env var: {}", val);
             val.to_uppercase()},
         Err(_e) => {
-            println!("  Using default home currency (USD).");
+            println!("    Using default home currency (USD).");
             "USD".to_string()},
     };
 
     let lk_cutoff_date = match env::var("LK_CUTOFF_DATE") {
         Ok(val) => {
-            println!("  Found LK_CUTOFF_DATE env var: {}", val);
+            println!("    Found LK_CUTOFF_DATE env var: {}", val);
             Some(val)},
         Err(_e) => None,
     };
     
     let inv_costing_method = match env::var("INV_COSTING_METHOD") {
         Ok(val) => {
-            println!("  Found INV_COSTING_METHOD env var: {}", val);
+            println!("    Found INV_COSTING_METHOD env var: {}", val);
             val},
         Err(_e) => {
-            println!("  Using default inventory costing method (LIFO by lot creation date).");
+            println!("    Using default inventory costing method (LIFO by lot creation date).");
             "1".to_string()},
     };
 
@@ -110,14 +112,14 @@ pub struct ArgsForImportVarsTBD {
     pub suppress_reports: bool,
 }
 
-pub (crate) fn run_setup(cmd_args: super::Cli, cfg: super::Cfg) -> Result<(PathBuf, ImportProcessParameters), Box<dyn Error>> {
+pub (crate) fn run_setup(cmd_args: &super::Cli, cfg: super::Cfg) -> Result<(PathBuf, ImportProcessParameters), Box<dyn Error>> {
 
     let date_separator = match cfg.date_separator_is_slash {
         false => { "-" } // Default
         true => { "/" } // Overridden by env var or cmd line flag
     };
 
-    let input_file_path = match cmd_args.file_to_import {
+    let input_file_path = match cmd_args.file_to_import.to_owned() {
         Some(file) => { 
             if File::open(&file).is_ok() {
                 file
@@ -137,7 +139,7 @@ pub (crate) fn run_setup(cmd_args: super::Cli, cfg: super::Cfg) -> Result<(PathB
     let wizard_or_not_args = ArgsForImportVarsTBD {
         inv_costing_method_arg: cfg.inv_costing_method,
         lk_cutoff_date_arg: cfg.lk_cutoff_date,
-        output_dir_path: cmd_args.output_dir_path,
+        output_dir_path: cmd_args.output_dir_path.to_owned(),
         suppress_reports: cmd_args.suppress_reports,
     };
 
@@ -165,7 +167,6 @@ pub (crate) fn run_setup(cmd_args: super::Cli, cfg: super::Cfg) -> Result<(PathB
         lk_basis_date_preserved: true,  //  TODO
         should_export,
         export_path: output_dir_path,
-        print_menu: cmd_args.print_menu,
         journal_entry_export: cmd_args.journal_entries_only,
     };
 

src/skip_wizard.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::path::PathBuf;
@@ -7,7 +7,7 @@ use std::error::Error;
 use crptls::costing_method::InventoryCostingMethod;
 
 use crate::cli_user_choices;
-use crate::setup::{ArgsForImportVarsTBD};
+use crate::setup::ArgsForImportVarsTBD;
 
 
 pub(crate) fn skip_wizard(args: ArgsForImportVarsTBD) -> Result<(

src/wizard.rs

@@ -1,4 +1,4 @@
-// Copyright (c) 2017-2019, scoobybejesus
+// Copyright (c) 2017-2023, scoobybejesus
 // Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
 
 use std::error::Error;
@@ -9,7 +9,7 @@ use std::path::PathBuf;
 use crptls::costing_method::InventoryCostingMethod;
 
 use crate::cli_user_choices;
-use crate::setup::{ArgsForImportVarsTBD};
+use crate::setup::ArgsForImportVarsTBD;
 
 
 pub(crate) fn wizard(args: ArgsForImportVarsTBD) -> Result<(