moved pending to temp file and simplified transaction process

cash.go

@@ -1,257 +1,49 @@
package main
import (
	"bytes"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"
	"path/filepath"
	"github.com/codegangsta/cli"
)
const (
	// Application name
	APP_NAME = "cash"
	// Application usage description
	APP_NAME  = "cash"
	APP_USAGE = "counting coins"
	// Application version
	APP_VER = "0.0.0"
	APP_VER   = "0.0.0"
)
var (
	// Ledger file name
	Ledger            = "example.ledger"
	Ledger            = "general.ledger"
	TransactionFormat = "%s\t%s\t%s"
	AccountFormat     = "\t%s\t%s"
	PendingFile       = filepath.Join(os.TempDir(), "pending.ledger")
)
// Application entry point
func main() {
	// Flags pertaining to a transaction action
	transactionFlags := []cli.Flag{
		cli.StringFlag{
			Name:  "date",
			Value: time.Now().UTC().Format("2006-01-02"),
			Usage: "",
		},
// Initialize the application
func init() {
	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()
	app.Name = APP_NAME
	app.Usage = APP_USAGE
	app.Version = APP_VER
	app.Commands = []cli.Command{
		{
			Name:      "credit",
			ShortName: "cr",
			Usage:     "",
			Action:    actionCredit,
		},
		{
			Name:      "debit",
			ShortName: "dr",
			Usage:     "",
			Action:    actionDebit,
		},
		{
			Name:      "status",
			ShortName: "stat",
			Usage:     "",
			Action:    actionStatus,
		},
		{
			Name:      "commit",
			ShortName: "c",
			Usage:     "",
			Action:    actionCommit,
			Flags:     transactionFlags,
		},
		{
			Name:      "list",
			ShortName: "ls",
			Usage:     "",
			Action:    actionList,
		},
		commandCredit,
		commandDebit,
		commandStatus,
		commandCommit,
		commandList,
		commandClear,
	}
	app.Run(os.Args)
}
// Helper function to check for fatal errors
func check(e error) {
	if e != nil {
		log.Fatal(fmt.Sprintf("Error: %s", e))
	}
}
// Add a credit to the pending transaction
func actionCredit(c *cli.Context) {
	addPendingTransaction()
	// Format: /t{account}/t-{value}
}
// Add a debit to the pending transaction
func actionDebit(c *cli.Context) {
	addPendingTransaction()
	// Format: /t{account}/t+{value}
}
// Display the current status of the ledger
func actionStatus(c *cli.Context) {
	log.Println(hasPendingTransaction())
}
// Commit the pending transaction
func actionCommit(c *cli.Context) {
	date := parseDate(c.String("date"))
	if date == "" {
		log.Fatal("Invalid transaction date")
	}
	args := c.Args()
	project := parseProject(args)
	description := parseDescription(args, project)
	err := writeTransaction(date, project, description)
	if err != nil {
		log.Fatal(err)
	}
}
// List the ledger contents
func actionList(c *cli.Context) {
}
// 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(Ledger)
	check(err)
	defer file.Close()
	info, err := file.Stat()
	check(err)
	size := info.Size()
	if size > 1024 {
		size = 1024
	}
	_, err = file.Seek(size*-1, 2)
	check(err)
	buffer := make([]byte, size)
	_, err = file.Read(buffer)
	check(err)
	return strings.Contains(string(buffer), "@pending")
}
// Adds a pending transaction if one is not already present
func addPendingTransaction() {
	if !hasPendingTransaction() {
		file, err := os.OpenFile(Ledger, os.O_APPEND|os.O_WRONLY, 0666)
		check(err)
		defer file.Close()
		_, err = file.WriteString("@pending")
		check(err)
	}
}
// Parse the given string to extract a proper date
func parseDate(in string) string {
	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.Format(formats[0])
		}
	}
	return ""
}
// Parse a given string to extract a project name
func parseProject(fields []string) string {
	project := "@general"
	for i := 0; i < len(fields); i++ {
		if strings.HasPrefix(fields[i], "@") {
			project = fields[i]
			break
		}
	}
	return project
}
// Parse the description from the arguments
func parseDescription(fields []string, project string) string {
	for i := 0; i < len(fields); i++ {
		if fields[i] == project {
			fields[i] = ""
			break
		}
	}
	return strings.Replace(strings.Join(fields, " "), "  ", " ", -1)
}
// Write a transaction line where there is a pending transaction
func writeTransaction(date, project, description string) error {
	if !hasPendingTransaction() {
		return errors.New("No pending transaction to write")
	}
	file, err := os.OpenFile(Ledger, os.O_RDWR, 0666)
	check(err)
	defer file.Close()
	info, err := file.Stat()
	check(err)
	size := info.Size()
	if size > 1024 {
		size = 1024
	}
	_, err = file.Seek(size*-1, 2)
	check(err)
	buffer := make([]byte, size)
	_, err = file.Read(buffer)
	check(err)
	// Find the line containing @pending and replace it with our transaction
	line := fmt.Sprintf("%s\t%s\t%s", date, project, description)
	buffer = bytes.Replace(buffer, []byte("@pending"), []byte(line), -1)
	offset := info.Size() - size
	_, err = file.WriteAt(buffer, offset)
	check(err)
	return nil
}

