add list command

cash.go

package main
import (
	"log"
	"os"
	"path/filepath"
	"github.com/codegangsta/cli"
)
	APP_VER   = "0.0.0"
)
var (
	LedgerFile  = "general.ledger"
	PendingFile = filepath.Join(os.TempDir(), "pending.ledger")
)
// Initialize the application
func init() {
	if _, err := os.Stat(LedgerFile); os.IsNotExist(err) {
		_, err = os.Create(LedgerFile)
		check(err)
		log.Println("Created ledger file at", LedgerFile)
	}
	if _, err := os.Stat(PendingFile); os.IsNotExist(err) {
		_, err = os.Create(PendingFile)
		check(err)
		log.Println("Created pending file at", PendingFile)
	}
}
// Application entry point
func main() {
	app := cli.NewApp()

clear.go

import (
	"os"
	"path/filepath"
	"github.com/codegangsta/cli"
)
// Command line subcommand for "clear"
var commandClear = cli.Command{
	Name:      "clear",
	ShortName: "",
	Usage:     "",
	Action:    actionClear,
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:  "file",
			Value: "general.ledger",
			Usage: "",
		},
	},
}
// Clear current pending transaction
func actionClear(c *cli.Context) {
	file, err := os.OpenFile(PendingFile, os.O_TRUNC|os.O_WRONLY, 0666)
	pendingFile := filepath.Join(os.TempDir(), c.String("file"))
	ensureFileExists(pendingFile)
	file, err := os.OpenFile(pendingFile, os.O_TRUNC|os.O_WRONLY, 0666)
	check(err)
	defer file.Close()
	_, err = file.Write([]byte{})
	check(err)
}

commit.go

	"errors"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
	"github.com/codegangsta/cli"
)
// Command line subcommand for "commit"
var commandCommit = cli.Command{
	Name:      "commit",
	ShortName: "c",
			Value: time.Now().UTC().Format("2006-01-02"),
			Usage: "",
		},
		cli.StringFlag{
			Name:  "file",
			Value: "general.ledger",
			Usage: "",
		},
	},
}
// Commit the pending transaction
func actionCommit(c *cli.Context) {
	ledgerFile := c.String("file")
	ensureFileExists(ledgerFile)
	pendingFile := filepath.Join(os.TempDir(), c.String("file"))
	ensureFileExists(pendingFile)
	date, err := parseDate(c.String("date"))
	check(err)
	project := parseProject(args)
	description := parseDescription(args, project)
	writeTransaction(date, project, description)
}
// Parse the given string to extract a proper date
func parseDate(in string) (time.Time, error) {
	formats := []string{
		"2006-01-02",
		"2006/01/02",
		"2006-1-2",
		"2006/1/2",
		"01-02-2006",
		"01/02/2006",
		"1-2-2006",
		"1/2/2006",
		"Jan 2, 2006",
		"Jan 02, 2006",
		"2 Jan 2006",
		"02 Jan 2006",
	}
	for _, f := range formats {
		d, err := time.Parse(f, in)
		if err == nil {
			return d, nil
		}
	}
	return time.Now().UTC(), errors.New("No valid date provided")
	writeTransaction(ledgerFile, pendingFile, project, description, date)
	actionClear(c)
}
// Parse a given string to extract a project name
}
// Write a transaction line where there is a pending transaction
func writeTransaction(date time.Time, project, description string) {
	if !hasPendingTransaction() {
func writeTransaction(ledgerFile, pendingFile, project, description string, date time.Time) {
	if !hasPendingTransaction(pendingFile) {
		check(errors.New("No pending transaction to write"))
	}
	pending, err := ioutil.ReadFile(PendingFile)
	pending, err := ioutil.ReadFile(pendingFile)
	check(err)
	t := Transaction{
	err = t.CheckBalance()
	check(err)
	file, err := os.OpenFile(LedgerFile, os.O_APPEND|os.O_WRONLY, 0666)
	file, err := os.OpenFile(ledgerFile, os.O_APPEND|os.O_WRONLY, 0666)
	check(err)
	defer file.Close()
	_, err = file.WriteString(t.ToString())

commandCredit.go

package main
import (
	"os"
	"path/filepath"
	"github.com/codegangsta/cli"
)
// Command line subcommand for "credit"
var commandCredit = cli.Command{
	Name:      "credit",
	ShortName: "cr",
	Usage:     "",
	Action:    actionCredit,
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:  "file",
			Value: "general.ledger",
			Usage: "",
		},
	},
}
// Add a credit to the pending transaction
func actionCredit(c *cli.Context) {
	pendingFile := filepath.Join(os.TempDir(), c.String("file"))
	ensureFileExists(pendingFile)
	args := c.Args()
	name, err := parseAccount(args)
	check(err)
	amount, err := parseValue(args, name)
	check(err)
	a := Account{
		Name:   name,
		Debit:  false,
		Amount: amount,
	}
	f, err := os.OpenFile(pendingFile, os.O_APPEND|os.O_WRONLY, 0666)
	check(err)
	defer f.Close()
	_, err = f.WriteString(a.ToString())
	check(err)
}

commandDebit.go

package main
import (
	"os"
	"path/filepath"
	"github.com/codegangsta/cli"
)
// Command line subcommand for "debit"
var commandDebit = cli.Command{
	Name:      "debit",
	ShortName: "dr",
	Usage:     "",
	Action:    actionDebit,
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:  "file",
			Value: "general.ledger",
			Usage: "",
		},
	},
}
// Add a debit to the pending transaction
func actionDebit(c *cli.Context) {
	pendingFile := filepath.Join(os.TempDir(), c.String("file"))
	ensureFileExists(pendingFile)
	args := c.Args()
	name, err := parseAccount(args)
	check(err)
	amount, err := parseValue(args, name)
	check(err)
	a := Account{
		Name:   name,
		Debit:  true,
		Amount: amount,
	}
	f, err := os.OpenFile(pendingFile, os.O_APPEND|os.O_WRONLY, 0666)
	check(err)
	defer f.Close()
	_, err = f.WriteString(a.ToString())
	check(err)
}

