basic transaction check to make sure it balances prior to commit

commit.go

	"errors"
	"fmt"
	"io/ioutil"
	"math/big"
	"os"
	"strings"
	"time"
	project := parseProject(args)
	description := parseDescription(args, project)
	writeTransaction(date, project, description)
	writeTransaction(date.Format("2006-01-02"), project, description)
}
// Parse the given string to extract a proper date
func parseDate(in string) (string, error) {
func parseDate(in string) (time.Time, error) {
	formats := []string{
		"2006-01-02",
		"2006/01/02",
	for _, f := range formats {
		d, err := time.Parse(f, in)
		if err == nil {
			return d.Format(formats[0]), nil
			return d, nil
		}
	}
	return "", errors.New("No valid date provided")
	return time.Now().UTC(), errors.New("No valid date provided")
}
// Parse a given string to extract a project name
	return strings.Replace(strings.Join(fields, " "), "  ", " ", -1)
}
type Account struct {
	Name   string
	Debit  bool
	Amount *big.Rat
}
type Transaction struct {
	Date        time.Time
	Project     string
	Description string
	Accounts    []Account
}
func (t *Transaction) FromString(text string) error {
	// Parse the lines of text
	lines := strings.Split(text, "\n")
	for i, line := range lines {
		fields := strings.Split(line, "\t")
		switch i {
		case 0:
			date, err := parseDate(fields[0])
			check(err)
			project := fields[1]
			description := ""
			if len(fields) > 2 {
				description = strings.Join(fields[2:], " ")
			}
			t = &Transaction{
				Date:        date,
				Project:     project,
				Description: description,
				Accounts:    []Account{},
			}
			break
		default:
			if len(fields) != 3 {
				break
			}
			account := fields[0]
			debit := true
			if strings.HasPrefix(fields[1], "-") {
				debit = false
			}
			value := new(big.Rat)
			value.SetString(fields[1][1:])
			t.Accounts = append(
				t.Accounts,
				Account{
					Name:   account,
					Debit:  debit,
					Amount: value,
				})
			break
		}
	}
	// Check that they balance
	balance := new(big.Rat)
	for _, a := range t.Accounts {
		balance.Add(balance, a.Amount)
	}
	if balance.FloatString(2) != "0.00" {
		return errors.New("Transaction does not balance")
	}
	return nil
}
// Write a transaction line where there is a pending transaction
func writeTransaction(date, project, description string) {
	if !hasPendingTransaction() {
	pending, err := ioutil.ReadFile(PendingFile)
	check(err)
	// Find the line containing @pending and replace it with our transaction
	s := fmt.Sprintf("%s\t%s\t%s\n%s\n", date, project, description, string(pending))
	var t Transaction
	err = t.FromString(s)
	check(err)
	file, err := os.OpenFile(Ledger, os.O_APPEND|os.O_WRONLY, 0666)
	check(err)
	defer file.Close()
	// Find the line containing @pending and replace it with our transaction
	transaction := fmt.Sprintf("%s\t%s\t%s\n%s\n", date, project, description, pending)
	_, err = file.WriteString(transaction)
	_, err = file.WriteString(s)
	check(err)
}

credit.go

	check(err)
	defer f.Close()
	_, err = f.WriteString(fmt.Sprintf("\t%s\t+%s\n", account, value.FloatString(2)))
	_, err = f.WriteString(fmt.Sprintf("\t%s\t-%s\n", account, value.FloatString(2)))
	check(err)
}

debit.go

	check(err)
	defer f.Close()
	_, err = f.WriteString(fmt.Sprintf("\t%s\t-%s\n", account, value.FloatString(2)))
	_, err = f.WriteString(fmt.Sprintf("\t%s\t+%s\n", account, value.FloatString(2)))
	check(err)
}

general.ledger

2015-01-03  @general    Some other stuff
    cash       -10.00
    services   +10.00
2015-01-03  @general    Multiple accounts example
    cash       +10.00
    liability  -5.00
    a          -5.00
2015-01-05	@general	blah
	savings	-10.00
	cash	+5.00
	sheep	+5.00
2015-01-05	@general	blah
	savings	-10.00
	cash	+5.00
	sheep	+5.00