fix 'golint' and 'go vet' warnings

Author: j-keck

bindata.go

@@ -3,17 +3,23 @@ package main
 import (
 	"bytes"
 	"fmt"
+
 	"github.com/sergi/go-diff/diffmatchpatch"
 )
 
+// DeltaType classifies a patch action like 'delete', 'equal' or 'insert'
 type DeltaType int
 
 const (
+	// Del represents a deleted patch chunk
 	Del DeltaType = (iota - 1)
+	// Eq represents a not changed patch chunk
 	Eq
+	// Ins represents a added patch chunk
 	Ins
 )
 
+// Delta represents a patch chunk
 type Delta struct {
 	Type           DeltaType
 	LineNrFrom     int
@@ -38,6 +44,7 @@ func (d *Delta) String() string {
 	return fmt.Sprintf("{%s:%d,%d:%d,%d:%s}", t, d.LineNrFrom, d.LineNrTarget, d.StartPosFrom, d.StartPosTarget, d.Text)
 }
 
+// Deltas represents all patch chunks of a file
 type Deltas []Delta
 
 func (deltas Deltas) String() string {
@@ -51,6 +58,7 @@ func (deltas Deltas) String() string {
 	return buffer.String()
 }
 
+// Diff compares two strings and returns the DiffResult
 func Diff(from, target string, contextSize int) DiffResult {
 
 	// init diff-match-patch and create the (diff-match-patch) diff
@@ -92,7 +100,7 @@ func createDeltasFromDiffs(diffs []diffmatchpatch.Diff, contextSize int) Deltas
 	nextDiffIfTypeIs := func(diffType diffmatchpatch.Operation) (diffmatchpatch.Diff, bool) {
 		if idx < len(diffs) && diffs[idx].Type == diffType {
 			next := diffs[idx]
-			idx += 1
+			idx++
 			return next, true
 		}
 		return diffmatchpatch.Diff{}, false

diff.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 )
 
+// DiffResult represents the result from a diff
 type DiffResult struct {
 	LineBasedDeltas Deltas
 	CharBasedDeltas Deltas
@@ -35,10 +36,12 @@ func splitDeltasByContext(deltas Deltas) []Deltas {
 	return splitted
 }
 
+// DeltasByContext splits the Delta at their context bounds
 func (dr *DiffResult) DeltasByContext() []Deltas {
 	return splitDeltasByContext(dr.LineBasedDeltas)
 }
 
+// AsSideBySideHTML creates a SideBySide Diff
 func (dr *DiffResult) AsSideBySideHTML() []string {
 	var htmlBlocks []string
 
@@ -63,7 +66,7 @@ func (dr *DiffResult) AsSideBySideHTML() []string {
 		nextDeltaIfTypeIs := func(deltaType DeltaType) (Delta, bool) {
 			if deltaIdx < len(deltas) && deltas[deltaIdx].Type == deltaType {
 				next := deltas[deltaIdx]
-				deltaIdx += 1
+				deltaIdx++
 				return next, true
 			}
 			return Delta{}, false
@@ -125,6 +128,7 @@ func (dr *DiffResult) AsSideBySideHTML() []string {
 	return htmlBlocks
 }
 
+// AsIntextHTML creates an Inline Diff
 func (dr *DiffResult) AsIntextHTML() []string {
 	var htmlBlocks []string
 

diff_result.go

@@ -33,6 +33,13 @@ func NewFileHandleInSnapshot(path, snapName string) (*FileHandle, error) {
 	return newFileHandle(ds.ConvertToSnapPath(path, snapName))
 }
 
+// NewFileHandleInSnapshotPart is the flipped, partially applied version of 'NewFileHandleInSnapshot'
+func NewFileHandleInSnapshotPart(snapName string) func(string) (*FileHandle, error) {
+	return func(path string) (*FileHandle, error) {
+		return NewFileHandleInSnapshot(path, snapName)
+	}
+}
+
 func newFileHandle(path string) (*FileHandle, error) {
 	fi, err := os.Stat(path)
 	if err != nil {
@@ -161,13 +168,12 @@ func (fh *FileHandle) CopyAs(path string) (err error) {
 //   * deleted entries are inserted
 //   * inserted entries are removed
 func (fh *FileHandle) Patch(deltas Deltas) error {
-	var err error
 
 	// verify the equal parts from the deltas are the same as in the given file
 	// returns a error if not
 	verifyDeltasAreApplicable := func() error {
-		var f *os.File
-		if f, err = os.Open(fh.Path); err != nil {
+		f, err := os.Open(fh.Path)
+		if err != nil {
 			return fmt.Errorf("open file: '%s' - %s", fh.Name, err.Error())
 		}
 		defer f.Close()
@@ -190,14 +196,15 @@ func (fh *FileHandle) Patch(deltas Deltas) error {
 
 	// apply the deltas to a given file
 	applyDeltasTo := func(dstPath string) error {
-		var src, dst *os.File
 		// open src / dst
-		if src, err = os.Open(fh.Path); err != nil {
+		src, err := os.Open(fh.Path)
+		if err != nil {
 			return fmt.Errorf("unable to open src-file: '%s' - %s", fh.Path, err.Error())
 		}
 		defer src.Close()
 
-		if dst, err = os.Create(dstPath); err != nil {
+		dst, err := os.Create(dstPath)
+		if err != nil {
 			return fmt.Errorf("unable to open dst-file: '%s' - %s", dstPath, err.Error())
 		}
 		defer func() {
@@ -267,12 +274,13 @@ func (fh *FileHandle) Patch(deltas Deltas) error {
 	}
 
 	if err := os.Rename(patchWorkFilePath, fh.Path); err != nil {
-		return fmt.Errorf("unable to rename patch file to orginal file - %s", err.Error())
+		return fmt.Errorf("unable to rename patch file to original file - %s", err.Error())
 	}
 
 	return nil
 }
 
+// MoveToBackup moves the file in the backup location
 func (fh *FileHandle) MoveToBackup() error {
 	backupDir := fmt.Sprintf("%s/.zsd", filepath.Dir(fh.Path))
 
@@ -296,7 +304,7 @@ func (fh *FileHandle) MoveToBackup() error {
 	return os.Rename(fh.Path, backupFilePath)
 }
 
-// FileHasChangedFunGen to create a FileHasChangedFunc
+// FileHasChangedFuncGen to create a FileHasChangedFunc
 type FileHasChangedFuncGen func(*FileHandle) FileHasChangedFunc
 
 // FileHasChangedFunc to detect if a file has changed
@@ -329,7 +337,7 @@ func NewFileHasChangedFuncGenByName(method string) (FileHasChangedFuncGen, error
 			return CompareFileBySizeAndModTime(actual)
 		}, nil
 	default:
-		return nil, fmt.Errorf("no such compare method: '%s' - avaliable: 'size+modTime', 'size', 'md5'", method)
+		return nil, fmt.Errorf("no such compare method: '%s' - available: 'size+modTime', 'size', 'md5'", method)
 	}
 }
 

file_handle.go

@@ -68,7 +68,8 @@ func main() {
 
 	// abort if zfs name is missing
 	if len(zfsName) == 0 {
-		fmt.Println("parameter <ZFS_NAME> missing\n")
+		fmt.Println("parameter <ZFS_NAME> missing")
+		fmt.Println()
 		flag.Usage()
 		os.Exit(1)
 	}

main.go

@@ -16,7 +16,7 @@ type params map[string]interface{}
 
 // parse and validate request parameters
 //   * rules format: [?]<NAME>:<TYPE>
-//     - seperated per ,
+//     - separated per ,
 //     - starting with a question mark means optional parameter
 //     - currently supported types: 'string' and 'int'
 //     - example: 'path:string,?limit:int'
@@ -47,15 +47,15 @@ func parseParams(w http.ResponseWriter, r *http.Request, rules string) (p params
 			if valueFound {
 				switch pType {
 				case "int":
-					if i, err := strconv.Atoi(value.(string)); err != nil {
+					i, err := strconv.Atoi(value.(string))
+					if err != nil {
 						msg := fmt.Sprintf("unable to convert parameter '%s' to int: %s", pName, err.Error())
 						logError.Println(msg)
 						http.Error(w, msg, http.StatusBadRequest)
 						paramsValid = false
 						return
-					} else {
-						p[pName] = i
 					}
+					p[pName] = i
 				case "string":
 					// nothing to do
 				default:

params.go

@@ -94,9 +94,9 @@ func TestParseParamsInvalidParams(t *testing.T) {
 }
 
 func newDummyReq(queryParam string) *http.Request {
-	testUrl, _ := url.Parse(fmt.Sprintf("http://example.com?%s", queryParam))
+	testURL, _ := url.Parse(fmt.Sprintf("http://example.com?%s", queryParam))
 	return &http.Request{
 		Method: "GET",
-		URL:    testUrl,
+		URL:    testURL,
 	}
 }

params_test.go

@@ -6,6 +6,26 @@ import (
 	"strings"
 )
 
+// read the file content from the file handle
+func readTextFrom(getFh func(string) (*FileHandle, error), name string) (string, error) {
+
+	// get the file handle
+	fh, err := getFh(name)
+	if err != nil {
+		logError.Println("unable to get file-handle: ", err.Error())
+		return "", err
+	}
+
+	// read the file content
+	content, err := fh.ReadText()
+	if err != nil {
+		logError.Println("unable to read the file: ", err.Error())
+		return "", err
+	}
+
+	return content, err
+}
+
 // lastElement splits a string by sep and returns the last element
 func lastElement(str, sep string) string {
 	fields := strings.Split(str, sep)
@@ -81,7 +101,7 @@ func countNewLines(text string) int {
 	count := 0
 	for _, char := range text {
 		if char == '\n' {
-			count += 1
+			count++
 		}
 	}
 	return count