various formatting and other fixes

Author: pjdufour

.circleci/config.yml

@@ -23,13 +23,24 @@ jobs:
           keys:
             - v1-go-src-{{ .Branch }}-{{ .Revision }}
       - run:
-          name: Install gometalinter
-          command: |
-            go get -u github.com/alecthomas/gometalinter
-            gometalinter --install
+          name: Get shadow
+          command: go get golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
+      - run:
+          name: Install shadow
+          command: go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
+      - run:
+          name: Download and install errcheck
+          command: go get -u github.com/kisielk/errcheck
+      - run:
+          name: Download and install misspell
+          command: go get -u github.com/client9/misspell/cmd/misspell
+      - run:
+          name: Download and install ineffassign
+          command: go get -u github.com/gordonklaus/ineffassign
       - run:
-          name: Test
-          command: bash scripts/test.sh
+          name: Download and install staticheck
+          command: go get -u honnef.co/go/tools/cmd/staticcheck
+      - run: bash scripts/test.sh
   validate:
     executor: base
     steps:

gss/DeserializeBytes.go

@@ -29,19 +29,19 @@ func unescapePropertyText(in string) string {
 	return out
 }
 
-func deserializeBSON(input_bytes []byte, outputType reflect.Type) (interface{}, error) {
+func deserializeBSON(inputBytes []byte, outputType reflect.Type) (interface{}, error) {
 	if outputType.Kind() == reflect.Map {
 		ptr := reflect.New(outputType)
 		ptr.Elem().Set(reflect.MakeMap(outputType))
-		err := bson.Unmarshal(input_bytes, ptr.Interface())
+		err := bson.Unmarshal(inputBytes, ptr.Interface())
 		if err != nil {
 			return nil, errors.Wrap(err, "error unmarshalling bytes into BSON")
 		}
 		return ptr.Elem().Interface(), nil
 	} else if outputType.Kind() == reflect.Slice {
 		ptr := reflect.New(outputType)
 		ptr.Elem().Set(reflect.MakeSlice(outputType, 0, 0))
-		err := bson.Unmarshal(input_bytes, ptr.Interface())
+		err := bson.Unmarshal(inputBytes, ptr.Interface())
 		if err != nil {
 			return nil, errors.Wrap(err, "error unmarshalling bytes into BSON")
 		}
@@ -55,7 +55,7 @@ func DeserializeBytes(input *DeserializeInput) (interface{}, error) {
 
 	switch input.Format {
 	case "csv", "tsv":
-		return DeserializeCSV(bytes.NewReader(input.Bytes), input.Format, input.Header, input.Comment, input.LazyQuotes, input.SkipLines, input.Limit, input.Type)
+		return DeserializeSV(bytes.NewReader(input.Bytes), input.Format, input.Header, input.Comment, input.LazyQuotes, input.SkipLines, input.Limit, input.Type)
 	case "properties":
 		return DeserializeProperties(string(input.Bytes), input.Comment, input.Type)
 	case "bson":

gss/DeserializeJSON.go

@@ -16,23 +16,23 @@ import (
 
 // DeserializeJSON deserializes the input bytes into a Go object.
 //  - https://golang.org/pkg/encoding/json/
-func DeserializeJSON(input_bytes []byte, output_type reflect.Type) (interface{}, error) {
-	if output_type.Kind() == reflect.Map {
-		ptr := reflect.New(output_type)
-		ptr.Elem().Set(reflect.MakeMap(output_type))
-		err := json.Unmarshal(input_bytes, ptr.Interface())
+func DeserializeJSON(inputBytes []byte, outputType reflect.Type) (interface{}, error) {
+	if outputType.Kind() == reflect.Map {
+		ptr := reflect.New(outputType)
+		ptr.Elem().Set(reflect.MakeMap(outputType))
+		err := json.Unmarshal(inputBytes, ptr.Interface())
 		if err != nil {
 			return nil, errors.Wrap(err, "error unmarshalling bytes into JSON")
 		}
 		return ptr.Elem().Interface(), nil
-	} else if output_type.Kind() == reflect.Slice {
-		ptr := reflect.New(output_type)
-		ptr.Elem().Set(reflect.MakeSlice(output_type, 0, 0))
-		err := json.Unmarshal(input_bytes, ptr.Interface())
+	} else if outputType.Kind() == reflect.Slice {
+		ptr := reflect.New(outputType)
+		ptr.Elem().Set(reflect.MakeSlice(outputType, 0, 0))
+		err := json.Unmarshal(inputBytes, ptr.Interface())
 		if err != nil {
 			return nil, errors.Wrap(err, "error unmarshalling bytes into JSON")
 		}
 		return ptr.Elem().Interface(), nil
 	}
-	return nil, errors.New("Invalid output type for json " + fmt.Sprint(output_type))
+	return nil, errors.New("Invalid output type for json " + fmt.Sprint(outputType))
 }

gss/DeserializeProperties.go

@@ -17,17 +17,17 @@ import (
 
 // DeserializeProperties deserializes a properties string into a Go instance.
 //  - https://en.wikipedia.org/wiki/.properties
-func DeserializeProperties(input string, input_comment string, output_type reflect.Type) (interface{}, error) {
-	m := reflect.MakeMap(output_type)
-	if len(input_comment) == 0 {
-		input_comment = "#"
+func DeserializeProperties(input string, inputComment string, outputType reflect.Type) (interface{}, error) {
+	m := reflect.MakeMap(outputType)
+	if len(inputComment) == 0 {
+		inputComment = "#"
 	}
 	scanner := bufio.NewScanner(strings.NewReader(input))
 	scanner.Split(bufio.ScanLines)
 	property := ""
 	for scanner.Scan() {
 		line := scanner.Text()
-		if len(line) > 0 && !strings.HasPrefix(line, input_comment) {
+		if len(line) > 0 && !strings.HasPrefix(line, inputComment) {
 			if line[len(line)-1] == '\\' {
 				property += strings.TrimLeftFunc(line[0:len(line)-1], unicode.IsSpace)
 			} else {

gss/DeserializeCSV.go gss/DeserializeSV.gogss/DeserializeCSV.go renamed to gss/DeserializeSV.go

@@ -14,19 +14,19 @@ import (
 	"reflect"
 )
 
-// DeserializeCSV deserializes a CSV or TSV string into a Go instance.
+// DeserializeSV deserializes a CSV or TSV string into a Go instance.
 //  - https://golang.org/pkg/encoding/csv/
-func DeserializeCSV(input io.Reader, format string, input_header []string, input_comment string, inputLazyQuotes bool, inputSkipLines int, inputLimit int, output_type reflect.Type) (interface{}, error) {
+func DeserializeSV(input io.Reader, format string, inputHeader []string, inputComment string, inputLazyQuotes bool, inputSkipLines int, inputLimit int, outputType reflect.Type) (interface{}, error) {
 
-	if output_type.Kind() == reflect.Map {
+	if outputType.Kind() == reflect.Map {
 		if inputLimit != 1 {
-			return nil, errors.Wrap(&ErrInvalidLimit{Value: inputLimit}, "DeserializeCSV expects input limit of 1 when output type is of kind map.")
+			return nil, errors.Wrap(&ErrInvalidLimit{Value: inputLimit}, "DeserializeSV expects input limit of 1 when output type is of kind map.")
 		}
-		if len(input_header) == 0 {
-			return nil, errors.New("deserializeCSV when returning a map type expects a input header")
+		if len(inputHeader) == 0 {
+			return nil, errors.New("deserializeSV when returning a map type expects a input header")
 		}
-	} else if !(output_type.Kind() == reflect.Array || output_type.Kind() == reflect.Slice) {
-		return nil, &ErrInvalidKind{Value: output_type.Kind(), Valid: []reflect.Kind{reflect.Array, reflect.Slice, reflect.Map}}
+	} else if !(outputType.Kind() == reflect.Array || outputType.Kind() == reflect.Slice) {
+		return nil, &ErrInvalidKind{Value: outputType.Kind(), Valid: []reflect.Kind{reflect.Array, reflect.Slice, reflect.Map}}
 	}
 
 	reader := csv.NewReader(input)
@@ -36,13 +36,13 @@ func DeserializeCSV(input io.Reader, format string, input_header []string, input
 	reader.LazyQuotes = inputLazyQuotes
 	reader.FieldsPerRecord = -1 // records may have a variable number of fields
 
-	if len(input_comment) > 1 {
+	if len(inputComment) > 1 {
 		return nil, errors.New("go's encoding/csv package only supports single character comment characters")
-	} else if len(input_comment) == 1 {
-		reader.Comment = []rune(input_comment)[0]
+	} else if len(inputComment) == 1 {
+		reader.Comment = []rune(inputComment)[0]
 	}
 
-	if output_type.Kind() == reflect.Map {
+	if outputType.Kind() == reflect.Map {
 		inRow, err := reader.Read()
 		if err != nil {
 			if err == io.EOF {
@@ -53,8 +53,8 @@ func DeserializeCSV(input io.Reader, format string, input_header []string, input
 		if len(inRow) == 0 {
 			return nil, &ErrEmptyRow{}
 		}
-		m := reflect.MakeMap(output_type)
-		for i, h := range input_header {
+		m := reflect.MakeMap(outputType)
+		for i, h := range inputHeader {
 			// if the number of columns in the header is greater than in the row,
 			// then break and return data for the columns that are there
 			if i >= len(inRow) {
@@ -65,17 +65,17 @@ func DeserializeCSV(input io.Reader, format string, input_header []string, input
 		return m.Interface(), nil
 	}
 
-	if len(input_header) == 0 {
+	if len(inputHeader) == 0 {
 		h, err := reader.Read()
 		if err != nil {
 			if err != io.EOF {
 				return nil, errors.Wrap(err, "Error reading header from input with format csv")
 			}
 		}
-		input_header = h
+		inputHeader = h
 	}
 
-	output := reflect.MakeSlice(output_type, 0, 0)
+	output := reflect.MakeSlice(outputType, 0, 0)
 	for {
 		inRow, err := reader.Read()
 		if err != nil {
@@ -85,8 +85,8 @@ func DeserializeCSV(input io.Reader, format string, input_header []string, input
 				return nil, errors.Wrap(err, "error reading row into slice from input with format csv")
 			}
 		}
-		m := reflect.MakeMap(output_type.Elem())
-		for i, h := range input_header {
+		m := reflect.MakeMap(outputType.Elem())
+		for i, h := range inputHeader {
 			if i < len(inRow) {
 				m.SetMapIndex(reflect.ValueOf(h), reflect.ValueOf(inRow[i]))
 			}

gss/DeserializeTOML.go

@@ -16,12 +16,12 @@ import (
 
 // DeserializeTOML deserializes an input TOML string into a Go object
 //  - https://godoc.org/pkg/github.com/BurntSushi/toml
-func DeserializeTOML(input string, output_type reflect.Type) (interface{}, error) {
-	if output_type.Kind() == reflect.Map {
-		ptr := reflect.New(output_type)
-		ptr.Elem().Set(reflect.MakeMap(output_type))
+func DeserializeTOML(input string, outputType reflect.Type) (interface{}, error) {
+	if outputType.Kind() == reflect.Map {
+		ptr := reflect.New(outputType)
+		ptr.Elem().Set(reflect.MakeMap(outputType))
 		_, err := toml.Decode(input, ptr.Interface())
 		return ptr.Elem().Interface(), err
 	}
-	return nil, errors.New("Invalid output type for toml " + fmt.Sprint(output_type))
+	return nil, errors.New("Invalid output type for toml " + fmt.Sprint(outputType))
 }

gss/DeserializeYAML.go

@@ -9,23 +9,30 @@ package gss
 
 import (
 	"fmt"
+	"reflect"
+)
+
+import (
 	"github.com/pkg/errors"
 	"gopkg.in/yaml.v2"
-	"reflect"
+)
+
+import (
+	stringify "github.com/spatialcurrent/go-stringify"
 )
 
 // DeserializeYAML deserializes the YAML input bytes into a Go object
-func DeserializeYAML(input_bytes []byte, output_type reflect.Type) (interface{}, error) {
-	if output_type.Kind() == reflect.Map {
-		ptr := reflect.New(output_type)
-		ptr.Elem().Set(reflect.MakeMap(output_type))
-		err := yaml.Unmarshal(input_bytes, ptr.Interface())
+func DeserializeYAML(inputBytes []byte, outputType reflect.Type) (interface{}, error) {
+	if outputType.Kind() == reflect.Map {
+		ptr := reflect.New(outputType)
+		ptr.Elem().Set(reflect.MakeMap(outputType))
+		err := yaml.Unmarshal(inputBytes, ptr.Interface())
 		return ptr.Elem().Interface(), err
-	} else if output_type.Kind() == reflect.Slice {
-		ptr := reflect.New(output_type)
-		ptr.Elem().Set(reflect.MakeSlice(output_type, 0, 0))
-		err := yaml.Unmarshal(input_bytes, ptr.Interface())
-		return StringifyMapKeys(ptr.Elem().Interface()), err
+	} else if outputType.Kind() == reflect.Slice {
+		ptr := reflect.New(outputType)
+		ptr.Elem().Set(reflect.MakeSlice(outputType, 0, 0))
+		err := yaml.Unmarshal(inputBytes, ptr.Interface())
+		return stringify.StringifyMapKeys(ptr.Elem().Interface()), err
 	}
-	return nil, errors.New("Invalid output type for yaml " + fmt.Sprint(output_type))
+	return nil, errors.New("Invalid output type for yaml " + fmt.Sprint(outputType))
 }