add pending transaction and add transaction if pending available

.gitignore

@@ -19,4 +19,5 @@ _cgo_export.*
_testmain.go
*.exe
*.exe
cash

cash.go

@@ -0,0 +1,257 @@
package main
import (
	"bytes"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"
	"github.com/codegangsta/cli"
)
const (
	// Application name
	APP_NAME = "cash"
	// Application usage description
	APP_USAGE = "counting coins"
	// Application version
	APP_VER = "0.0.0"
)
var (
	// Ledger file name
	Ledger            = "example.ledger"
	TransactionFormat = "%s\t%s\t%s"
	AccountFormat     = "\t%s\t%s"
)
// 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: "",
		},
	}
	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,
		},
	}
	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
}

doc.go

@@ -0,0 +1,9 @@
package main
/*
Subcommands
	ledger
	period <start date> <stop date>
	add
	delete <transaction>
*/

example.ledger

@@ -0,0 +1,10 @@
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-03  @something
    #cash       +2.00
@pending