created new types and some refactoring

.gitignore

*.exe
cash
*.ledger

account.go

package main
import (
	"errors"
	"fmt"
	"math/big"
	"strings"
)
type Account struct {
	Name   string
	Debit  bool
	Amount *big.Rat
}
// Convert from a string to an account
func (a *Account) FromString(text string) error {
	fields := strings.Split(text, "\t")
	if len(fields) != 3 {
		return errors.New("Invalid account format")
	}
	debit := true
	if strings.HasPrefix(fields[2], "-") {
		debit = false
	}
	a.Debit = debit
	a.Name = fields[1]
	a.Amount = new(big.Rat)
	a.Amount.SetString(fields[2][1:])
	return nil
}
// Convert the account to string format
func (a *Account) ToString() string {
	symbol := "-"
	if a.Debit {
		symbol = "+"
	}
	return fmt.Sprintf("\t%s\t%s%s\n", a.Name, symbol, a.Amount.FloatString(2))
}

cash.go

)
var (
	Ledger            = "general.ledger"
	TransactionFormat = "%s\t%s\t%s"
	AccountFormat     = "\t%s\t%s"
	PendingFile       = filepath.Join(os.TempDir(), "pending.ledger")
	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)

commit.go

import (
	"errors"
	"fmt"
	"io/ioutil"
	"math/big"
	"os"
	"strings"
	"time"
	project := parseProject(args)
	description := parseDescription(args, project)
	writeTransaction(date.Format("2006-01-02"), project, description)
	writeTransaction(date, project, description)
}
// Parse the given string to extract a proper date
	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[1]
			debit := true
			if strings.HasPrefix(fields[2], "-") {
				debit = false
			}
			value := new(big.Rat)
			value.SetString(fields[2][1:])
			t.Accounts = append(
				t.Accounts,
				Account{
					Name:   account,
					Debit:  debit,
					Amount: value,
				})
			break
		}
	}
	if len(t.Accounts) == 0 {
		return errors.New("Transaction does not have any accounts")
	}
	// Check that they balance
	balance := new(big.Rat)
	for _, a := range t.Accounts {
		if a.Debit {
			balance.Add(balance, a.Amount)
		} else {
			balance.Sub(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) {
func writeTransaction(date time.Time, project, description string) {
	if !hasPendingTransaction() {
		check(errors.New("No pending transaction to write"))
	}
	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)
	t := Transaction{
		Date:        date,
		Project:     project,
		Description: description,
		Accounts:    []Account{},
	}
	lines := strings.Split(strings.TrimRight(string(pending), "\n"), "\n")
	for _, line := range lines {
		var a Account
		err = a.FromString(line)
		check(err)
		t.Accounts = append(t.Accounts, a)
	}
	err = t.CheckBalance()
	check(err)
	file, err := os.OpenFile(Ledger, 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(s)
	_, err = file.WriteString(t.ToString())
	check(err)
}

example.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

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

transaction.go

package main
import (
	"errors"
	"fmt"
	"math/big"
	"strings"
	"time"
)
type Transaction struct {
	Date        time.Time
	Project     string
	Description string
	Accounts    []Account
}
// Create a transaction from a string
func (t *Transaction) FromString(text string) {
	// Parse the lines of text
	lines := strings.Split(text, "\n")
	for i, line := range lines {
		switch i {
		case 0:
			fields := strings.Split(line, "\t")
			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:
			var account Account
			err := account.FromString(line)
			check(err)
			t.Accounts = append(t.Accounts, account)
			break
		}
	}
}
// Check the transaction to ensure it is balanced
func (t *Transaction) CheckBalance() error {
	if len(t.Accounts) == 0 {
		return errors.New("Transaction does not have any accounts")
	}
	// Check that they balance
	balance := new(big.Rat)
	for _, a := range t.Accounts {
		if a.Debit {
			balance.Add(balance, a.Amount)
		} else {
			balance.Sub(balance, a.Amount)
		}
	}
	if balance.FloatString(2) != "0.00" {
		return errors.New("Transaction does not balance")
	}
	return nil
}
// Convert a transaction to string format
func (t *Transaction) ToString() string {
	accounts := ""
	for _, account := range t.Accounts {
		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))
}