commandList.go

package main
import (
	"bufio"
	"bytes"
	"fmt"
	"os"
	"github.com/codegangsta/cli"
)
// Command line subcommand for "list"
var commandList = cli.Command{
	Name:      "list",
	ShortName: "ls",
	Usage:     "",
	Action:    actionList,
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:  "file",
			Value: "general.ledger",
			Usage: "",
		},
		cli.StringFlag{
			Name:  "project",
			Value: "",
			Usage: "",
		},
		cli.StringFlag{
			Name:  "sort",
			Value: "account",
			Usage: "",
		},
		cli.BoolFlag{
			Name:  "asc",
			Usage: "",
		},
	},
}
// List the ledger contents
func actionList(c *cli.Context) {
	ledgerFile := c.String("file")
	ensureFileExists(ledgerFile)
	f, err := os.Open(ledgerFile)
	check(err)
	defer f.Close()
	l := Ledger{}
	scanner := bufio.NewScanner(f)
	scanner.Split(ScanTransactions)
	for scanner.Scan() {
		text := scanner.Text()
		t := Transaction{}
		t.FromString(text)
		l.Transactions = append(l.Transactions, t)
	}
	fmt.Print(l.ToString())
}
// ScanTransactions is a split function for a Scanner that returns each line of
// text, stripped of any trailing end-of-line marker. The returned line may be
// empty. The end-of-line marker is one optional carriage return followed
// by one mandatory newline. In regular expression notation, it is `\r\n`.
// The last non-empty line of input will be returned even if it has no newline.
//
// source: https://golang.org/src/bufio/scan.go
func ScanTransactions(data []byte, atEOF bool) (advance int, token []byte, err error) {
	if atEOF && len(data) == 0 {
		return 0, nil, nil
	}
	if i := bytes.Index(data, []byte("\n\n")); i >= 0 {
		// We have a double newline terminated line
		return i + 2, dropCR(data[0:i]), nil
	}
	// If we're at EOF, we have a final, non-terminated line. Return it
	if atEOF {
		return len(data), dropCR(data), nil
	}
	// Request more data
	return 0, nil, nil
}
// dropCR drops a terminal \r from the data
// source: https://golang.org/src/bufio/scan.go
func dropCR(data []byte) []byte {
	if len(data) > 0 && data[len(data)-1] == '\r' {
		return data[0 : len(data)-1]
	}
	return data
}

