pretty print vs cumulative

cmd/cli/config.go

@@ -7,5 +7,7 @@ type Config struct {
 		Sort         string
 		NoRounding   bool
 		Depth        int
+		Reverse      bool
+		NoExchanging bool
 	}
 }

cmd/cli/main.go

@@ -19,6 +19,8 @@ func Main() {
 	fs.StringVar(&config.Query.Sort, "S", "", "sort ie date")
 	fs.BoolVar(&config.Query.NoRounding, "no-rounding", false, "no rounding")
 	fs.IntVar(&config.Query.Depth, "depth", 0, "depth grouping")
+	fs.BoolVar(&config.Query.Reverse, "r", false, "reverse printed accounts")
+	fs.BoolVar(&config.Query.NoExchanging, "no-exchanging", true, "omit currency exchanges")
 	if err := fs.Parse(os.Args[1:]); err != nil {
 		panic(err)
 	}
@@ -86,33 +88,50 @@ func Main() {
 			balances = balances.NotLike(notLikePattern)
 		}
 
-		FPrintBalances(os.Stdout, balances)
+		FPrintBalances(os.Stdout, "", balances, nil)
 	case "reg":
-		register := deltas.Register()
+		transactions := deltas.Transactions()
+		likes := []ledger.Like{}
 		if likePattern != "" {
-			register = register.Like(likePattern)
+			like := ledger.LikeName(likePattern)
+			transactions = transactions.Like(like)
+			if config.Query.Reverse {
+				like = ledger.LikeNot(like)
+			}
+			likes = append(likes, like)
 		}
 		if notLikePattern != "" {
-			register = register.NotLike(notLikePattern)
+			like := ledger.NotLikeName(notLikePattern)
+			transactions = transactions.NotLike(like)
+			if config.Query.Reverse {
+				like = ledger.LikeNot(like)
+			}
+			likes = append(likes, like)
 		}
 
-		var prev ledger.Balances
+		for i, transaction := range transactions {
-		for _, date := range register.Dates() {
+			balances := ledger.Deltas(transaction).Like(likes...).Balances()
-			balances := register[date]
+			shouldPrint := false
-
+			shouldPrint = shouldPrint || len(balances) > 2
-			if newBalances := balances.Sub(prev).Nonzero(); len(newBalances) > 0 {
+			if config.Query.NoExchanging {
-				fmt.Println(date)
+				shouldPrint = shouldPrint || len(balances) > 1
-				FPrintBalances(os.Stdout, newBalances)
+				for _, v := range balances {
+					shouldPrint = shouldPrint || len(v) == 1
+				}
+			} else {
+				shouldPrint = shouldPrint || len(balances) > 0
+			}
+			if shouldPrint {
+				fmt.Printf("%s\t%s\n", transaction[0].Date, transaction[0].Description)
+				FPrintBalances(os.Stdout, "\t\t", balances, transactions[:i+1].Deltas().Like(likes...).Balances())
 			}
-
-			prev = balances
 		}
 	default:
 		panic("unknown command " + positional[0])
 	}
 }
 
-func FPrintBalances(w io.Writer, balances ledger.Balances) {
+func FPrintBalances(w io.Writer, linePrefix string, balances, cumulatives ledger.Balances) {
 	keys := []string{}
 	for k := range balances {
 		keys = append(keys, k)
@@ -126,7 +145,7 @@ func FPrintBalances(w io.Writer, balances ledger.Balances) {
 		}
 	}
 
-	format := fmt.Sprintf("%%-%ds\t%%s%%.2f\n", max)
+	format := fmt.Sprintf("%s%%-%ds\t%%s%%.2f (%%s%%.2f)\n", linePrefix, max)
 	for _, key := range keys {
 		currencies := []ledger.Currency{}
 		for currency := range balances[key] {
@@ -139,7 +158,15 @@ func FPrintBalances(w io.Writer, balances ledger.Balances) {
 			if printableCurrency != "$" {
 				printableCurrency += " "
 			}
-			fmt.Fprintf(w, format, key, printableCurrency, balances[key][currency])
+
+			cumulative := balances[key][currency]
+			if balance, ok := cumulatives[key]; !ok {
+			} else if value, ok := balance[currency]; !ok {
+			} else {
+				cumulative = value
+			}
+
+			fmt.Fprintf(w, format, key, printableCurrency, balances[key][currency], printableCurrency, cumulative)
 		}
 	}
 }

src/ledger/like.go

@@ -41,6 +41,16 @@ func LikeNotName(pattern string) Like {
 	}
 }
 
+func LikeNot(like Like) Like {
+	return func(d Delta) bool {
+		return !like(d)
+	}
+}
+
+func NotLikeName(pattern string) Like {
+	return LikeNot(LikeName(pattern))
+}
+
 func LikeName(pattern string) Like {
 	return func(d Delta) bool {
 		return like(pattern, d.Name)

src/ledger/transaction.go

@@ -18,6 +18,14 @@ type Transaction Deltas
 
 type Transactions []Transaction
 
+func (transactions Transactions) Deltas() Deltas {
+	result := make(Deltas, 0, len(transactions))
+	for _, transaction := range transactions {
+		result = append(result, transaction...)
+	}
+	return result
+}
+
 func (deltas Deltas) Transactions() Transactions {
 	m := make(map[string]Transaction)
 	for _, d := range deltas {
@@ -42,6 +50,26 @@ func (deltas Deltas) Transactions() Transactions {
 	return result
 }
 
+func (transactions Transactions) NotLike(like ...Like) Transactions {
+	result := make(Transactions, 0, len(transactions))
+	for _, transaction := range transactions {
+		if matching := (Deltas)(transaction).Like(like...); len(matching) == 0 {
+			result = append(result, transaction)
+		}
+	}
+	return result
+}
+
+func (transactions Transactions) Like(like ...Like) Transactions {
+	result := make(Transactions, 0, len(transactions))
+	for _, transaction := range transactions {
+		if matching := (Deltas)(transaction).Like(like...); len(matching) > 0 {
+			result = append(result, transaction)
+		}
+	}
+	return result
+}
+
 func (transaction Transaction) Payee() string {
 	balances := Deltas(transaction).Balances()