register: aggregation by tags or payee

Author: mkobetic

.vscode/settings.json

@@ -14,6 +14,9 @@
   },
   "files.insertFinalNewline": true,
   "files.trimFinalNewlines": true,
-  "files.trimTrailingWhitespace": true,
-  "makefile.configureOnOpen": false
+  "files.trimTrailingWhitespace": false, // breaks test files
+  "makefile.configureOnOpen": false,
+  "[go]": {
+    "editor.defaultFormatter": "golang.go"
+  }
 }

TODO.md

@@ -1,5 +1,6 @@
 ### Features
 
+- register: aggregate by tags, payee, etc
 - thousand separator in amounts
 - check for account/cc numbers in transactions
 - balance: last reconciled posting date
@@ -24,8 +25,9 @@
 
 ### coin2html
 
-- update user docs in README (details, balances, screenshots ...)
 - allow dropping subaccounts from aggregations (in both chart and register)
+- show reconciliation state in balance view (last reconciled date? vs balance date?)
+- show reconciliation flag in non-aggregated register
 - filter subaccounts, payee, tag...
 - brush to select date range
 - buttons to reset To/From to Min/Max date
@@ -35,6 +37,7 @@
 - tooltips for columns, inputs and wherever useful
 - preserve UI state in history (make back/forward buttons work)
 - trim to time range on export (need to recalc posting balances!)
+- trim to account subtree (need to recalc outer posting balances!)
 - show commodities and prices
 - investment performance summary
 

cmd/coin/register.go

@@ -40,7 +40,7 @@ func (*cmdRegister) newCommand(names ...string) command {
 
 Lists or aggregate postings from the specified account.`)
 	cmd.BoolVar(&cmd.verbose, "v", false, "log debug info to stderr")
-	cmd.BoolVar(&cmd.recurse, "r", false, "include subaccount postings in parent accounts")
+	cmd.BoolVar(&cmd.recurse, "r", false, "include sub-account postings in parent accounts")
 	// filtering options
 	cmd.Var(&cmd.begin, "b", "begin register from this date")
 	cmd.Var(&cmd.end, "e", "end register on this date")
@@ -51,7 +51,7 @@ Lists or aggregate postings from the specified account.`)
 	cmd.BoolVar(&cmd.monthly, "m", false, "aggregate postings by month")
 	cmd.BoolVar(&cmd.quarterly, "q", false, "aggregate postings by quarter")
 	cmd.BoolVar(&cmd.yearly, "y", false, "aggregate postings by year")
-	cmd.IntVar(&cmd.top, "g", 5, "include this many largest subaccounts in aggregate results")
+	cmd.IntVar(&cmd.top, "g", 5, "include this many largest sub-accounts in aggregate results")
 	cmd.BoolVar(&cmd.cumulative, "c", false, "aggregate cumulatively across time")
 	// output options
 	cmd.IntVar(&cmd.maxLabelWidth, "l", 12, "maximum width of a column label")
@@ -73,92 +73,59 @@ func (cmd *cmdRegister) execute(f io.Writer) {
 		fmt.Fprintln(f, acc.FullName, acc.Commodity.Id)
 	}
 	if by := cmd.period(); by != nil {
-		if cmd.recurse {
-			cmd.recursiveAggregatedRegister(f, acc, by)
-		} else {
-			cmd.flatAggregatedRegister(f, acc, by)
-		}
+		cmd.aggregatedRegister(f, acc, by)
 	} else {
-		var opts = options{
-			prefix:    acc.FullName,
-			maxAcct:   cmd.maxLabelWidth,
-			location:  cmd.location,
-			commodity: acc.Commodity,
-			showNotes: cmd.showNotes,
-		}
-		if cmd.recurse {
-			var ps postings
-			acc.WithChildrenDo(func(a *coin.Account) {
-				ps = append(ps, cmd.trim(a.Postings)...)
-			})
-			sort.SliceStable(ps, func(i, j int) bool {
-				return ps[i].Transaction.Posted.Before(ps[j].Transaction.Posted)
-			})
-			ps.printLong(f, &opts)
-		} else {
-			cmd.trim(acc.Postings).print(f, &opts)
-		}
+		cmd.fullRegister(f, acc)
 	}
 }
 
