go-aah/aah#69 reusable format flag parser

Author: jeevatkm

archive_test.go

@@ -6,6 +6,7 @@ package ess
 
 import (
 	"io/ioutil"
+	"strings"
 	"testing"
 
 	"aahframework.org/test.v0/assert"
@@ -39,4 +40,12 @@ func TestArchiveZip(t *testing.T) {
 	err := Zip(zipName, join(testdataPath, "dirpaths"))
 	assert.Nil(t, err)
 	assert.True(t, IsFileExists(zipName))
+
+	err = Zip(zipName, join(testdataPath, "dirpaths1"))
+	assert.NotNil(t, err)
+	assert.True(t, strings.HasPrefix(err.Error(), "source does not exists:"))
+
+	err = Zip(zipName, join(testdataPath, "dirpaths"))
+	assert.NotNil(t, err)
+	assert.True(t, strings.HasPrefix(err.Error(), "destination archive already exists:"))
 }

fmt_flag.go

@@ -0,0 +1,75 @@
+// Copyright (c) Jeevanandam M. (https://github.com/jeevatkm)
+// go-aah/essentials source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ess
+
+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	// FmtFlagSeparator is used parse flags pattern.
+	FmtFlagSeparator = "%"
+
+	// FmtFlagValueSeparator is used to parse into flag and value.
+	FmtFlagValueSeparator = ":"
+
+	defaultFormat = "%v"
+)
+
+type (
+	// FmtFlagPart is indiviual flag details
+	//  For e.g.:
+	//    part := FmtFlagPart{
+	//      Flag:   FmtFlagTime,
+	//      Name:   "time",
+	//      Format: "2006-01-02 15:04:05.000",
+	//    }
+	FmtFlagPart struct {
+		Flag   FmtFlag
+		Name   string
+		Format string
+	}
+
+	// FmtFlag type definition
+	FmtFlag uint8
+)
+
+// ParseFmtFlag it parses the given pattern, format flags into format flag parts.
+//  For e.g.:
+//    %time:2006-01-02 15:04:05.000 %level:-5 %message
+//    %clientip %reqid %reqtime %restime %resstatus %ressize %reqmethod %requrl %reqhdr:Referer %reshdr:Server
+func ParseFmtFlag(pattern string, fmtFlags map[string]FmtFlag) ([]FmtFlagPart, error) {
+	var flagParts []FmtFlagPart
+	pattern = strings.TrimSpace(pattern)
+	formatFlags := strings.Split(pattern, FmtFlagSeparator)[1:]
+	for _, f := range formatFlags {
+		f = strings.TrimSpace(f)
+		parts := strings.SplitN(f, FmtFlagValueSeparator, 2)
+		flag, found := fmtFlags[parts[0]]
+		if !found {
+			return nil, fmt.Errorf("fmtflag: unknown flag '%s'", f)
+		}
+
+		part := FmtFlagPart{Flag: flag, Name: parts[0]}
+		switch len(parts) {
+		case 2:
+			// handle `time` related flag, `custom` flag
+			// and `hdr` flag particularly
+			if strings.Contains(parts[0], "time") || parts[0] == "custom" ||
+				strings.HasSuffix(parts[0], "hdr") {
+				part.Format = parts[1]
+			} else {
+				part.Format = "%" + parts[1] + "v"
+			}
+		default:
+			part.Format = defaultFormat
+		}
+
+		flagParts = append(flagParts, part)
+	}
+
+	return flagParts, nil
+}

fmt_flag_test.go

