unit tests; lazy quotes; output header; ErrEmptyRow; Options struct; much refractoring

Author: pjdufour

.travis.yml

@@ -2,8 +2,9 @@ sudo: false
 language: go
 
 go:
-  - 1.9
+  - "1.9"
   - "1.10"
+  - "1.11"
   - tip
 
 os:
@@ -21,13 +22,5 @@ install:
   - gometalinter --install
 
 script:
-  - gometalinter --misspell-locale=US --disable-all --enable=misspell --enable=vet ./gss/
-  - gometalinter --misspell-locale=US --disable-all --enable=misspell --enable=vet ./plugins/gss/
-  - gometalinter --misspell-locale=US --disable-all --enable=misspell --enable=vet ./cmd/gss/
-  - gometalinter --misspell-locale=US --disable-all --enable=misspell --enable=vet ./cmd/gss.js/
-  - cd gss
-  - go fmt
-  - cd ./../cmd/gss
-  - go fmt
-  - cd ./../../cmd/gss.js
-  - go fmt
+  - scripts/format.sh
+  - scripts/test.sh

Gopkg.toml

@@ -21,7 +21,7 @@ import (
 
 func main() {
 	js.Global.Set("gss", map[string]interface{}{
-		"version":     gss.VERSION,
+		"version":     gss.Version,
 		"formats":     gss.Formats,
 		"convert":     gssjs.Convert,
 		"deserialize": gssjs.Deserialize,

cmd/gss.js/main.go

@@ -34,20 +34,24 @@ func main() {
 	var input_format string
 	var input_header_text string
 	var input_comment string
+	var input_lazy_quotes bool
 	var input_limit int
 
 	var output_format string
+	var output_header_text string
 	var output_limit int
 
 	var version bool
 	var verbose bool
 	var help bool
 
 	flag.StringVar(&input_format, "i", "", "The input format: "+strings.Join(gss.Formats, ", "))
-	flag.StringVar(&input_header_text, "h", "", "The input header if the stdin input has no header.")
+	flag.StringVar(&input_header_text, "", "", "The input header if the stdin input has no header.")
 	flag.StringVar(&input_comment, "c", "", "The input comment character, e.g., #.  Commented lines are not sent to output.")
+	flag.BoolVar(&input_lazy_quotes, "", false, "allows lazy quotes for CSV and TSV")
 	flag.IntVar(&input_limit, "", -1, "The input limit")
 	flag.StringVar(&output_format, "o", "", "The output format: "+strings.Join(gss.Formats, ", "))
+	flag.StringVar(&output_header_text, "", "", "The output header if the stdout output has no header.")
 	flag.IntVar(&output_limit, "", -1, "the output limit")
 	flag.BoolVar(&version, "version", false, "Prints version to stdout")
 	flag.BoolVar(&verbose, "verbose", false, "Print debug info to stdout")
@@ -72,7 +76,7 @@ func main() {
 	}
 
 	if version {
-		fmt.Println(gss.VERSION)
+		fmt.Println(gss.Version)
 		os.Exit(0)
 	}
 
@@ -99,7 +103,12 @@ func main() {
 		input_header = strings.Split(input_header_text, ",")
 	}
 
-	output_string, err := gss.Convert(input_bytes, input_format, input_header, input_comment, input_limit, output_format, output_limit, verbose)
+	output_header := make([]string, 0)
+	if len(input_header_text) > 0 {
+		output_header = strings.Split(output_header_text, ",")
+	}
+
+	output_string, err := gss.Convert(input_bytes, input_format, input_header, input_comment, input_lazy_quotes, input_limit, output_format, output_header, output_limit, verbose)
 	if err != nil {
 		fmt.Println(errors.Wrap(err, "Error converting"))
 		os.Exit(1)

cmd/gss/main.go

@@ -14,7 +14,7 @@ import (
 
 // Convert converts an input_string from the input_format to the output_format.
 // Returns the output string and error, if any.
-func Convert(input_bytes []byte, input_format string, input_header []string, input_comment string, input_limit int, output_format string, output_limit int, verbose bool) (string, error) {
+func Convert(input_bytes []byte, input_format string, input_header []string, input_comment string, input_lazy_quotes bool, input_limit int, output_format string, output_header []string, output_limit int, verbose bool) (string, error) {
 
 	input_type, err := GetType(input_bytes, input_format)
 	if err != nil {
@@ -29,24 +29,24 @@ func Convert(input_bytes []byte, input_format string, input_header []string, inp
 
 	if input_format == "bson" || input_format == "json" || input_format == "hcl" || input_format == "hcl2" || input_format == "properties" || input_format == "toml" || input_format == "yaml" {
 		if output_format == "bson" || output_format == "json" || input_format == "hcl" || input_format == "hcl2" || output_format == "properties" || output_format == "toml" || output_format == "yaml" {
-			object, err := Deserialize(string(input_bytes), input_format, input_header, input_comment, input_limit, input_type, verbose)
+			object, err := DeserializeBytes(input_bytes, input_format, input_header, input_comment, input_lazy_quotes, input_limit, input_type, verbose)
 			if err != nil {
 				return "", errors.Wrap(err, "Error deserializing input")
 			}
 			if verbose {
 				fmt.Println("Object:", object)
 			}
-			output_string, err := Serialize(object, output_format)
+			output_string, err := SerializeString(object, output_format, output_header, output_limit)
 			if err != nil {
 				return "", errors.Wrap(err, "Error serializing output")
 			}
 			return output_string, nil
 		} else if output_format == "jsonl" {
-			object, err := Deserialize(string(input_bytes), input_format, input_header, input_comment, input_limit, input_type, verbose)
+			object, err := DeserializeBytes(input_bytes, input_format, input_header, input_comment, input_lazy_quotes, input_limit, input_type, verbose)
 			if err != nil {
 				return "", errors.Wrap(err, "Error deserializing input")
 			}
-			output_string, err := Serialize(object, output_format)
+			output_string, err := SerializeString(object, output_format, output_header, output_limit)
 			if err != nil {
 				return "", errors.Wrap(err, "Error serializing output")
 			}
@@ -60,11 +60,11 @@ func Convert(input_bytes []byte, input_format string, input_header []string, inp
 		}
 	} else if input_format == "jsonl" || input_format == "csv" || input_format == "tsv" {
 		if output_format == "bson" || output_format == "json" || output_format == "hcl" || output_format == "hcl2" || output_format == "toml" || output_format == "yaml" || output_format == "jsonl" || output_format == "csv" || output_format == "tsv" {
-			object, err := Deserialize(string(input_bytes), input_format, input_header, input_comment, input_limit, input_type, verbose)
+			object, err := DeserializeBytes(input_bytes, input_format, input_header, input_comment, input_lazy_quotes, input_limit, input_type, verbose)
 			if err != nil {
 				return "", errors.Wrap(err, "Error deserializing input")
 			}
-			output_string, err := Serialize(object, output_format)
+			output_string, err := SerializeString(object, output_format, output_header, output_limit)
 			if err != nil {
 				return "", errors.Wrap(err, "Error serializing output")
 			}