-func (cmd *cmdRegister) flatAggregatedRegister(f io.Writer, acc *coin.Account, by *reducer) {
-	totals := accountTotals{}
-	acc.WithChildrenDo(func(a *coin.Account) {
-		ts := totals.newTotals(a, by)
-		for _, p := range cmd.trim(a.Postings) {
-			ts.add(p.Transaction.Posted, p.Quantity)
-		}
-	})
-	var accounts []*coin.Account
-	totals, accounts = totals.top(cmd.top)
-	top := totals[accounts[0]]
-	for _, ts := range totals {
-		top.mergeTime(ts)
-	}
-	totals.mergeTime(top)
-	if cmd.cumulative {
-		totals.makeCumulative()
+func (cmd *cmdRegister) fullRegister(f io.Writer, acc *coin.Account) {
+	var opts = options{
+		prefix:    acc.FullName,
+		maxAcct:   cmd.maxLabelWidth,
+		location:  cmd.location,
+		commodity: acc.Commodity,
+		showNotes: cmd.showNotes,
 	}
-	label := func(a *coin.Account) string {
-		switch a {
-		case nil:
-			return "Other"
-		case acc:
-			return acc.Name
-		default:
-			n := strings.TrimPrefix(a.FullName, acc.FullName)
-			return coin.ShortenAccountName(n, cmd.maxLabelWidth)
-		}
+	if cmd.recurse {
+		var ps postings
+		acc.WithChildrenDo(func(a *coin.Account) {
+			ps = append(ps, cmd.trim(a.Postings)...)
+		})
+		sort.SliceStable(ps, func(i, j int) bool {
+			return ps[i].Transaction.Posted.Before(ps[j].Transaction.Posted)
+		})
+		ps.printLong(f, &opts)
+	} else {
+		cmd.trim(acc.Postings).print(f, &opts)
 	}
-	totals.output(f, accounts, label, cmd.output)
 }
 
-func (cmd *cmdRegister) recursiveAggregatedRegister(f io.Writer, acc *coin.Account, by *reducer) {
+func (cmd *cmdRegister) aggregatedRegister(f io.Writer, acc *coin.Account, by *timeReducer) {
 	totals := accountTotals{}
 	acc.WithChildrenDo(func(a *coin.Account) {
 		ts := totals.newTotals(a, by)
 		for _, p := range cmd.trim(a.Postings) {
-			ts.add(p.Transaction.Posted, p.Quantity)
+			ts.add(p)
 		}
 	})
-	if cmd.recurse {
-		acc.FirstWithChildrenDo(func(a *coin.Account) {
-			child := totals[a]
-			parent := totals[a.Parent]
-			if parent != nil {
+	// Propagate timelines and possibly amounts up top
+	acc.FirstWithChildrenDo(func(a *coin.Account) {
+		child := totals[a]
+		parent := totals[a.Parent]
+		if parent != nil {
+			if cmd.recurse {
 				parent.merge(child)
+			} else {
+				parent.mergeTime(child)
 			}
-		})
-	}
+		}
+	})
 	totals.sanitize()
-	accTotals := totals[acc]
-	check.If(accTotals != nil, "root account totals shouldn't be empty\n")
-	delete(totals, acc)
 	var accounts []*coin.Account
 	totals, accounts = totals.top(cmd.top)
-	totals.mergeTime(accTotals)
-	totals[acc] = accTotals
-	accounts = append(accounts, acc)
+	totals.mergeTime(totals[acc])
+
 	if cmd.cumulative {
 		totals.makeCumulative()
 	}
@@ -167,7 +134,7 @@ func (cmd *cmdRegister) recursiveAggregatedRegister(f io.Writer, acc *coin.Accou
 		case nil:
 			return "Other"
 		case acc:
-			return "Totals"
+			return acc.Name
 		default:
 			n := strings.TrimPrefix(a.FullName, acc.FullName)
 			return coin.ShortenAccountName(n, cmd.maxLabelWidth)
@@ -176,7 +143,7 @@ func (cmd *cmdRegister) recursiveAggregatedRegister(f io.Writer, acc *coin.Accou
 	totals.output(f, accounts, label, cmd.output)
 }
 
-func (cmd *cmdRegister) period() *reducer {
+func (cmd *cmdRegister) period() *timeReducer {
 	switch {
 	case cmd.weekly:
 		return &week

cmd/coin/test.go

@@ -6,9 +6,12 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path"
+	"strconv"
 	"strings"
 
 	"github.com/mkobetic/coin"
+	"github.com/mkobetic/coin/check"
 	"github.com/pmezard/go-difflib/difflib"
 )
 
@@ -26,10 +29,10 @@ func (*cmdTest) newCommand(names ...string) command {
 	cmd.FlagSet = newCommand(&cmd, names...)
 	setUsage(cmd.FlagSet, `(test|t)
 
-Execute any test clauses found in the ledger (see tests/ directory).`)
+Execute any test clauses found in the ledger (see tests/ directory).
+If test result is empty, updates the test file with computed result.`)
 	cmd.BoolVar(&cmd.verbose, "v", false, "print OK result for every test, not just for each file")
 	return &cmd
-
 }
 
 func (cmd *cmdTest) init() {
@@ -42,8 +45,22 @@ func (cmd *cmdTest) execute(f io.Writer) {
 		return
 	}
 	lastTestFile := file(coin.Tests[0])
+	var toUpdate []*coin.Test
 	success := true
 	for _, t := range coin.Tests {
+		// assume the tests are sorted file by file
+		// and in the order they are in the file
+		testFile := file(t)
+		startingNewFile := testFile != lastTestFile
+		var oldTestFile string // this is set only when moving to new file
+		if startingNewFile {
+			oldTestFile = lastTestFile
+		}
+		lastTestFile = testFile
+		if startingNewFile && len(toUpdate) > 0 {
+			updateTestFile(toUpdate)
+			toUpdate = nil
+		}
 		var args []string
 		scanner := bufio.NewScanner(strings.NewReader(t.Cmd))
 		scanner.Split(bufio.ScanWords)
@@ -69,14 +86,19 @@ func (cmd *cmdTest) execute(f io.Writer) {
 		}
 		var b bytes.Buffer
 		command.execute(&b)
+		// If the test result is empty, update the test file
+		// once we collect all the tests to be updated
+		if len(t.Result) == 0 {
+			t.Result = b.Bytes()
+			toUpdate = append(toUpdate, t)
+			continue
+		}
 		if bytes.Equal(b.Bytes(), t.Result) {
-			testFile := file(t)
 			if cmd.verbose {
 				fmt.Fprintf(f, "OK %s %s\n", t.Location(), t.Cmd)
-			} else if lastTestFile != testFile {
-				fmt.Fprintf(f, "OK %s\n", lastTestFile)
+			} else if oldTestFile != "" {
+				fmt.Fprintf(f, "OK %s\n", oldTestFile)
 			}
-			lastTestFile = testFile
 			continue
 		}
 		success = false
@@ -90,6 +112,9 @@ func (cmd *cmdTest) execute(f io.Writer) {
 				Context:  3,
 			})
 	}
+	if len(toUpdate) > 0 {
+		updateTestFile(toUpdate)
+	}
 	if !cmd.verbose {
 		result := "OK"
 		if !success {
@@ -103,3 +128,47 @@ func file(t *coin.Test) string {
 	file, _, _ := strings.Cut(t.Location(), ":")
 	return file
 }
+
+// assume ts are tests from the same file in the order in which they are in the file,
+// and all test have empty result in the file,
+// then write the results from the test commands into the file.
+func updateTestFile(ts []*coin.Test) {
+	fn := file(ts[0])
+	tf, err := os.CreateTemp(path.Dir(fn), path.Base(fn))
+	check.NoError(err, "creating temp file")
+	// read file fn by lines up to line
+	// write the lines into tf
+	of, err := os.Open(fn)
+	check.NoError(err, "opening old file")
+	defer of.Close()
+
+	scanner := bufio.NewScanner(of)
+	writer := bufio.NewWriter(tf)
+	line := 0
+	for i, t := range ts {
+		_, ln, _ := strings.Cut(t.Location(), ":")
+		tLine, _ := strconv.Atoi(ln)
+
+		for ; line < tLine && scanner.Scan(); line++ {
+			_, err := writer.Write(scanner.Bytes())
+			check.NoError(err, "writing prefix %d", i)
+			check.NoError(writer.WriteByte('\n'), "writing prefix %d", i)
+		}
+		check.NoError(scanner.Err(), "writing prefix %d", i)
+		_, err = writer.Write(t.Result)
+		check.NoError(err, "writing result %d", i)
+		fmt.Fprintf(os.Stderr, "UPDATED %s %s\n", t.Location(), t.Cmd)
+	}
+	// finish writing rest of the old file
+	for scanner.Scan() {
+		_, err := writer.Write(scanner.Bytes())
+		check.NoError(err, "writing trailer")
+		check.NoError(writer.WriteByte('\n'), "writing trailer")
+	}
+	check.NoError(scanner.Err(), "writing trailer")
+	check.NoError(of.Close(), "closing old file")
+	check.NoError(writer.Flush(), "flushing writer")
+	check.NoError(tf.Close(), "closing temp file")
+	check.NoError(os.Remove(fn), "deleting old file")
+	check.NoError(os.Rename(tf.Name(), fn), "renaming temp file %s to %s", tf.Name(), fn)
+}