Changed structopt dependency to clap and updated to latest version.

Completed documenting create_lots_and_movements()

.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.9.1"
+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

@@ -60,12 +60,13 @@ The truth is that the input file is simple to maintain once it is brought curren
 The rules for successfully preparing and maintaining the input file can generally be summarized as follows:
 
 1. The first account must be given number `1`, and each additional account must count up sequentially.
-2. Margin quote account `ticker`s must be followed by an underscore and the base account ticker (i.e., `BTC_xmr`).
-3. `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.
-4. `Proceeds` must have a period as a decimal separator (`1,000.00` not `1.000,00`) and must not contain the ticker or symbol (USD or $).
-5. Only home currency accounts can have negative balances. Crypto accounts may not go negative at any time.
+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, 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.
@@ -188,8 +189,9 @@ Until "spot" funds are spent to pay off the margin loans, it's simply an [unreco
 
 * **txDate**: As a default, this parser expects a format of `MM-dd-YY` or `MM-dd-YYYY`.
 The ISO 8601 date format (`YYYY-MM-dd` or `YY-MM-dd` both work) may be indicated by setting the environment variable `ISO_DATE` to `1` or `true`.
-The hyphen, slash, or period delimiters (`-`, `/`, or `.`) may be indicated
-by setting `DATE_SEPARATOR` to `h`, `s`, or `p`, respectively (hyphen, `-`, is default).
+The hyphen date separator character (`-`) is the default.  The slash date separator character (`/`) may be indicated
+by setting the `DATE_SEPARATOR_IS_SLASH` environment variable (or in .env file) to `1` or `true`,
+or by passing the `date_separator_is_slash` command line flag.
 
 * **proceeds**: This is can be any **positive** number that will parse into a floating point 32-bit number,
 as long as the **decimal separator** is a **period**.
@@ -199,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

@@ -8,6 +8,8 @@ This is a command-line tool that calculates income, expenses, realized gains, re
 and holding period from cryptocurrency activity and denominates the results in the user's home currency.
 The default home currency is USD, but any currency can be substituted.
 This tool is probably most useful for filling out a tax return or making tax planning decisions.
+It is already mildly difficult to do the prep work (CSV input file, below) for using a tool like this,
+so a person wanted this for a quick fix may be disappointed.
 
 ---
 
@@ -23,13 +25,16 @@ containing the user's entire cryptocurrency transaction history, the software wi
 
 *The tracking isn't pooled by `ticker`.  Rather, it's tracked at the account/wallet level.
 
+There is a helper Python script at the root of the repo that will assist you in sanitizing your CSV file
+so it can be successfully imported into `cryptools`.
+
 ---
 
 ### Features
 
 * 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
 
@@ -52,6 +57,18 @@ when appreciated cryptocurrency was used to make a tax-deductible charitable con
 * Precision is limited to eight decimal places.  Additional digits will be stripped during
 import and may cause unintended rounding issues.
 
+* Microsoft Excel.  Don't let Excel cause you to bang your head against a wall.
+`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
 
 1. `git clone https://github.com/scoobybejesus/cryptools.git`
@@ -60,10 +77,15 @@ import and may cause unintended rounding issues.
 
 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:
@@ -71,6 +93,13 @@ To skip the wizard, there are three requirements:
 * The `-a` flag must be passed.
 * The configuration settings you require are the same as default, or you set the appropriate environment variables, or you have a `.env` file.
 