clear.go

@@ -0,0 +1,24 @@
package main
import (
	"os"
	"github.com/codegangsta/cli"
)
var commandClear = cli.Command{
	Name:      "clear",
	ShortName: "",
	Usage:     "",
	Action:    actionClear,
}
// Clear current pending transaction
func actionClear(c *cli.Context) {
	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

@@ -0,0 +1,111 @@
package main
import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"strings"
	"time"
	"github.com/codegangsta/cli"
)
var commandCommit = cli.Command{
	Name:      "commit",
	ShortName: "c",
	Usage:     "",
	Action:    actionCommit,
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:  "date",
			Value: time.Now().UTC().Format("2006-01-02"),
			Usage: "",
		},
	},
}
// Commit the pending transaction
func actionCommit(c *cli.Context) {
	date, err := parseDate(c.String("date"))
	check(err)
	args := c.Args()
	project := parseProject(args)
	description := parseDescription(args, project)
	writeTransaction(date, project, description)
}
// Parse the given string to extract a proper date
func parseDate(in string) (string, 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.Format(formats[0]), nil
		}
	}
	return "", errors.New("No valid date provided")
}
// Parse a given string to extract a project name
func parseProject(fields []string) string {
	project := "@general"
	for i := 0; i < len(fields); i++ {
		if strings.HasPrefix(fields[i], "@") {
			project = fields[i]
			break
		}
	}
	return project
}
// Parse the description from the arguments
func parseDescription(fields []string, project string) string {
	for i := 0; i < len(fields); i++ {
		if fields[i] == project {
			fields[i] = ""
			break
		}
	}
	return strings.Replace(strings.Join(fields, " "), "  ", " ", -1)
}
// Write a transaction line where there is a pending transaction
func writeTransaction(date, project, description string) {
	if !hasPendingTransaction() {
		check(errors.New("No pending transaction to write"))
	}
	pending, err := ioutil.ReadFile(PendingFile)
	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)
	check(err)
}

credit.go

@@ -0,0 +1,33 @@
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

@@ -0,0 +1,33 @@
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)
}

example.ledger

@@ -5,6 +5,3 @@
    #cash       +10.00
    #liability  -5.00
    #a          -5.00
2015-01-03  @something
    #cash       +2.00
@pending

helpers.go

@@ -0,0 +1,58 @@
package main
import (
	"errors"
	"fmt"
	"log"
	"math/big"
	"os"
	"strings"
)
// Helper function to check for fatal errors
func check(e error) {
	if e != nil {
		log.Fatal(fmt.Sprintf("Error: %s", e))
	}
}
// 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)
	check(err)
	defer file.Close()
	info, err := file.Stat()
	check(err)
	return info.Size() > 0
}
// Parse a given string to extract an account name
func parseAccount(fields []string) (string, error) {
	for i := 0; i < len(fields); i++ {
		if strings.HasPrefix(fields[i], "#") {
			return fields[i], nil
		}
	}
	return fields[0], nil
}
// Parse the value from the arguments
func parseValue(fields []string, account string) (*big.Rat, error) {
	r := new(big.Rat)
	for i := 0; i < len(fields); i++ {
		if fields[i] != account {
			r.SetString(fields[i])
			return r, nil
		}
	}
	return r, errors.New("No value found")
}

list.go

@@ -0,0 +1,14 @@
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) {
}

status.go

@@ -0,0 +1,26 @@
package main
import (
	"fmt"
	"io/ioutil"
	"github.com/codegangsta/cli"
)
var commandStatus = cli.Command{
	Name:      "status",
	ShortName: "stat",
	Usage:     "",
	Action:    actionStatus,
}
// Display the current status of the ledger
func actionStatus(c *cli.Context) {
	if hasPendingTransaction() {
		pending, err := ioutil.ReadFile(PendingFile)
		check(err)
		fmt.Println(string(pending))
	} else {
		fmt.Println("No pending transactions")
	}
}