@@ -0,0 +1,100 @@
+// Copyright (c) Jeevanandam M. (https://github.com/jeevatkm)
+// go-aah/essentials source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package ess
+
+import (
+	"testing"
+
+	"aahframework.org/test.v0/assert"
+)
+
+func TestFmtParseFlagLog(t *testing.T) {
+	const (
+		FmtFlagLevel FmtFlag = iota
+		FmtFlagTime
+		FmtFlagUTCTime
+		FmtFlagLongfile
+		FmtFlagShortfile
+		FmtFlagLine
+		FmtFlagMessage
+		FmtFlagCustom
+	)
+
+	logFmtFlags := map[string]FmtFlag{
+		"level":     FmtFlagLevel,
+		"time":      FmtFlagTime,
+		"utctime":   FmtFlagUTCTime,
+		"longfile":  FmtFlagLongfile,
+		"shortfile": FmtFlagShortfile,
+		"line":      FmtFlagLine,
+		"message":   FmtFlagMessage,
+		"custom":    FmtFlagCustom,
+	}
+
+	flagParts, err := ParseFmtFlag("%time:2006-01-02 15:04:05.000 %level %custom:- %message", logFmtFlags)
+	assert.Nil(t, err)
+
+	assertFlagPart(t, "time", "2006-01-02 15:04:05.000", FmtFlag(1), flagParts[0])
+	assertFlagPart(t, "level", "%v", FmtFlag(0), flagParts[1])
+	assertFlagPart(t, "custom", "-", FmtFlag(7), flagParts[2])
+	assertFlagPart(t, "message", "%v", FmtFlag(6), flagParts[3])
+
+	// Unknown flag
+	flagParts, err = ParseFmtFlag("%myflag", logFmtFlags)
+	assert.NotNil(t, err)
+	assert.Equal(t, "fmtflag: unknown flag 'myflag'", err.Error())
+	assert.True(t, len(flagParts) == 0)
+}
+
+func TestFmtParseFlagAccessLog(t *testing.T) {
+	const (
+		fmtFlagClientIP FmtFlag = iota
+		fmtFlagRequestTime
+		fmtFlagRequestURL
+		fmtFlagRequestMethod
+		fmtFlagRequestID
+		fmtFlagRequestHeader
+		fmtFlagQueryString
+		fmtFlagResponseStatus
+		fmtFlagResponseSize
+		fmtFlagResponseHeader
+		fmtFlagResponseTime
+	)
+
+	accessLogFmtFlags := map[string]FmtFlag{
+		"clientip":  fmtFlagClientIP,
+		"reqtime":   fmtFlagRequestTime,
+		"requrl":    fmtFlagRequestURL,
+		"reqmethod": fmtFlagRequestMethod,
+		"reqid":     fmtFlagRequestID,
+		"reqhdr":    fmtFlagRequestHeader,
+		"querystr":  fmtFlagQueryString,
+		"resstatus": fmtFlagResponseStatus,
+		"ressize":   fmtFlagResponseSize,
+		"reshdr":    fmtFlagResponseHeader,
+		"restime":   fmtFlagResponseTime,
+	}
+
+	flagParts, err := ParseFmtFlag("%clientip %reqid %reqtime %restime %resstatus %ressize %reqmethod %requrl %reqhdr:Referer %reshdr:Server", accessLogFmtFlags)
+	assert.Nil(t, err)
+
+	assertFlagPart(t, "clientip", "%v", FmtFlag(0), flagParts[0])
+	assertFlagPart(t, "reqid", "%v", FmtFlag(4), flagParts[1])
+	assertFlagPart(t, "reqtime", "%v", FmtFlag(1), flagParts[2])
+	assertFlagPart(t, "restime", "%v", FmtFlag(10), flagParts[3])
+	assertFlagPart(t, "resstatus", "%v", FmtFlag(7), flagParts[4])
+	assertFlagPart(t, "ressize", "%v", FmtFlag(8), flagParts[5])
+	assertFlagPart(t, "reqmethod", "%v", FmtFlag(3), flagParts[6])
+	assertFlagPart(t, "requrl", "%v", FmtFlag(2), flagParts[7])
+	assertFlagPart(t, "reqhdr", "Referer", FmtFlag(5), flagParts[8])
+	assertFlagPart(t, "reshdr", "Server", FmtFlag(9), flagParts[9])
+}
+
+func assertFlagPart(t *testing.T, name, format string, fflag FmtFlag, flagPart FmtFlagPart) {
+	t.Logf("Fmt Flag: %v", format)
+	assert.Equal(t, name, flagPart.Name)
+	assert.Equal(t, format, flagPart.Format)
+	assert.Equal(t, fflag, flagPart.Flag)
+}