status.go

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"github.com/codegangsta/cli"
)
// Command line subcommand for "status"
var commandStatus = cli.Command{
	Name:      "status",
	ShortName: "stat",
	Usage:     "",
	Action:    actionStatus,
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:  "file",
			Value: "general.ledger",
			Usage: "",
		},
	},
}
// Display the current status of the ledger
func actionStatus(c *cli.Context) {
	if hasPendingTransaction() {
		pending, err := ioutil.ReadFile(PendingFile)
	pendingFile := filepath.Join(os.TempDir(), c.String("file"))
	ensureFileExists(pendingFile)
	if hasPendingTransaction(pendingFile) {
		pending, err := ioutil.ReadFile(pendingFile)
		check(err)
		fmt.Println(string(pending))
	} else {

credit.go

package main
import (
	"fmt"
	"os"
	"github.com/codegangsta/cli"
)
var commandCredit = cli.Command{
	Name:      "credit",
	ShortName: "cr",
	Usage:     "",
	Action:    actionCredit,
}
// Add a credit to the pending transaction
func actionCredit(c *cli.Context) {
	args := c.Args()
	account, err := parseAccount(args)
	check(err)
	value, err := parseValue(args, account)
	check(err)
	f, err := os.OpenFile(PendingFile, os.O_APPEND|os.O_WRONLY, 0666)
	check(err)
	defer f.Close()
	_, err = f.WriteString(fmt.Sprintf("\t%s\t-%s\n", account, value.FloatString(2)))
	check(err)
}

debit.go

package main
import (
	"fmt"
	"os"
	"github.com/codegangsta/cli"
)
var commandDebit = cli.Command{
	Name:      "debit",
	ShortName: "dr",
	Usage:     "",
	Action:    actionDebit,
}
// Add a debit to the pending transaction
func actionDebit(c *cli.Context) {
	args := c.Args()
	account, err := parseAccount(args)
	check(err)
	value, err := parseValue(args, account)
	check(err)
	f, err := os.OpenFile(PendingFile, os.O_APPEND|os.O_WRONLY, 0666)
	check(err)
	defer f.Close()
	_, err = f.WriteString(fmt.Sprintf("\t%s\t+%s\n", account, value.FloatString(2)))
	check(err)
}

helpers.go

	"math/big"
	"os"
	"strings"
	"time"
)
// Helper function to check for fatal errors
	}
}
func ensureFileExists(fileName string) {
	if _, err := os.Stat(fileName); os.IsNotExist(err) {
		_, err = os.Create(fileName)
		check(err)
	}
}
// Format the ledger so it is human readable
func formatLedger() {
}
// Determines if there is currently a pending transaction in the ledger
func hasPendingTransaction() bool {
	file, err := os.Open(PendingFile)
func hasPendingTransaction(pendingFile string) bool {
	file, err := os.Open(pendingFile)
	check(err)
	defer file.Close()
	return fields[0], nil
}
// Parse the given string to extract a proper date
func parseDate(in string) (time.Time, error) {
	formats := []string{
		"2006-01-02",
		"2006/01/02",
		"2006-1-2",
		"2006/1/2",
		"01-02-2006",
		"01/02/2006",
		"1-2-2006",
		"1/2/2006",
		"Jan 2, 2006",
		"Jan 02, 2006",
		"2 Jan 2006",
		"02 Jan 2006",
	}
	for _, f := range formats {
		d, err := time.Parse(f, in)
		if err == nil {
			return d, nil
		}
	}
	return time.Now().UTC(), errors.New("No valid date provided")
}
// Parse the value from the arguments
func parseValue(fields []string, account string) (*big.Rat, error) {
	r := new(big.Rat)

ledger.go

package main
import (
	"fmt"
	"math/big"
	"sort"
)
type Ledger struct {
	Transactions []Transaction
}
func (l *Ledger) ToString() string {
	balance := make(map[string]*big.Rat)
	for _, t := range l.Transactions {
		err := t.CheckBalance()
		check(err)
		for _, a := range t.Accounts {
			if b, ok := balance[a.Name]; ok {
				if a.Debit {
					b.Add(b, a.Amount)
				} else {
					b.Sub(b, a.Amount)
				}
			} else {
				if a.Debit {
					balance[a.Name] = a.Amount
				} else {
					neg := new(big.Rat)
					neg.SetInt64(-1)
					balance[a.Name] = a.Amount.Mul(a.Amount, neg)
				}
			}
		}
	}
	keys := make([]string, len(balance))
	i := 0
	for k := range balance {
		keys[i] = k
		i++
	}
	sort.Strings(keys)
	boom := ""
	for _, key := range keys {
		boom += fmt.Sprintf("%s\t\t%s\n", key, balance[key].FloatString(2))
	}
	return boom
}

list.go

package main
import "github.com/codegangsta/cli"
var commandList = cli.Command{
	Name:      "list",
	ShortName: "ls",
	Usage:     "",
	Action:    actionList,
}
// List the ledger contents
func actionList(c *cli.Context) {
}

transaction.go

	// Parse the lines of text
	lines := strings.Split(text, "\n")
	for i, line := range lines {
		if len(line) == 0 {
			continue
		}
		switch i {
		case 0:
			fields := strings.Split(line, "\t")
				description = strings.Join(fields[2:], " ")
			}
			t = &Transaction{
				Date:        date,
				Project:     project,
				Description: description,
				Accounts:    []Account{},
			}
			t.Date = date
			t.Project = project
			t.Description = description
			t.Accounts = []Account{}
			break
		default:
			var account Account
			err := account.FromString(line)
			var a Account
			err := a.FromString(line)
			check(err)
			t.Accounts = append(t.Accounts, account)
			t.Accounts = append(t.Accounts, a)
			break
		}
	}
		accounts += account.ToString()
	}
	return fmt.Sprintf("%s\t%s\t%s\n%s\n", t.Date.Format("2006-01-02"), t.Project, t.Description, string(accounts))
	err := t.CheckBalance()
	if err != nil {
		accounts += fmt.Sprintf("Error: %s\n", err)
	}
	return fmt.Sprintf("%s\t%s\t%s\n%s\n", t.Date.Format("2006-01-02"), t.Project, t.Description, accounts)
}