+`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
+(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.
 
@@ -78,7 +107,14 @@ 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
+
+Hop into `/usr/local/bin`, and run `ln -s /path/to/cryptools/target/debug/cryptools cryptools`
+and `ln -s /path/to/cryptools/clean_input_csv.py clean_input_csv` to be able to run the sanitizer
+script and `cryptools` from the directory where you keep your CSV Input File.
 
 ## Development state
 

clean_input_csv.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+
+## Purpose:	Allows user to keep additional data in their CSV Input File to increase its usefulness and
+##			enhance readability, yet be able to properly format it prior to importing into `cryptools`.
+##			e.g.:
+##				-Keep an additional first column for flagging/noting important transactions
+##				-Keep additional columns for tracking a running balance
+##				-Rows beneath transactions for life-to-date totals and other calculations and notes
+##				-Ability to use number formatting with parenthesis for negative numbers and commas
+##					-This script will change (1,000.00) to 1000.00
+##
+##			If a column doesn't have a header, this script will exclude it from the sanitized output.
+##			Similarly, this script will exclude transaction rows missing data in either of the first
+##			two fields of the row.
+
+## Usage:
+
+# 1.  Export/Save crypto activity as csv
+# 2.  Move the csv file to your desired directory
+# 3.  Rename file to <unedited>.csv (see variable below)
+# 4.  Build/run this file in an editor or on command line (from same directory), creating the input file
+# 5.  Import the input file into cryptools
+
+import csv
+import re
+import os
+import sys
+
+unedited = "DigiTrnx.csv" 	# To be replaced with a launch arg, presumably	
+
+stage1 = "stage1.csv"
+
+##		First, writes all header rows.  Then attempts to write all transaction rows.
+##      In the transaction rows, if it finds blank/empty transaction date or proceeds fields,
+##		it discards the row.
+
+##		This allows notes/sums/calculations/etc under the transaction rows to be discarded
+
+with open(unedited) as fin, open(stage1, 'a') as fout:
+	rdr = csv.reader(fin) 	
+	wtr = csv.writer(fout)
+	header = next(rdr)
+	header2 = next(rdr)
+	header3 = next(rdr)
+	header4 = next(rdr)		
+	wtr.writerow(header)
+	wtr.writerow(header2)
+	wtr.writerow(header3)
+	wtr.writerow(header4)
+
+	# First, double check there are no account number duplicates
+	for i, val in enumerate(header):
+		if val != "":
+			if header.count(val) > 1:
+				print("### There is a duplicate account number (" + val +").  Please fix and re-run. ###")
+				sys.exit()
+
+	for row in rdr:
+		if row[0] == "" or row[1] == "":
+			pass
+		else:
+			wtr.writerow(row)
+
+stage2 = "stage2.csv"
+
+##		Iterates over the fields in the first header row to search for empty/blank cells.
+##      Keeps a list of every column index that does contain data, and disregards all the
+##		indices for columns with a blank.
+
+##		Using the indicies of valid columns, writes a new CSV file using only valid columns.
+
+##		This is useful when the input file is also used to manually keep a running tally or
+##		columns with additional notes, but which must be discarded to prepare a proper
+##		CSV input file.
+
+with open(stage1) as fin, open(stage2, 'a') as fout:
+	rdr = csv.reader(fin)
+	wtr = csv.writer(fout)
+	header = next(rdr)
+	header2 = next(rdr)
+	header3 = next(rdr)
+	header4 = next(rdr)
+
+	colListKept = []
+
+	for col in header:
+		if col == "":
+			pass
+		else:
+			colListKept.append(header.index(col))
+
+	output = [v for (i,v) in enumerate(header) if i in colListKept]
+	wtr.writerow(output)
+
+	output = [v for (i,v) in enumerate(header2) if i in colListKept]
+	wtr.writerow(output)
+
+	output = [v for (i,v) in enumerate(header3) if i in colListKept]
+	wtr.writerow(output)
+
+	output = [v for (i,v) in enumerate(header4) if i in colListKept]
+	wtr.writerow(output)
+
+	for row in rdr:
+		output = [v for (i,v) in enumerate(row) if i in colListKept]
+		wtr.writerow(output)
+
+
+stage3 = "InputFile-pycleaned.csv"
+
+##		Performs final formatting changes to ensure values can be successfully parsed.
+##	 	Numbers must have commas removed.  Negative numbers must have parentheses replaced
+##		with a minus sign.  Could also be used to substitute the date separation character.
+
+##	 	i.e., (1.01) -> -1.01  (1,000.00) -> -1000.00
+
+with open(stage2) as fin, open(stage3, 'w') as fout:
+	rdr = csv.reader(fin, quoting=csv.QUOTE_ALL) 	
+	wtr = csv.writer(fout)
+	
+	header = next(rdr)
+	header2 = next(rdr)
+	header3 = next(rdr)
+	header4 = next(rdr)
+	wtr.writerow(header)
+	wtr.writerow(header2)
+	wtr.writerow(header3)
+	wtr.writerow(header4)
+
+	for row in rdr:
+		listRow = []
+		for field in row:
+			fieldStr = str(field) # cast as string, just so there's no funny business
+			try:
+				# Handles negative numbers
+				if fieldStr[0] == "(":
+					fieldStr = fieldStr.replace('(','-').replace(')', '').replace(',', '')
+					listRow.append(fieldStr)
+					continue
+
+			# Uncomment the below and modify as necessary if you want to change date formatting
+				# elif re.search(r'\d\d-\d\d-\d\d',fieldStr):#	Find dates and change formatting
+				# 	fieldStr = fieldStr.replace('-', '/')
+				# 	listRow.append(fieldStr)
+				# 	continue
+
+				# Handle commas in remaining fields
+				else: 
+					try:
+						# if you remove commas from a string and are able to convert to float...
+						fieldStr_test = fieldStr.replace(',', '')
+						fieldStr_float = float(fieldStr_test)
+						# then it is definitely a positive number, so remove the comma.
+						fieldStr = fieldStr.replace(',', '')
+						listRow.append(fieldStr)
+						continue
+					except: # If the 'try' block fails, it's a memo, not a number, so leave any commas
+						listRow.append(fieldStr)
+						continue
+			except: # If the `try` block fails, it's a blank/empty string
+				listRow.append(fieldStr)
+				continue
+		wtr.writerow(listRow)
+
+os.remove(stage1)
+os.remove(stage2)
+
+print("Input file ready")

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,18 +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, NaiveTime, NaiveDateTime, DateTime, Utc, TimeZone};
-use chrono_tz::US::Eastern;
-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 {
@@ -45,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;
@@ -55,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;
@@ -65,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;
@@ -80,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
             }
         }
@@ -103,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
 	}
@@ -124,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 {
@@ -155,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();
@@ -168,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();
@@ -181,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();
@@ -190,31 +190,46 @@ 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()
 	}
 
-	pub fn get_term(&self, acct_map: &HashMap<u16, Account>, ar_map: &HashMap<u32, ActionRecord>,) -> Term {
+	/// This function is only called during export operations.  In addition, this will
+	/// only be called on flow and outgoing exchange `transactions`. Lastly, the only
+	/// `movement`s subject to this call with have non-margin accounts.
+	pub fn get_term(
+		&self,
+		acct_map: &HashMap<u16, Account>,
+		ar_map: &HashMap<u32, ActionRecord>,
+		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);
 
     	match ar.direction() {
 
 			Polarity::Incoming => {
-				let today = Utc::now();
-				let utc_lot_date = Self::create_date_time_from_atlantic(
-                    lot.date_for_basis_purposes,
-                    NaiveTime::from_hms_milli(12, 34, 56, 789)
-                );
-				// if today.signed_duration_since(self.lot.date_for_basis_purposes) > 365
-				if (today - utc_lot_date) > Duration::days(365) {
-                    //	TODO: figure out how to instantiate today's date and convert it to compare to NaiveDate
+
+				// For a dual-`action record` `transaction` with a non-margin `account` incoming amount,
+				// if there was like-kind treatment, the basis date may be before the `transaction` date.
+				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) > chrono::Duration::days(365) {
+						return Term::LT
+					}
+					return Term::ST
+				}
+
+				// 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) > chrono::Duration::days(365) {
 					Term::LT
 				}
 				else {
@@ -226,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
@@ -234,14 +249,6 @@ impl Movement {
 		}
 	}
 
-	pub fn create_date_time_from_atlantic(date: NaiveDate, time: NaiveTime) -> DateTime<Utc> {
-
-		let naive_datetime = NaiveDateTime::new(date, time);
-		let east_time = Eastern.from_local_datetime(&naive_datetime).unwrap();
-
-        east_time.with_timezone(&Utc)
-	}
-
 	pub fn get_income(
 		&self,
 		ar_map: &HashMap<u32,
@@ -249,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?");
 
@@ -262,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)) }
 		}
 	}
 
@@ -275,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?");
 
@@ -292,7 +299,7 @@ impl Movement {
 
                     if raw_acct.is_margin {
 
-                       Ok(d128!(0))
+                       Ok(dec!(0))
 
                     } else {
 
@@ -300,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)) }
 		}
     }
 
@@ -319,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,
@@ -95,10 +95,11 @@ pub fn import_and_process_final(
 
     if settings.lk_treatment_enabled {
 
-        println!(" Applying like-kind treatment for cut-off date: {}.", settings.lk_cutoff_date);
+        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/csv_import_accts_txns.rs

@@ -0,0 +1,358 @@
+// 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::path::PathBuf;
+
+use chrono::NaiveDate;
+use rust_decimal::Decimal;
+use rust_decimal_macros::dec;
+
+use crate::transaction::{Transaction, ActionRecord};
+use crate::account::{Account, RawAccount};
+use crate::decimal_utils::round_d128_1e8;
+
+
+pub fn import_from_csv(
+    import_file_path: PathBuf,
+    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>,
+    transactions_map: &mut HashMap<u32, Transaction>,
+) -> Result<(), Box<dyn Error>> {
+
+    let file = match File::open(import_file_path) {
+        Ok(x) => {
+            // println!("\nCSV ledger file opened successfully.\n");
+            x
+        },
+        Err(e) => {
+            println!("Invalid import_file_path");
+            eprintln!("System error: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    let mut rdr = csv::ReaderBuilder::new()
+        .has_headers(true)
+        .from_reader(file);
+
+    import_accounts(&mut rdr, raw_acct_map, acct_map)?;
+
+    import_transactions(
+        &mut rdr,
+        iso_date_style,
+        &separator,
+        action_records,
+        transactions_map,
+    )?;
+
+    Ok(())
+}
+
+fn import_accounts(
+    rdr: &mut csv::Reader<File>,
+    raw_acct_map: &mut HashMap<u16, RawAccount>,
+    acct_map: &mut HashMap<u16, Account>,
+) -> Result<(), Box<dyn Error>> {
+
+    let header1 = rdr.headers()?.clone();   //  account_num
+    let mut header2: csv::StringRecord = csv::StringRecord::new();  //  name
+    let mut header3: csv::StringRecord = csv::StringRecord::new();  //  ticker
+    let header4: csv::StringRecord; //  is_margin
+
+    // Account Creation loop.  With rdr.has_headers() set to true above, the first record here is the second row of the CSV
+    for result in rdr.records() {
+        //  This initial iteration through records will break after the 4th row, after accounts have been created
+        let record = result?;
+        if header2.len() == 0 {
+            header2 = record.clone();
+            continue    //  After header2 is set, continue to next record
+        }
+        else if header3.len() == 0 {
+            header3 = record.clone();
+            continue    //  After header3 is set, continue to next record
+        }
+        else {
+            header4 = record.clone();
+            // 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 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!("\nCreating accounts...");
+
+            let length = &headerstrings.len();
+
+            for (idx, field) in headerstrings[3..*length].iter().enumerate() {
+
+                // Parse account numbers.
+                let account_num = field.trim().parse::<u16>().expect(&format!("Header row account number should parse into u16: {}", field));
+                // For now, their columns aren't remembered.  Instead, they must have a particular index. 0th idx is the 1st account, and so on.
+                if account_num != ((idx + 1) as u16) {
+                    println!("FATAL: CSV Import: {}", acct_num_warn);
+                    std::process::exit(1);
+                }
+
+                let ind = idx+3; // Add three because the idx skips the first three 'key' columns
+                let name:String = header2[ind].trim().to_string();
+                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.to_lowercase().trim() {
+                    "no" | "non" | "false" => false,
+                    "yes" | "margin" | "true" => true,
+                    _ => {
+                        println!("\n FATAL: CSV Import: Couldn't parse margin value for account {} {} \n",account_num, name);
+                        process::exit(1)
+                    }
+                };
+
+                let just_account: RawAccount = RawAccount {
+                    account_num,
+                    name,
+                    ticker,
+                    is_margin,
+                };
+
+                raw_acct_map.insert(account_num, just_account);
+
+                let account: Account = Account {
+                    raw_key: account_num,
+                    list_of_lots: RefCell::new([].to_vec())
+                };
+
+                acct_map.insert(account_num, account);
+            }
+            break    //  This `break` exits this scope so `accounts` can be accessed in `import_transactions`. The rdr stays put.
+        }
+    };
+    Ok(())
+}
+
+fn import_transactions(
+    rdr: &mut csv::Reader<File>,
+    iso_date_style: bool,
+    separator: &String,
+    action_records: &mut HashMap<u32, ActionRecord>,
+    txns_map: &mut HashMap<u32, Transaction>,
+) -> Result<(), Box<dyn Error>> {
+
+    let mut this_tx_number = 0;
+    let mut this_ar_number = 0;
+    let mut changed_action_records = 0;
+    let mut changed_txn_num = Vec::new();
+
+    println!("Creating transactions...");
+
+    for result in rdr.records() {
+
+        //  rdr's cursor is at row 5, which is the first transaction row
+        let record = result?;
+        this_tx_number += 1;
+
+        //  First, initialize metadata fields.
+        let mut this_tx_date: &str = "";
+        let mut this_proceeds: &str;
+        let mut this_memo: &str = "";
+        let mut proceeds_parsed = 0f32;
+
+        //  Next, create action_records.
+        let mut action_records_map_keys_vec: Vec<u32> = Vec::with_capacity(2);
+        let mut outgoing_ar: Option<ActionRecord> = None;
+        let mut incoming_ar: Option<ActionRecord> = None;
+        let mut outgoing_ar_num: Option<u32> = None;
+        let mut incoming_ar_num: Option<u32> = None;
+
+        for (idx, field) in record.iter().enumerate() {
+
+            //  Set metadata fields on first three fields.
+            if idx == 0 { this_tx_date = field; }
+            else if idx == 1 {
+                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.
+            else if field != "" {
+                this_ar_number += 1;
+                let ind = idx;  //  starts at 3, which is the fourth field
+                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;
+
+                let amount_str = field.replace(",", "");
+                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); }
+
+                let action_record = ActionRecord {
+                    account_key,
+                    amount: amount_rounded,
+                    tx_key: this_tx_number,
+                    self_ar_key: this_ar_number,
+                    movements: RefCell::new([].to_vec()),
+                };
+
+                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())
+                } else {
+                    outgoing_ar = Some(action_record);
+                    outgoing_ar_num = Some(this_ar_number);
+                    action_records_map_keys_vec.insert(0, outgoing_ar_num.unwrap())
+                };
+            }
+        }
+
+        // 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);
+        }
+
+        if let Some(outgoing_ar) = outgoing_ar {
+            let y = outgoing_ar_num.unwrap();
+            action_records.insert(y, outgoing_ar);
+        }
+
+        let format_yy: String;
+        let format_yyyy: String;
+
+        if iso_date_style {
+            format_yyyy = "%Y".to_owned() + separator + "%m" + separator + "%d";
+            format_yy = "%y".to_owned() + separator + "%m" + separator + "%d";
+        } else {
+            format_yyyy = "%m".to_owned() + separator + "%d" + separator + "%Y";
+            format_yy = "%m".to_owned() + separator + "%d" + separator + "%y";
+        }
+
+        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("
+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 {
+            tx_number: this_tx_number,
+            date_as_string: this_tx_date.to_string(),
+            date: tx_date,
+            user_memo: this_memo.to_string(),
+            proceeds: proceeds_parsed,
+            action_record_idx_vec: action_records_map_keys_vec,
+        };
+
+        txns_map.insert(this_tx_number, transaction);
+    };
+
+    if changed_action_records > 0 {
+        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 {
@@ -52,7 +53,8 @@ impl Transaction {
 			let ar2_ticker = ar2_ticker_comp[0];
 
 			if first_ar.direction() == second_ar.direction() {
-				println!("Program exiting. Found transaction with two actionRecords with the same polarity: {:?}", self); process::exit(1);
+                println!("FATAL: TxType: Found transaction with two actionRecords with the same polarity: \n{:#?}", self);
+                process::exit(1);
 			}
 			if ar1_ticker == ar2_ticker {
 				if ar1_raw_acct.is_margin != ar2_raw_acct.is_margin {
@@ -67,10 +69,12 @@ impl Transaction {
 			}
 		}
 		else if self.action_record_idx_vec.len() > 2 {
-			println!("Program exiting. Found transaction with too many actionRecords: {:?}", self); process::exit(1);
+            println!("FATAL: TxType: Found transaction with too many actionRecords: \n{:#?}", self);
+            process::exit(1);
 		}
 		else {
-			println!("Program exiting. Found transaction with no actionRecords: {:?}", self); process::exit(1);
+            println!("FATAL: TxType: Found transaction with no actionRecords: \n{:#?}", self);
+            process::exit(1);
 		}
 	}
 
@@ -92,11 +96,23 @@ impl Transaction {
 			}
 		} else {
 
-			assert_eq!(self.action_record_idx_vec.len(),2,
-                "Each txn can only have one or two ARs. Txn has {} ARs.", self.action_record_idx_vec.len());
+            if self.action_record_idx_vec.len() != 2 {
+                println!("FATAL: Each transaction may have up to two actionrecords, and there are {} actionrecords in transaction:\n{:#?}",
+                self.action_record_idx_vec.len(), self);
+            }
 
-			let first_ar = ars.get(&self.action_record_idx_vec[0]).unwrap();
-			let second_ar = ars.get(&self.action_record_idx_vec[1]).unwrap();
+            let first_ar = match ars.get(&self.action_record_idx_vec[0]) {
+                Some(x) => x,
+                None => {
+                    println!("FATAL: ActionRecord not found for: \n{:#?}", self);
+                    process::exit(1)}
+            };
+			let second_ar = match ars.get(&self.action_record_idx_vec[1]) {
+                Some(x) => x,
+                None => {
+                    println!("FATAL: ActionRecord not found for: \n{:#?}", self);
+                    process::exit(1)}
+            };
 
 			let first_acct = acct_map.get(&first_ar.account_key).unwrap();
 			let second_acct = acct_map.get(&second_ar.account_key).unwrap();
@@ -144,7 +160,8 @@ impl Transaction {
 			quote = second_acct_raw_key;
 			Ok((base, quote))
 		} else {
-			println!("{}", VariousErrors::MarginNoUnderbar); use std::process::exit; exit(1)
+            println!("FATAL: {}", VariousErrors::MarginNoUnderbar);
+            std::process::exit(1);
 		}
 	}
 
@@ -281,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)
@@ -301,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>>>,
@@ -310,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()
@@ -357,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,19 +1,21 @@
 ## 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.
 
 # Setting to `TRUE` or `1` will cause 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, depending on the date-separator option)
+# the format YYYY-MM-dd or YY-MM-dd (or YYYY/MM/dd or YY/MM/dd, depending on the date-separator character)
 # instead of the default US-style MM-dd-YYYY or MM-dd-YY (or MM/dd/YYYY or MM/dd/YY, depending on the
 # date separator option).
 # (bool; default is FALSE/0)
 #ISO_DATE=0
 
-# Choose "h", "s", or "p" for hyphen, slash, or period (i.e., "-", "/", or ".") to indicate the separator
-# character used in the `file_to_import` `txDate` column (i.e. 2017/12/31, 2017-12-31, or 2017.12.31).
-# (String; default is 'h')
-#DATE_SEPARATOR=h
+# Switches the default date separator from hyphen to slash (i.e., from "-" to "/") to indicate the separator
+# character used in the file_to_import txDate column (i.e. 2017-12-31 to 2017/12/31).
+# (bool; default is FALSE/0)
+#DATE_SEPARATOR_IS_SLASH=0
 
 # Home currency (currency in which all resulting reports are denominated).
 # (String; default is 'USD')
@@ -24,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,27 +1,27 @@
-// 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::io::{self, BufRead};
 use std::process;
 use std::path::PathBuf;
+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>> {
 
     if flag_to_accept_cli_args {
-        println!("WARN: Flag to 'accept args' was set, but 'file' is missing.\n");
+        println!("\nWARN: Flag to 'accept args' was set, but 'file_to_import' is missing.\n");
     }
 
     println!("Please input a file (absolute or relative path) to import: ");
@@ -30,6 +30,9 @@ pub fn choose_file_for_import(flag_to_accept_cli_args: bool) -> Result<PathBuf,
 
     if has_tilde {
         choose_file_for_import(flag_to_accept_cli_args)
+    } else if File::open(&file_string).is_err() {
+        println!("WARN: Invalid file path.");
+        choose_file_for_import(false)
     } else {
         Ok( PathBuf::from(file_string) )
     }
@@ -69,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(),
@@ -82,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);
@@ -125,19 +134,19 @@ pub fn choose_inventory_costing_method(cmd_line_arg: String) -> Result<Inventory
 
     let method = _costing_method(cmd_line_arg)?;
 
-    fn _costing_method(cmd_line_arg: String) -> Result<InventoryCostingMethod, Box<dyn Error>> {
+    fn _costing_method(env_var_arg: String) -> Result<InventoryCostingMethod, Box<dyn Error>> {
 
         let mut input = String::new();
         let stdin = io::stdin();
         stdin.lock().read_line(&mut input).expect("Failed to read stdin");
 
         match input.trim() { // Without .trim(), there's a hidden \n or something preventing the match
-            "" => Ok(inv_costing_from_cmd_arg(cmd_line_arg)?),
+            "" => Ok(inv_costing_from_cmd_arg(env_var_arg)?),
             "1" => Ok(InventoryCostingMethod::LIFObyLotCreationDate),
             "2" => Ok(InventoryCostingMethod::LIFObyLotBasisDate),
             "3" => Ok(InventoryCostingMethod::FIFObyLotCreationDate),
             "4" => Ok(InventoryCostingMethod::FIFObyLotBasisDate),
-            _   => { println!("Invalid choice.  Please enter a valid choice."); _costing_method(cmd_line_arg) }
+            _   => { println!("Invalid choice.  Please enter a valid choice."); _costing_method(env_var_arg) }
         }
     }
 
@@ -151,10 +160,9 @@ pub fn inv_costing_from_cmd_arg(arg: String) -> Result<InventoryCostingMethod, &
         "3" => Ok(InventoryCostingMethod::FIFObyLotCreationDate),
         "4" => Ok(InventoryCostingMethod::FIFObyLotBasisDate),
         _ => { 
-                eprintln!("WARN: Invalid environment variable for 'INV_COSTING_METHOD'. Using default."); 
+                println!("WARN: Invalid environment variable for 'INV_COSTING_METHOD'. Using default."); 
                 Ok(InventoryCostingMethod::LIFObyLotCreationDate)
-            }
-        // _   => { Err("Invalid input parameter, probably from environment variable INV_COSTING_METHOD") } 
+        }
     }
 }
 
@@ -171,7 +179,7 @@ pub(crate) fn elect_like_kind_treatment(cutoff_date_arg: &mut Option<String>) ->
                     second_date_try_from_user(&mut cutoff_date_arg).unwrap()
                 } ) );
 
-            println!("\nUse like-kind exchange treatment through {}? [Y/n/c] ('c' to 'change') ", provided_date);
+            println!("Use like-kind exchange treatment through {}? [Y/n/c] ('c' to 'change') ", provided_date);
 
             let (election, date_string) = _elect_like_kind_arg(&cutoff_date_arg, provided_date)?;
 
@@ -253,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)?;
 
@@ -278,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")
@@ -288,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/create_lots_mvmts.rs

@@ -1,919 +0,0 @@
-// Copyright (c) 2017-2019, scoobybejesus
-// Redistributions must include the license: https://github.com/scoobybejesus/cryptools/blob/master/LEGAL.txt
-
-use std::rc::{Rc};
-use std::cell::{RefCell, Ref, Cell};
-use std::collections::{HashMap};
-use std::error::Error;
-
-use decimal::d128;
-
-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};
-
-pub(crate) fn create_lots_and_movements(
-    settings: &ImportProcessParameters,
-    raw_acct_map: &HashMap<u16, RawAccount>,
-    acct_map: &HashMap<u16, Account>,
-    ar_map: &HashMap<u32, ActionRecord>,
-    txns_map: HashMap<u32, Transaction>,
-    // lot_map: &HashMap<(RawAccount, u32), Lot>,
-) -> Result<HashMap<u32,Transaction>, Box<dyn Error>> {
-
-    let chosen_home_currency = &settings.home_currency;
-    let chosen_costing_method = &settings.costing_method;
-    let enable_lk_treatment = settings.lk_treatment_enabled;
-    let like_kind_cutoff_date = settings.lk_cutoff_date;
-    let lk_basis_date_preserved = settings.lk_basis_date_preserved;
-
-    let multiple_incoming_mvmts_per_ar = lk_basis_date_preserved;
-
-    //  On with the creating of lots and movements.
-    let length = txns_map.len();
-    for num in 1..=length {
-
-        let txn_num = num as u32;
-        let txn = txns_map.get(&(txn_num)).expect("Couldn't get txn. Tx num invalid?");
-        if txn.marginness(&ar_map, &raw_acct_map, &acct_map) == TxHasMargin::TwoARs {
-            assert_eq!(txn.transaction_type(&ar_map, &raw_acct_map, &acct_map)?, TxType::Exchange);
-            assert_eq!(txn.action_record_idx_vec.len(), 2);
-
-            let the_raw_pair_keys = txn.get_base_and_quote_raw_acct_keys(&ar_map, &raw_acct_map, &acct_map)?;
-            let base_acct = acct_map.get(&the_raw_pair_keys.0).expect("Couldn't get acct. Raw pair keys invalid?");
-            let quote_acct = acct_map.get(&the_raw_pair_keys.1).expect("Couldn't get acct. Raw pair keys invalid?");
-
-            let (base_ar_idx, quote_ar_idx) = get_base_and_quote_ar_idxs(
-                the_raw_pair_keys,
-                &txn,
-                &ar_map,
-                &raw_acct_map,
-                &acct_map
-            );
-
-            let base_ar = ar_map.get(&base_ar_idx).unwrap();
-            let quote_ar = ar_map.get(&quote_ar_idx).unwrap();
-
-            let mut base_acct_lot_list = base_acct.list_of_lots.borrow_mut();
-            let mut quote_acct_lot_list = quote_acct.list_of_lots.borrow_mut();
-
-            let base_number_of_lots = base_acct_lot_list.len() as u32;
-            let quote_number_of_lots = quote_acct_lot_list.len() as u32;
-            assert_eq!(base_number_of_lots, quote_number_of_lots, "");
-
-            let acct_balances_are_zero: bool;
-
-            if !base_acct_lot_list.is_empty() && !quote_acct_lot_list.is_empty() {
-                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);
-                if base_balance_is_zero && quote_balance_is_zero {
-                    acct_balances_are_zero = true
-                } else {
-                    acct_balances_are_zero = false
-                }
-            } else {
-                assert_eq!(true, base_acct_lot_list.is_empty(),
-                    "One margin account's list_of_lots is empty, but its pair's isn't.");
-                assert_eq!(true, quote_acct_lot_list.is_empty(),
-                    "One margin account's list_of_lots is empty, but its pair's isn't.");
-                acct_balances_are_zero = true
-            }
-
-            let base_lot: Rc<Lot>;
-            let quote_lot: Rc<Lot>;
-
-            if acct_balances_are_zero {
-                base_lot =
-                Rc::new(
-                    Lot {
-                        date_as_string: txn.date_as_string.clone(),
-                        date_of_first_mvmt_in_lot: txn.date,
-                        date_for_basis_purposes: txn.date,
-                        lot_number: base_number_of_lots + 1,
-                        account_key: the_raw_pair_keys.0,
-                        movements: RefCell::new([].to_vec()),
-                    }
-                )
-                ;
-                quote_lot =
-                Rc::new(
-                    Lot {
-                        date_as_string: txn.date_as_string.clone(),
-                        date_of_first_mvmt_in_lot: txn.date,
-                        date_for_basis_purposes: txn.date,
-                        lot_number: quote_number_of_lots + 1,
-                        account_key: the_raw_pair_keys.1,
-                        movements: RefCell::new([].to_vec()),
-                    }
-                )
-                ;
-            } else {
-                base_lot = base_acct_lot_list.last().expect("Couldn't get lot. Base acct lot list empty?").clone();
-                quote_lot = quote_acct_lot_list.last().expect("Couldn't get lot. Quote acct lot list empty?").clone();
-            }
-
-            let base_mvmt = Movement {
-                amount: base_ar.amount,
-                date_as_string: txn.date_as_string.clone(),
-                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)),
-                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)),
-            };
-            wrap_mvmt_and_push(base_mvmt, &base_ar, &base_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-
-            let quote_mvmt = Movement {
-                amount: quote_ar.amount,
-                date_as_string: txn.date_as_string.clone(),
-                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)),
-                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)),
-            };
-            wrap_mvmt_and_push(quote_mvmt, &quote_ar, &quote_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-
-            if acct_balances_are_zero {
-                base_acct_lot_list.push(base_lot);
-                quote_acct_lot_list.push(quote_lot);
-            }
-            continue
-        } else {
-            for ar_num in txn.action_record_idx_vec.iter() {
-                let ar = ar_map.get(ar_num).unwrap();
-
-                let acct = acct_map.get(&ar.account_key).unwrap();
-                let raw_acct = raw_acct_map.get(&acct.raw_key).unwrap();
-                let length_of_list_of_lots = acct.list_of_lots.borrow().len();
-
-                if raw_acct.is_home_currency(&chosen_home_currency) {
-                    if length_of_list_of_lots == 0 {
-                        let lot =
-                        Rc::new(
-                            Lot {
-                                date_as_string: txn.date_as_string.clone(),
-                                date_of_first_mvmt_in_lot: txn.date,
-                                date_for_basis_purposes: txn.date,
-                                lot_number: 1,
-                                account_key: acct.raw_key,
-                                movements: RefCell::new([].to_vec()),
-                            }
-                        )
-                        ;
-                        let whole_mvmt = Movement {
-                            amount: ar.amount,
-                            date_as_string: txn.date_as_string.clone(),
-                            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)),
-                            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(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                        acct.list_of_lots.borrow_mut().push(lot);
-                        continue
-                    }
-                    else {
-                        assert_eq!(1, length_of_list_of_lots); //  Only true for home currency
-                        let lot = acct.list_of_lots.borrow_mut()[0 as usize].clone();
-                        let whole_mvmt = Movement {
-                            amount: ar.amount,
-                            date_as_string: txn.date_as_string.clone(),
-                            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)),
-                            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(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                        continue
-                    }
-                }
-                //  Note: a_r is not in home currency if here or below
-                let polarity = ar.direction();
-                let tx_type = txn.transaction_type(&ar_map, &raw_acct_map, &acct_map)?;
-
-                match polarity {
-                    Polarity::Outgoing => {
-                        // println!("Txn: {}, outgoing {:?}-type of {} {}",
-                            // txn.tx_number, txn.transaction_type(), ar.amount, acct.ticker);
-                        //
-                        if raw_acct.is_margin {
-                            let this_acct = acct_map.get(&ar.account_key).unwrap();
-                            let lot = this_acct.list_of_lots.borrow().last()
-                                .expect("Couldn't get lot. Acct lot list empty?").clone();
-                            let whole_mvmt = Movement {
-                                amount: ar.amount,
-                                date_as_string: txn.date_as_string.clone(),
-                                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)),
-                                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(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                            continue
-                        } else {
-                            let list_of_lots_to_use = acct.list_of_lots.clone();
-
-                            //  the following returns vec to be iterated from beginning to end, which provides the index for the correct lot
-                            let vec_of_ordered_index_values = match chosen_costing_method {
-                                InventoryCostingMethod::LIFObyLotCreationDate => {
-                                    get_lifo_by_creation_date(&list_of_lots_to_use.borrow())}
-                                InventoryCostingMethod::LIFObyLotBasisDate => {
-                                    get_lifo_by_lot_basis_date(&list_of_lots_to_use.borrow())}
-                                InventoryCostingMethod::FIFObyLotCreationDate => {
-                                    get_fifo_by_creation_date(&list_of_lots_to_use.borrow())}
-                                InventoryCostingMethod::FIFObyLotBasisDate => {
-                                    get_fifo_by_lot_basis_date(&list_of_lots_to_use.borrow())}
-                            };
-
-                            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() {
-                                    vec_of_indexes.insert(0, idx)
-                                }
-                                let vec = vec_of_indexes;
-                                vec
-                            }
-
-                            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();
-                                for _ in 0..length {
-                                    for j in 0..length-1 {
-                                        if reordered_vec[j].date_for_basis_purposes > reordered_vec[j+1].date_for_basis_purposes {
-                                            reordered_vec.swap(j, j+1)
-                                        }
-                                    }
-                                }
-                                let mut vec_of_indexes = [].to_vec();
-                                for (idx, _lot) in reordered_vec.iter().enumerate() {
-                                    vec_of_indexes.insert(0, idx)
-                                }
-                                let vec = vec_of_indexes;
-                                vec
-                            }
-
-                            fn get_fifo_by_creation_date(list_of_lots: &Ref<Vec<Rc<Lot>>>) -> Vec<usize> {
-                                let mut vec_of_indexes = [].to_vec();
-                                for (idx, _lot) in list_of_lots.iter().enumerate() {
-                                    vec_of_indexes.push(idx)
-                                }
-                                let vec = vec_of_indexes;
-                                vec
-                            }
-
-                            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();
-                                for _ in 0..length {
-                                    for j in 0..length-1 {
-                                        if reordered_vec[j].date_for_basis_purposes > reordered_vec[j+1].date_for_basis_purposes {
-                                            reordered_vec.swap(j, j+1)
-                                        }
-                                    }
-                                }
-                                let mut vec_of_indexes = [].to_vec();
-                                for (idx, _lot) in reordered_vec.iter().enumerate() {
-                                    vec_of_indexes.push(idx)
-                                }
-                                let vec = vec_of_indexes;
-                                vec
-                            }
-
-                            let index_position: usize = 0;
-                            let lot_index = vec_of_ordered_index_values[index_position];
-
-                            let lot_to_use = list_of_lots_to_use.borrow()[lot_index].clone();
-                            let whole_mvmt = Movement {
-                                amount: ar.amount,
-                                date_as_string: txn.date_as_string.clone(),
-                                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)),
-                                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)),
-                            };
-
-                            fit_into_lots(
-                                txn_num,
-                                *ar_num,
-                                whole_mvmt,
-                                list_of_lots_to_use,
-                                vec_of_ordered_index_values,
-                                index_position,
-                                &chosen_home_currency,
-                                &ar_map,
-                                &raw_acct_map,
-                                &acct_map,
-                            );
-                            continue
-                        }
-                    }
-                    Polarity::Incoming => {
-                        // println!("Txn: {}, Incoming {:?}-type of {} {}",
-                        //     txn.tx_number, txn.transaction_type(), ar.amount, acct.ticker);
-                        match tx_type {
-                            TxType::Flow => {
-                                let lot: Rc<Lot>;
-                                if raw_acct.is_margin {
-                                    let this_acct = acct_map.get(&ar.account_key).unwrap();
-                                    let lot_list = this_acct.list_of_lots.borrow_mut();
-                                    lot = lot_list.last().unwrap().clone();
-
-                                    let mvmt = Movement {
-                                        amount: ar.amount,
-                                        date_as_string: txn.date_as_string.clone(),
-                                        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)),
-                                        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, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                                    continue
-                                } else {
-                                    let mvmt: Movement;
-                                    if txn.action_record_idx_vec.len() == 1 {
-                                        lot =
-                                        Rc::new(
-                                            Lot {
-                                                date_as_string: txn.date_as_string.clone(),
-                                                date_of_first_mvmt_in_lot: txn.date,
-                                                date_for_basis_purposes: txn.date,
-
-                                                lot_number: length_of_list_of_lots as u32 + 1,
-                                                account_key: acct.raw_key,
-                                                movements: RefCell::new([].to_vec()),
-                                            }
-                                        )
-                                        ;
-                                        mvmt = Movement {
-                                            amount: ar.amount,
-                                            date_as_string: txn.date_as_string.clone(),
-                                            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)),
-                                            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)),
-                                        };
-                                    } else {
-                                        assert_eq!(txn.action_record_idx_vec.len(), 2);
-                                        // create list of incoming/positive amounts(mvmts) in margin lot, add them
-                                        let mut positive_mvmt_list: Vec<Rc<Movement>> = [].to_vec();
-                                        let mut total_positive_amounts = d128!(0);
-
-                                        let (base_acct_key, quote_acct_key) = get_base_and_quote_acct_for_dual_actionrecord_flow_tx(
-                                            txn_num,
-                                            &ar_map,
-                                            &raw_acct_map,
-                                            &acct_map,
-                                            &txns_map,
-                                        )?;
-
-                                        let base_acct = acct_map.get(&base_acct_key).unwrap();
-                                        let base_acct_lot = base_acct.list_of_lots.borrow().last().unwrap().clone();
-                                        //  TODO: generalize this to work with margin shorts as well
-                                        for mvmt in base_acct_lot.movements.borrow().iter() {
-                                            if mvmt.amount > d128!(0) {
-                                                // println!("In lot# {}, positive mvmt amount: {} {},",
-                                                //     base_acct_lot.lot_number,
-                                                //     mvmt.borrow().amount,
-                                                //     base_acct_lot.account.raw.ticker);
-                                                total_positive_amounts += mvmt.amount;
-                                                positive_mvmt_list.push(mvmt.clone())
-                                            }
-                                        }
-                                        let mut amounts_used = d128!(0);
-                                        let mut percentages_used = d128!(0);
-
-                                        for pos_mvmt in positive_mvmt_list.iter().take(positive_mvmt_list.len()-1) {
-                                            let inner_lot =
-                                            Rc::new(
-                                                Lot {
-                                                    date_as_string: txn.date_as_string.clone(),
-                                                    date_of_first_mvmt_in_lot: txn.date,
-                                                    date_for_basis_purposes: pos_mvmt.date,
-                                                    lot_number: acct.list_of_lots.borrow().len() as u32 + 1,
-                                                    account_key: acct.raw_key,
-                                                    movements: RefCell::new([].to_vec()),
-                                                }
-                                            );
-                                            let percentage_used = round_d128_1e8(&(pos_mvmt.amount/&total_positive_amounts));
-                                            let amount_used = round_d128_1e8(&(ar.amount*percentage_used));
-                                            let inner_mvmt = Movement {
-                                                amount: amount_used,
-                                                date_as_string: txn.date_as_string.clone(),
-                                                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: percentage_used,
-                                                ratio_of_amt_to_outgoing_mvmts_in_a_r: Cell::new(d128!(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)),
-                                            };
-                                            wrap_mvmt_and_push(inner_mvmt, &ar, &inner_lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                                            acct.list_of_lots.borrow_mut().push(inner_lot);
-                                            amounts_used += amount_used;
-                                            percentages_used += percentage_used;
-                                        }
-
-                                        let final_mvmt = positive_mvmt_list.last().unwrap();
-                                        lot =
-                                        Rc::new(
-                                            Lot {
-                                                date_as_string: txn.date_as_string.clone(),
-                                                date_of_first_mvmt_in_lot: txn.date,
-                                                date_for_basis_purposes: final_mvmt.date,
-                                                lot_number: acct.list_of_lots.borrow().len() as u32 + 1,
-                                                account_key: acct.raw_key,
-                                                movements: RefCell::new([].to_vec()),
-                                            }
-                                        )
-                                        ;
-                                        mvmt = Movement {
-                                            amount: round_d128_1e8(&(ar.amount - amounts_used)),
-                                            date_as_string: txn.date_as_string.clone(),
-                                            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)),
-                                            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, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                                    acct.list_of_lots.borrow_mut().push(lot);
-                                    continue
-                                }
-                            }
-                            TxType::Exchange => {
-                                let both_are_non_home_curr: bool;
-                                let og_ar = ar_map.get(txn.action_record_idx_vec.first().unwrap()).unwrap();
-                                let og_acct = acct_map.get(&og_ar.account_key).unwrap();
-                                let og_raw_acct = raw_acct_map.get(&og_acct.raw_key).unwrap();
-                                let ic_ar = ar;
-                                let ic_raw_acct = raw_acct;
-                                both_are_non_home_curr = !og_raw_acct.is_home_currency(&chosen_home_currency)
-                                                        && !ic_raw_acct.is_home_currency(&chosen_home_currency);
-
-                                if both_are_non_home_curr && multiple_incoming_mvmts_per_ar && (txn.date <= like_kind_cutoff_date) {
-                                    process_multiple_incoming_lots_and_mvmts(
-                                        txn_num,
-                                        &og_ar,
-                                        &ic_ar,
-                                        &chosen_home_currency,
-                                        *ar_num,
-                                        &raw_acct_map,
-                                        &acct_map,
-                                        &txns_map,
-                                        &ar_map,
-                                    );
-                                    continue
-                                }
-
-                                else {
-                                    let lot =
-                                    Rc::new(
-                                        Lot {
-                                            date_as_string: txn.date_as_string.clone(),
-                                            date_of_first_mvmt_in_lot: txn.date,
-                                            date_for_basis_purposes: txn.date,
-                                            lot_number: length_of_list_of_lots as u32 + 1,
-                                            account_key: acct.raw_key,
-                                            movements: RefCell::new([].to_vec()),
-                                        }
-                                    )
-                                    ;
-                                    let whole_mvmt = Movement {
-                                        amount: ar.amount,
-                                        date_as_string: txn.date_as_string.clone(),
-                                        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)),
-                                        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(whole_mvmt, &ar, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-                                    acct.list_of_lots.borrow_mut().push(lot);
-                                    continue
-                                }
-                            }
-                            TxType::ToSelf => {
-                                if raw_acct.is_margin {
-                                    { println!("\n Found margin actionrecord in toself txn # {} \n", txn.tx_number); use std::process::exit; exit(1) };
-                                } else {
-                                    process_multiple_incoming_lots_and_mvmts(
-                                        txn_num,
-                                        &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,
-                                    );
-                                }
-                                continue
-                            }
-                        }
-                    }
-                }
-            }    //  end for ar in txn.actionrecords
-        }   //  end of tx does not have marginness of TwoARs
-    }   //  end for txn in transactions
-    Ok(txns_map)
-}
-
-/// Chooses the outgoing `ActionRecord`. Gets a `Vec` of its `Movement`s. Chooses its
-/// first/earliest `Movement`. Gets that `Movement`'s `ActionRecord`. Gets that
-/// `ActionRecord`'s `Account`. Gets the first `Lot` from that `Account`'s
-/// `list_of_lots`. Get the `Movement`s from that `Lot`. Takes the first `Movement`
-/// and gets that `Movement`'s `Transaction`. Gets base and quote keys from that.println!
-///
-/// The rationale for this was to be able to determine whether this should be classifiable
-/// as a Long or a Short. As it turns out, the two are basically indistinguishable and/or
-/// interchangeable, so this `fn` should be simplified.
-///
-/// Just kidding.  You weren't paying attention, were you? This is a dual `ActionRecord`
-/// `Flow` `Transaction`, meaning this is most likely recording a margin profit or a
-/// margin loss. The `fn` was designed this was to definitely work for a margin profit,
-/// but it might could use reworking to be generalized for margin profit or loss.
-fn get_base_and_quote_acct_for_dual_actionrecord_flow_tx(
-    txn_num: u32,
-    ar_map: &HashMap<u32, ActionRecord>,
-    raw_acct_map: &HashMap<u16, RawAccount>,
-    acct_map: &HashMap<u16, Account>,
-    txns_map: &HashMap<u32, Transaction>,
-) -> Result<(u16, u16), Box<dyn Error>> {
-
-    let txn = txns_map.get(&txn_num).expect("Couldn't get txn. Tx num invalid?");
-
-    let og_flow_ar = ar_map.get(txn.action_record_idx_vec.first().unwrap()).unwrap();
-
-    let og_ar_mvmts_list = &og_flow_ar.get_mvmts_in_ar_in_lot_date_order(acct_map, txns_map);
-    let og_ar_list_first_mvmt = &og_ar_mvmts_list.first().unwrap(); // TODO: then this takes the one mvmt
-    let og_ar_list_first_mvmt_ar = ar_map.get(&og_ar_list_first_mvmt.action_record_key).unwrap();
-    let og_ar_list_first_mvmt_ar_acct = acct_map.get(&og_ar_list_first_mvmt_ar.account_key).unwrap();
-    let og_mvmt_lot = &og_ar_list_first_mvmt_ar_acct.list_of_lots.borrow()[(og_ar_list_first_mvmt.lot_num - 1) as usize];
-
-    let og_mvmt_lot_mvmts = og_mvmt_lot.movements.borrow();
-    let og_mvmt_lot_first_mvmt = &og_mvmt_lot_mvmts.first().unwrap();
-    let txn_of_og_mvmt_lot_first_mvmt = txns_map.get(&og_mvmt_lot_first_mvmt.transaction_key).unwrap();
-    let (base_key,quote_key) = txn_of_og_mvmt_lot_first_mvmt.get_base_and_quote_raw_acct_keys(
-        ar_map,
-        &raw_acct_map,
-        &acct_map)?; // TODO: should this panic on margin loss? As of 2019-10-02, no. Should test for margin shorting too, though.
-	Ok((base_key, quote_key))
-}
-
-fn get_base_and_quote_ar_idxs(
-    pair_keys: (u16,u16),
-    txn: &Transaction,
-    ars: &HashMap<u32, ActionRecord>,
-    raw_acct_map: &HashMap<u16, RawAccount>,
-    acct_map: &HashMap<u16, Account>
-    ) -> (u32, u32){
-
-    let incoming_ar = ars.get(&txn.action_record_idx_vec[0]).unwrap();
-    let incoming_acct = acct_map.get(&incoming_ar.account_key).unwrap();
-    let raw_ic_acct = raw_acct_map.get(&incoming_acct.raw_key).unwrap();
-    let compare = raw_acct_map.get(&pair_keys.0).unwrap();  //  key.0 is base, and key.1 is quote
-
-    if raw_ic_acct == compare {
-        (txn.action_record_idx_vec[0], txn.action_record_idx_vec[1])
-    } else {
-        (txn.action_record_idx_vec[1], txn.action_record_idx_vec[0])
-    }
-}
-
-fn wrap_mvmt_and_push(
-    this_mvmt: Movement,
-    ar: &ActionRecord,
-    lot: &Lot,
-    chosen_home_currency: &str,
-    raw_acct_map: &HashMap<u16, RawAccount>,
-    acct_map: &HashMap<u16, Account>,
-) {
-
-    let acct = acct_map.get(&ar.account_key).unwrap();
-    let raw_acct = raw_acct_map.get(&acct.raw_key).unwrap();
-
-    if ar.direction() == Polarity::Outgoing && !raw_acct.is_home_currency(chosen_home_currency) {
-        let ratio = this_mvmt.amount / ar.amount;
-        this_mvmt.ratio_of_amt_to_outgoing_mvmts_in_a_r.set(round_d128_1e8(&ratio));
-    }
-
-    let amt = this_mvmt.amount;
-    let amt2 = round_d128_1e8(&amt);
-    assert_eq!(amt, amt2);
-
-    let mvmt = Rc::from(this_mvmt);
-    lot.movements.borrow_mut().push(mvmt.clone());
-    ar.movements.borrow_mut().push(mvmt);
-}
-
-fn fit_into_lots(
-    txn_num: u32,
-    spawning_ar_key: u32,
-    mvmt_to_fit: Movement,
-    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>,
-) {
-
-    let ar = ar_map.get(&spawning_ar_key).unwrap();
-    let acct = acct_map.get(&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 spawning_ar = ar_map.get(&spawning_ar_key).unwrap();
-    let mut current_index_position = index_position;
-
-    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 sum_of_mvmts_in_lot == d128!(0.0) { //  If the lot is "full", go to the next
-        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;
-    }
-    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 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  //  And we're done
-    }
-    //  Note: at this point, we know the movement doesn't fit in a single lot & sum_of_mvmts_in_lot > 0
-    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);
-    let remainder_amt_to_recurse = remainder_amt + sum_of_mvmts_in_lot;
-    // println!("Remainder amount to recurse: {}", remainder_amt_to_recurse);
-    current_index_position += 1;
-    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 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!(current_index_position < vec_of_ordered_index_values.len());
-    fit_into_lots(
-        txn_num,
-        spawning_ar_key,
-        remainder_mvmt_to_recurse,
-        list_of_lots_to_use,
-        vec_of_ordered_index_values,
-        current_index_position,
-        &chosen_home_currency,
-        &ar_map,
-        &raw_acct_map,
-        &acct_map
-    );
-}
-
-fn process_multiple_incoming_lots_and_mvmts(
-    txn_num: u32,
-    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>,
-) {
-
-    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);
-    // 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 final_mvmt = list_of_mvmts_of_outgoing_ar.last().unwrap();
-    //  First iteration, for all but final movement
-    for outgoing_mvmt in list_of_mvmts_of_outgoing_ar
-                            .iter()
-                            .take(outgoing_ar.get_mvmts_in_ar_in_lot_date_order(acct_map, txns_map).len() - 1) {
-        let ratio_of_outgoing_mvmt_to_total_ar = outgoing_mvmt.amount / outgoing_ar.amount; //  Negative divided by negative is positive
-        // 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);
-        // 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));
-        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;
-        let lot =
-        Rc::new(
-            Lot {
-                date_as_string: txn.date_as_string.clone(),
-                date_of_first_mvmt_in_lot: txn.date,
-                date_for_basis_purposes: inherited_date,
-                lot_number: length_of_list_of_lots as u32 + 1,
-                account_key: this_acct.raw_key,
-                movements: RefCell::new([].to_vec()),
-            }
-        )
-        ;
-        let incoming_mvmt = Movement {
-            amount: corresponding_incoming_amt.reduce(),
-            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: round_d128_1e8(&ratio_of_outgoing_mvmt_to_total_ar),
-            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)),
-        };
-        // 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, &lot, &chosen_home_currency, &raw_acct_map, &acct_map);
-        this_acct.list_of_lots.borrow_mut().push(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));
-    let this_acct = acct_of_incoming_ar;
-    let length_of_list_of_lots = this_acct.list_of_lots.borrow().len();
-    let inherited_date = final_mvmt.get_lot(acct_map, ar_map).date_of_first_mvmt_in_lot;
-    let lot =
-    Rc::new(
-        Lot {
-            date_as_string: txn.date_as_string.clone(),
-            date_of_first_mvmt_in_lot: txn.date,
-            date_for_basis_purposes: inherited_date,
-            lot_number: length_of_list_of_lots as u32 + 1,
-            account_key: this_acct.raw_key,
-            movements: RefCell::new([].to_vec()),
-        }
-    )
-    ;
-    let incoming_mvmt = Movement {
-        amount: corresponding_incoming_amt.reduce(),
-        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)),
-        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)),
-    };
-    // 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);
-    this_acct.list_of_lots.borrow_mut().push(lot);
-}

src/crptls_lib/csv_import_accts_txns.rs

@@ -1,264 +0,0 @@
-// Copyright (c) 2017-2019, 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::path::PathBuf;
-
-use chrono::NaiveDate;
-use decimal::d128;
-
-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};
-
-
-pub(crate) fn import_from_csv(
-    import_file_path: PathBuf,
-    settings: &ImportProcessParameters,
-    raw_acct_map: &mut HashMap<u16, RawAccount>,
-    acct_map: &mut HashMap<u16, Account>,
-    action_records: &mut HashMap<u32, ActionRecord>,
-    transactions_map: &mut HashMap<u32, Transaction>,
-) -> Result<(), Box<dyn Error>> {
-
-    let file = File::open(import_file_path)?; println!("\nCSV ledger file opened successfully.\n");
-
-    let mut rdr = csv::ReaderBuilder::new()
-        .has_headers(true)
-        .from_reader(file);
-
-    import_accounts(&mut rdr, raw_acct_map, acct_map)?;
-
-    import_transactions(
-        &mut rdr,
-        settings,
-        action_records,
-        transactions_map,
-    )?;
-
-    Ok(())
-}
-
-fn import_accounts(
-    rdr: &mut csv::Reader<File>,
-    raw_acct_map: &mut HashMap<u16, RawAccount>,
-    acct_map: &mut HashMap<u16, Account>,
-) -> Result<(), Box<dyn Error>> {
-
-    let header1 = rdr.headers()?.clone();   //  account_num
-    let mut header2: Option<csv::StringRecord> = None;  //  name
-    let mut header3: Option<csv::StringRecord> = None;  //  ticker
-    let header4: csv::StringRecord; //  is_margin
-
-    // A StringRecord doesn't accept the same range indexing we need below, so we create our own
-    let mut headerstrings: Vec<String> = Vec::with_capacity(header1.len());
-
-    for element in header1.into_iter() {
-        headerstrings.push(element.to_string())
-    }
-
-    // Account Creation loop.  We set hasheaders() to true above, so the first record here is the second row of the CSV
-    for result in rdr.records() {
-        //  This initial iteration through records will break after the 4th row, after accounts have been created
-        let record = result?;
-        if header2 == None {
-            header2 = Some(record.clone());
-            continue    //  After header2 is set, continue to next record
-        }
-        else if header3 == None {
-            header3 = Some(record.clone());
-            continue    //  After header3 is set, continue to next record
-        }
-        else {
-            header4 = record.clone();
-            // println!("Assigned last header, record: {:?}", record);
-
-            let warn = "FATAL: 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).";
-
-            // We've got all our header rows.  It's now that we set up the accounts.
-            println!("Attempting to create accounts...");
-
-            let mut no_dup_acct_nums = HashMap::new();
-            let length = &headerstrings.len();
-
-            for num in headerstrings[3..*length].iter().enumerate() {
-                let counter = no_dup_acct_nums.entry(num).or_insert(0);
-                *counter += 1;
-            }
-
-            for acct_num in no_dup_acct_nums.keys() {
-                assert_eq!(no_dup_acct_nums[acct_num], 1, "Found accounts with duplicate numbers during import.");
-            }
-
-            for (idx, item) in headerstrings[3..*length].iter().enumerate() {
-
-                // println!("Headerstrings value: {:?}", item);
-                let ind = idx+3; // Add three because the idx skips the first three 'key' columns
-                let account_num = item.parse::<u16>()?;
-                assert_eq!((idx + 1) as u16, account_num, "Found improper Account Number usage: {}", warn);
-
-                let name:String = header2.clone().unwrap()[ind].trim().to_string();
-                let ticker:String = header3.clone().unwrap()[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() {
-                    "no" | "non" | "false" => false,
-                    "yes" | "margin" | "true" => true,
-                    _ => { println!("\n Couldn't parse margin value for acct {} {} \n",account_num, name); process::exit(1) }
-                };
-
-                let just_account: RawAccount = RawAccount {
-                    account_num,
-                    name,
-                    ticker,
-                    is_margin,
-                };
-
-                raw_acct_map.insert(account_num, just_account);
-
-                let account: Account = Account {
-                    raw_key: account_num,
-                    list_of_lots: RefCell::new([].to_vec())
-                };
-
-                acct_map.insert(account_num, account);
-            }
-            break    //  This `break` exits this scope so `accounts` can be accessed in `import_transactions`. The rdr stays put.
-        }
-    };
-    Ok(())
-}
-
-fn import_transactions(
-    rdr: &mut csv::Reader<File>,
-    settings: &ImportProcessParameters,
-    action_records: &mut HashMap<u32, ActionRecord>,
-    txns_map: &mut HashMap<u32, Transaction>,
-) -> Result<(), Box<dyn Error>> {
-
-    let mut this_tx_number = 0;
-    let mut this_ar_number = 0;
-    let mut changed_action_records = 0;
-    let mut changed_txn_num = Vec::new();
-
-    println!("Attempting to create transactions...");
-
-    for result in rdr.records() {
-
-        //  rdr's cursor is at row 5, which is the first transaction row
-        let record = result?;
-        this_tx_number += 1;
-
-        //  First, initialize metadata fields.
-        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.
-        let mut action_records_map_keys_vec: Vec<u32> = Vec::with_capacity(2);
-        let mut outgoing_ar: Option<ActionRecord> = None;
-        let mut incoming_ar: Option<ActionRecord> = None;
-        let mut outgoing_ar_num: Option<u32> = None;
-        let mut incoming_ar_num: Option<u32> = None;
-
-        for (idx, field) in record.iter().enumerate() {
-
-            //  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>()?;
-            }
-            else if idx == 2 { this_memo = field; }
-
-            //  Check for empty strings. If not empty, it's a value for an action_record.
-            else if field != "" {
-                this_ar_number += 1;
-                let ind = idx;  //  starts at 3, which is the fourth field
-                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;
-
-                let amount_str = field.replace(",", "");
-                let amount = amount_str.parse::<d128>().unwrap();
-                let amount_rounded = round_d128_1e8(&amount);
-                if amount != amount_rounded { changed_action_records += 1; changed_txn_num.push(this_tx_number); }
-
-                let action_record = ActionRecord {
-                    account_key,
-                    amount: amount_rounded,
-                    tx_key: this_tx_number,
-                    self_ar_key: this_ar_number,
-                    movements: RefCell::new([].to_vec()),
-                };
-
-                if amount > d128!(0.0) {
-                    incoming_ar = Some(action_record);
-                    incoming_ar_num = Some(this_ar_number);
-                    action_records_map_keys_vec.push(incoming_ar_num.unwrap())
-                } else {
-                    outgoing_ar = Some(action_record);
-                    outgoing_ar_num = Some(this_ar_number);
-                    action_records_map_keys_vec.insert(0, outgoing_ar_num.unwrap())
-                };
-            }
-        }
-
-        if let Some(incoming_ar) = incoming_ar {
-            let x = incoming_ar_num.unwrap();
-            action_records.insert(x, incoming_ar);
-        }
-
-        if let Some(outgoing_ar) = outgoing_ar {
-            let y = outgoing_ar_num.unwrap();
-            action_records.insert(y, outgoing_ar);
-        }
-
-        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 + "%d" + separator + "%m";
-            format_yy = "%y".to_owned() + separator + "%d" + separator + "%m";
-        } else {
-            format_yyyy = "%m".to_owned() + separator + "%d" + separator + "%Y";
-            format_yy = "%m".to_owned() + separator + "%d" + separator + "%y";
-        }
-
-        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")
-        );
-
-        let transaction = Transaction {
-            tx_number: this_tx_number,
-            date_as_string: this_tx_date.to_string(),
-            date: tx_date,
-            user_memo: this_memo.to_string(),
-            proceeds: proceeds_parsed,
-            action_record_idx_vec: action_records_map_keys_vec,
-        };
-
-        txns_map.insert(this_tx_number, transaction);
-    };
-
-    if changed_action_records > 0 {
-        println!("  Changed actionrecord amounts: {}. Changed txn numbers: {:?}.", changed_action_records, changed_txn_num);
-    }
-
-    Ok(())
-}

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(
@@ -66,6 +64,14 @@ pub fn export(
         &transactions_map
     )?;
 
+    export_csv::_7_gain_loss_8949_to_csv(
+        &settings,
+        &raw_acct_map,
+        &account_map,
+        &action_records_map,
+        &transactions_map
+    )?;
+
     export_txt::_1_account_lot_detail_to_txt(
         &settings,
         &raw_acct_map,

src/export/export_csv.rs

@@ -1,16 +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::{Transaction, ActionRecord, Polarity, TxType};
+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(
@@ -46,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() }
 
@@ -55,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() }
         }
@@ -120,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() }
 
@@ -131,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() }
         }
@@ -141,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());
@@ -199,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() }
 
@@ -216,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() }
         }
@@ -311,10 +312,10 @@ 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).to_string();
+            let term = mvmt.get_term(acct_map, ars, txns_map).to_string();
             let mut proceeds_lk = mvmt.proceeds_lk.get();
             let mut cost_basis_lk = mvmt.cost_basis_lk.get();
             let mut gain_loss = mvmt.get_lk_gain_or_loss();
@@ -322,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);
@@ -409,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,
@@ -443,13 +444,13 @@ 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)
                 };
             }
 
-            let term = mvmt.get_term(acct_map, ars);
+            let term = mvmt.get_term(acct_map, ars, txns_map);
 
             if term == Term::LT {
                 amount_lt += mvmt.amount;
@@ -473,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(
@@ -619,10 +620,10 @@ 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).to_string();
+            let term = mvmt.get_term(acct_map, ars, txns_map).to_string();
             let mut proceeds_lk = mvmt.proceeds_lk.get();
             let mut cost_basis_lk = mvmt.cost_basis_lk.get();
             let mut gain_loss = mvmt.get_lk_gain_or_loss();
@@ -632,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);
@@ -679,3 +680,192 @@ pub fn _6_transaction_mvmt_detail_to_csv_w_orig(
 
     Ok(())
 }
+
+pub fn _7_gain_loss_8949_to_csv(
+    settings: &ImportProcessParameters,
+    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 rows: Vec<Vec<String>> = [].to_vec();
+
+    let columns = [
+        "Term".to_string(),
+        "Txn#".to_string(),             // not in 8949; just useful
+        "Description".to_string(),      // auto_memo
+        "Amt in term".to_string(),      // auto_memo amt split by ST/LT
+        "Date Acquired".to_string(),    // lot basis date
+        "Date Sold".to_string(),        // txn date
+        "Proceeds".to_string(),         // txn proceeds (for LT or ST portion only)
+        "Cost basis".to_string(),       // txn cost basis (for LT or ST portion only)
+        "Gain/loss".to_string(),
+    ];
+
+    let total_columns = columns.len();
+    let mut header: Vec<String> = Vec::with_capacity(total_columns);
+    header.extend_from_slice(&columns);
+    rows.push(header);
+
+    let length = txns_map.len();
+
+    for txn_num in 1..=length {
+
+        let txn_num = txn_num as u32;
+        let txn = txns_map.get(&(txn_num)).unwrap();
+        let txn_date_string = txn.date.to_string();
+        let tx_num_string = txn.tx_number.to_string();
+        let tx_memo_string = txn.get_auto_memo(ars,raw_acct_map,acct_map, &settings.home_currency)?;
+
+        let mut term_st: Option<Term> = None;
+        let mut term_lt: Option<Term> = None;
+        let mut ticker: Option<String> = None;
+        let mut polarity: Option<Polarity> = None;
+
+        let mut amount_st = dec!(0);
+        let mut proceeds_st = dec!(0);
+        let mut cost_basis_st = dec!(0);
+
+        let mut expense_st = dec!(0);
+
+        let mut amount_lt = dec!(0);
+        let mut proceeds_lt = dec!(0);
+        let mut cost_basis_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,
+            ars,
+            raw_acct_map,
+            acct_map,
+            txns_map
+        )?;
+
+        let mut purchase_date_lt: NaiveDate = NaiveDate::parse_from_str("1-1-1", "%y-%m-%d").unwrap();
+        let mut purchase_date_st: NaiveDate = NaiveDate::parse_from_str("1-1-1", "%y-%m-%d").unwrap();
+        let mut various_dates_lt: bool = false;
+        let mut various_dates_st: bool = false;
+        let mut lt_set = false;
+        let mut st_set = false;
+        for mvmt in flow_or_outgoing_exchange_movements.iter() {
+            let lot = mvmt.get_lot(acct_map, ars);
+            let acct = acct_map.get(&lot.account_key).unwrap();
+            let raw_acct = raw_acct_map.get(&acct.raw_key).unwrap();
+
+            if ticker.is_none() { ticker = Some(raw_acct.ticker.clone()) };
+
+            if polarity.is_none() {
+                polarity = if mvmt.amount > dec!(0) {
+                    Some(Polarity::Incoming)
+                    } else { Some(Polarity::Outgoing)
+                };
+            }
+
+            fn dates_are_different(existing: &NaiveDate, current: &NaiveDate) -> bool {
+                if existing != current {true} else {false}
+            }
+
+            let term = mvmt.get_term(acct_map, ars, txns_map);
+
+            if term == Term::LT {
+                if lt_set {} else { purchase_date_lt = lot.date_for_basis_purposes; lt_set = true }
+                various_dates_lt = dates_are_different(&purchase_date_lt, &lot.date_for_basis_purposes);
+
+                amount_lt += mvmt.amount;
+                proceeds_lt += mvmt.proceeds_lk.get();
+                cost_basis_lt += mvmt.cost_basis_lk.get();
+
+                if term_lt.is_none() { term_lt = Some(term) }
+
+            } else {
+                if st_set {} else { purchase_date_st = lot.date_for_basis_purposes; st_set = true}
+                various_dates_st = dates_are_different(&purchase_date_st, &lot.date_for_basis_purposes);
+
+                assert_eq!(term, Term::ST);
+                amount_st += mvmt.amount;
+                proceeds_st += mvmt.proceeds_lk.get();
+                cost_basis_st += mvmt.cost_basis_lk.get();
+
+                if term_st.is_none() {
+                    term_st = Some(term);
+                }
+            }
+        }
+        let lt_purchase_date = if various_dates_lt { "Various".to_string() } else { purchase_date_lt.to_string() };
+        let st_purchase_date = if various_dates_st { "Various".to_string() } else { purchase_date_st.to_string() };
+
+        if (txn.transaction_type(
+            ars,
+            &raw_acct_map,
+            &acct_map)? == TxType::Flow
+        ) & (polarity == Some(Polarity::Incoming)) {
+            // 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 = dec!(0);
+                proceeds_lt = -proceeds_lt;   //  Proceeds are negative for incoming txns
+                cost_basis_lt = dec!(0);
+            } else {
+                continue    // Plain, old income isn't reported on form 8949
+            }
+        }
+
+        if (txn.transaction_type(
+            ars,
+            &raw_acct_map,
+            &acct_map)? == TxType::Flow
+        ) & (polarity == Some(Polarity::Outgoing)) {
+            expense_st -= proceeds_st;
+            expense_lt -= proceeds_lt;
+        }
+
+        if let Some(term) = term_st {
+
+            let mut row: Vec<String> = Vec::with_capacity(total_columns);
+
+            row.push(term.abbr_string());
+            row.push(tx_num_string.clone());
+            row.push(tx_memo_string.clone());
+            row.push(amount_st.to_string());
+            row.push(st_purchase_date.clone());
+            row.push(txn_date_string.clone());
+            row.push(proceeds_st.to_string());
+            row.push(cost_basis_st.to_string());
+            row.push((proceeds_st + cost_basis_st).to_string());
+
+            rows.push(row);
+        }
+        if let Some(term) = term_lt {
+
+            let mut row: Vec<String> = Vec::with_capacity(total_columns);
+
+            row.push(term.abbr_string());
+            row.push(tx_num_string);
+            row.push(tx_memo_string);
+            row.push(amount_lt.to_string());
+            row.push(lt_purchase_date.clone());
+            row.push(txn_date_string);
+            row.push(proceeds_lt.to_string());
+            row.push(cost_basis_lt.to_string());
+            row.push((proceeds_lt + cost_basis_lt).to_string());
+
+            rows.push(row);
+        }
+    }
+
+    let file_name = PathBuf::from("C7_Form_8949.csv");
+    let path = PathBuf::from(&settings.export_path);
+
+    let full_path: PathBuf = [path, file_name].iter().collect();
+    let buffer = File::create(full_path).unwrap();
+    let mut wtr = csv::Writer::from_writer(buffer);
+
+    for row in rows.iter() {
+        wtr.write_record(row).expect("Could not write row to CSV file");
+    }
+    wtr.flush().expect("Could not flush Writer, though file should exist and be complete");
+
+    Ok(())
+}

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,13 +124,13 @@ 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)
                 };
             }
 
-            let term = mvmt.get_term(acct_map, ars);
+            let term = mvmt.get_term(acct_map, ars, txns_map);
 
             if term == Term::LT {
                 amount_lt += mvmt.amount;
@@ -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;
                     }
@@ -219,7 +220,7 @@ Enable like-kind treatment: {}",
                     let activity_str = format!("\t    Proceeds: {:>10.2}; Cost basis: {:>10.2}; for Gain/loss: {} {:>10.2}; Inc.: {:>10.2}; Exp.: {:>10.2}.",
                         lk_proceeds.to_string().as_str().parse::<f32>()?,
                         lk_cost_basis.to_string().as_str().parse::<f32>()?,
-                        mvmt.get_term(acct_map, ars),
+                        mvmt.get_term(acct_map, ars, txns_map),
                         gain_loss.to_string().as_str().parse::<f32>()?,
                         income.to_string().as_str().parse::<f32>()?,
                         expense.to_string().as_str().parse::<f32>()?,
@@ -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,56 +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).
-    #[structopt(name = "accept args", short = "a", long = "accept")]
+    /// environment variables (or .env file) or certain command line flags.
+    #[arg(id = "accept args", short, long = "accept")]
     accept_args: bool,
 
-    /// This flag will suppress the printing of "all" reports, except that it *will* trigger the
+    /// 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 import file has been fully processed, the user will be presented
+    /// 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,
 
-    /// This will prevent the program from writing reports to files.
+    /// 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,
 
-    /// File to be imported.  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 environment variables.  See .env.example for
-    /// further details.
-    #[structopt(name = "file", parse(from_os_str))]
+    /// 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.
+    #[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.
+    #[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) 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.
+    #[arg(id = "file_to_import")]
     file_to_import: Option<PathBuf>,
 }
 
@@ -72,10 +89,9 @@ pub struct Cfg {
     /// The default value is `false`, meaning the program will expect default US-style MM-dd-YYYY or MM-dd-YY (or MM/dd/YYYY 
     /// or MM/dd/YY, depending on the date separator option).   
     iso_date: bool,
-    /// Set the corresponding environment variable to "h", "s", or "p" for hyphen, slash, or period (i.e., "-", "/", or ".") 
-    /// to indicate the separator character used in the `Cli::file_to_import` `txDate` column (i.e. 2017/12/31, 2017-12-31, or 2017.12.31).
-    /// The default is `h`.
-    date_separator: String,
+    /// Switches the default date separator from hyphen to slash (i.e., from "-" to "/") to indicate the separator
+    /// character used in the file_to_import txDate column (i.e. 2017-12-31 to 2017/12/31).
+    date_separator_is_slash: bool,
     /// Home currency (currency from the `proceeds` column of the `Cli::file_to_import` and in which all resulting reports are denominated).  
     /// Default is `USD`.
     home_currency: String,
@@ -93,7 +109,7 @@ pub struct Cfg {
 
 fn main() -> Result<(), Box<dyn Error>> {
 
-    let args = Cli::from_args();
+    let args = Cli::parse();
 
     println!(
         "\
@@ -103,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()?;
+    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,
@@ -121,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 {
@@ -149,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,61 +1,75 @@
-// 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 crptls::core_functions::ImportProcessParameters;
+use ratatui::widgets::ListState;
 
-use crate::export_csv;
-use crate::export_txt;
-use crate::export_je;
+use crate::export::{export_csv, export_je, export_txt};
 
-
-pub (crate) const REPORTS: [&'static str; 10] = [
+pub (crate) const REPORTS: [&'static str; 11] = [
     "1. CSV: Account Sums",
     "2. CSV: Account Sums (Non-zero only)",
     "3. CSV: Account Sums (Orig. basis vs like-kind basis)",
     "4. CSV: Transactions by movement (every movement)",
     "5. CSV: Transactions by movement (summarized by long-term/short-term)",
     "6. CSV: Transactions by movement (every movement, w/ orig. and like-kind basis",
-    "7. TXT: Accounts by lot (every movement)",
-    "8. TXT: Accounts by lot (every lot balance)",
-    "9. TXT: Accounts by lot (every non-zero lot balance)",
-    "10. TXT: Bookkeeping journal entries",
+    "7. CSV: Transactions summary by LT/ST for Form 8949",
+    "8. TXT: Accounts by lot (every movement)",
+    "9. TXT: Accounts by lot (every lot balance)",
+    "10. TXT: Accounts by lot (every non-zero lot balance)",
+    "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>,
 }
@@ -63,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()),
         }
@@ -80,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 {
 
@@ -92,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])
@@ -101,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 );
@@ -109,6 +126,7 @@ impl<'a> PrintWindow<'a> {
             }
             _ => {}
         }
+        Ok(())
     }
 
     fn change_vecs_to_chrono_order(vec: &mut Vec<usize>, strvec: &mut Vec<&str>) {
@@ -139,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]);
@@ -194,6 +217,16 @@ pub fn export(
                 )?;
             }
             7 => {
+                export_csv::_7_gain_loss_8949_to_csv(
+                    &settings,
+                    &raw_acct_map,
+                    &account_map,
+                    &action_records_map,
+                    &transactions_map
+                )?;
+            }
+
+            8 => {
                 export_txt::_1_account_lot_detail_to_txt(
                     &settings,
                     &raw_acct_map,
@@ -202,21 +235,21 @@ pub fn export(
                     &transactions_map,
                 )?;
             }
-            8 => {
+            9 => {
                 export_txt::_2_account_lot_summary_to_txt(
                     &settings,
                     &raw_acct_map,
                     &account_map,
                 )?;
             }
-            9 => {
+            10 => {
                 export_txt::_3_account_lot_summary_non_zero_to_txt(
                     &settings,
                     &raw_acct_map,
                     &account_map,
                 )?;
             }
-            10 => {
+            11 => {
                 if !settings.lk_treatment_enabled {
                     export_je::prepare_non_lk_journal_entries(
                         &settings,

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,10 +1,10 @@
-// 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::process;
 use std::env;
+use std::fs::File;
 
 use chrono::NaiveDate;
 use dotenv;
@@ -17,61 +17,85 @@ use crate::skip_wizard;
 use crate::wizard;
 
 
-pub fn get_env() -> Result<super::Cfg, Box<dyn Error>> {
+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.")
     }
 
-    let iso_date: bool = match env::var("ISO_DATE") {
-        Ok(val) => {
-            if val == "1" || val.to_lowercase() == "true" {
-                true
-            } else {
+    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.");
+        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);
+                    true
+                } else {
+                    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).");
                 false
-            }
-        },
-        Err(_e) => false,
+            },
+        }
     };
 
-    let date_separator: String = match env::var("DATE_SEPARATOR") {
-        Ok(val) => {
-            println!("  Found DATE_SEPARATOR env var: {}", val);
-            val.to_lowercase()},
-        Err(_e) => {
-            println!("  Using default date separator (hyphen).");
-            "h".to_string()},
+    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 (\"/\").");
+        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);
+                    true
+                } else {
+                    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 (\"-\").");
+                false
+            },
+        }
     };
 
     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()},
     };
 
     let cfg = super::Cfg {
         iso_date,
-        date_separator,
+        date_separator_is_slash,
         home_currency,
         lk_cutoff_date,
         inv_costing_method,
@@ -88,24 +112,34 @@ 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.as_str() {
-        "h" => { "-" } 
-        "s" => { "/" }
-        "p" => { "." }
-        _ => { println!("\nFATAL: The date-separator arg requires either an 'h', an 's', or a 'p'.\n"); process::exit(1) }
+    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 {
-        Some(file) => file,
-        None => cli_user_choices::choose_file_for_import(cmd_args.accept_args)?
+    let input_file_path = match cmd_args.file_to_import.to_owned() {
+        Some(file) => { 
+            if File::open(&file).is_ok() {
+                file
+            } else {
+                cli_user_choices::choose_file_for_import(cmd_args.accept_args)?
+            }
+        },
+        None => {
+            if !cmd_args.accept_args {
+                wizard::shall_we_proceed()?;
+                println!("Note: No file was provided as a command line arg, or the provided file wasn't found.\n");
+            }
+            cli_user_choices::choose_file_for_import(cmd_args.accept_args)?
+        }
     };
 
     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,
     };
 
@@ -133,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<(
@@ -20,7 +20,8 @@ pub(crate) fn wizard(args: ArgsForImportVarsTBD) -> Result<(
     PathBuf,
 ), Box<dyn Error>> {
 
-    shall_we_proceed()?;
+    println!("\nThe following wizard will guide you through your choices:\n");
+    // shall_we_proceed()?;
 
     let costing_method_choice = cli_user_choices::choose_inventory_costing_method(args.inv_costing_method_arg)?;
 
@@ -39,9 +40,9 @@ pub(crate) fn wizard(args: ArgsForImportVarsTBD) -> Result<(
     Ok((costing_method_choice, like_kind_election, like_kind_cutoff_date_string, should_export, output_dir_path.to_path_buf()))
 }
 
-fn shall_we_proceed() -> Result<(), Box<dyn Error>> {
+pub fn shall_we_proceed() -> Result<(), Box<dyn Error>> {
 
-    println!("Shall we proceed? [Y/n] ");
+    println!("\n  Shall we proceed? [Y/n] ");
 
     _proceed()?;
 
@@ -64,7 +65,7 @@ fn shall_we_proceed() -> Result<(), Box<dyn Error>> {
 
 fn export_reports_to_output_dir(output_dir_path: PathBuf) -> Result<(bool, PathBuf), Box<dyn Error>> {
 
-    println!("\nThe directory currently selected for exporting reports is: {}", output_dir_path.to_str().unwrap());
+    println!("The directory currently selected for exporting reports is: {}", output_dir_path.to_str().unwrap());
 
     if output_dir_path.to_str().unwrap() == "." {
         println!("  (A 'dot' denotes the default value: current working directory.)");