Use camel case in favour of underscored names

Author: stilvoid

formatter/dot.go

@@ -47,7 +47,7 @@ func formatDot(in interface{}) (out string) {
 	return fmt.Sprintf("graph{\n%s}", buf.String())
 }
 
-func flatten(in interface{}, current_path string) ([]node, []link) {
+func flatten(in interface{}, currentPath string) ([]node, []link) {
 	var nodes []node
 	var links []link
 
@@ -62,62 +62,62 @@ func flatten(in interface{}, current_path string) ([]node, []link) {
 		vv := in.(map[string]interface{})
 
 		for key, value := range vv {
-			target := current_path + "-" + key
+			target := currentPath + "-" + key
 
 			nodes = append(nodes, node{
 				name:  target,
 				label: key,
 			})
 
-			if current_path != "" {
+			if currentPath != "" {
 				links = append(links, link{
-					left:  current_path,
+					left:  currentPath,
 					right: target,
 				})
 			}
 
-			new_nodes, new_links := flatten(value, target)
+			newNodes, newLinks := flatten(value, target)
 
-			nodes = append(nodes, new_nodes...)
-			links = append(links, new_links...)
+			nodes = append(nodes, newNodes...)
+			links = append(links, newLinks...)
 		}
 
 		return nodes, links
 	case reflect.Array, reflect.Slice:
 		for index := 0; index < val.Len(); index++ {
 			value := val.Index(index).Interface()
 
-			target := current_path + "-" + fmt.Sprint(index)
+			target := currentPath + "-" + fmt.Sprint(index)
 
 			nodes = append(nodes, node{
 				name:  target,
 				label: fmt.Sprintf("[%d]", index),
 			})
 
-			if current_path != "" {
+			if currentPath != "" {
 				links = append(links, link{
-					left:  current_path,
+					left:  currentPath,
 					right: target,
 				})
 			}
 
-			new_nodes, new_links := flatten(value, target)
+			newNodes, newLinks := flatten(value, target)
 
-			nodes = append(nodes, new_nodes...)
-			links = append(links, new_links...)
+			nodes = append(nodes, newNodes...)
+			links = append(links, newLinks...)
 		}
 
 		return nodes, links
 	default:
-		target := current_path + "=content"
+		target := currentPath + "=content"
 
 		nodes = append(nodes, node{
 			name:  target,
 			label: fmt.Sprint(in),
 		})
 
 		links = append(links, link{
-			left:  current_path,
+			left:  currentPath,
 			right: target,
 		})
 

formatter/json.go

@@ -7,13 +7,13 @@ import (
 )
 
 func formatJson(in interface{}) (out string) {
-	in_map, ok := in.(map[string]interface{})
+	inMap, ok := in.(map[string]interface{})
 
 	if !ok {
 		return fmt.Sprintf("\"%s\"", in)
 	}
 
-	m := mxj.Map(in_map)
+	m := mxj.Map(inMap)
 
 	bytes, err := m.JsonIndent("", "  ")
 

formatter/util.go

@@ -10,23 +10,23 @@ func forceStringKeys(in interface{}) interface{} {
 
 	switch val.Kind() {
 	case reflect.Map:
-		new_map := make(map[string]interface{}, val.Len())
+		newMap := make(map[string]interface{}, val.Len())
 
 		for _, key := range val.MapKeys() {
-			string_key := fmt.Sprint(key.Interface())
-			new_map[string_key] = forceStringKeys(val.MapIndex(key).Interface())
+			stringKey := fmt.Sprint(key.Interface())
+			newMap[stringKey] = forceStringKeys(val.MapIndex(key).Interface())
 		}
 
-		return new_map
+		return newMap
 	case reflect.Array, reflect.Slice:
-		new_slice := make([]interface{}, val.Len())
+		newSlice := make([]interface{}, val.Len())
 
 		for i := 0; i < val.Len(); i++ {
 			value := val.Index(i).Interface()
-			new_slice[i] = forceStringKeys(value)
+			newSlice[i] = forceStringKeys(value)
 		}
 
-		return new_slice
+		return newSlice
 	default:
 		return in
 	}

parse.go

@@ -32,8 +32,8 @@ func parseHelp() {
 
 func parseCommand(args []string) {
 	// Flags
-	in_format := getopt.String('i', "auto")
-	out_format := getopt.String('o', "bash")
+	inFormat := getopt.String('i', "auto")
+	outFormat := getopt.String('o', "bash")
 
 	opts := getopt.CommandLine
 
@@ -56,7 +56,7 @@ func parseCommand(args []string) {
 	}
 
 	// Try parsing
-	parsed, err := parser.Parse(input, *in_format)
+	parsed, err := parser.Parse(input, *inFormat)
 
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
@@ -74,7 +74,7 @@ func parseCommand(args []string) {
 	}
 
 	// ...and format back out :)
-	output, err := formatter.Format(parsed, *out_format)
+	output, err := formatter.Format(parsed, *outFormat)
 
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)

parser/filter.go

@@ -14,36 +14,36 @@ func Filter(in interface{}, path string) (interface{}, error) {
 		return in, nil
 	}
 
-	split_path := strings.SplitN(path, ".", 2)
+	splitPath := strings.SplitN(path, ".", 2)
 
-	this_path := split_path[0]
-	var next_path string
+	thisPath := splitPath[0]
+	var nextPath string
 
-	if len(split_path) > 1 {
-		next_path = split_path[1]
+	if len(splitPath) > 1 {
+		nextPath = splitPath[1]
 	}
 
 	val := reflect.ValueOf(in)
 
 	switch val.Kind() {
 	case reflect.Map:
 		for _, key := range val.MapKeys() {
-			if fmt.Sprint(key.Interface()) == this_path {
+			if fmt.Sprint(key.Interface()) == thisPath {
 				value := val.MapIndex(key).Interface()
-				return Filter(value, next_path)
+				return Filter(value, nextPath)
 			}
 		}
 
 		break
 	case reflect.Array, reflect.Slice:
-		index, err := strconv.Atoi(this_path)
+		index, err := strconv.Atoi(thisPath)
 
 		if err != nil || index < 0 || index >= val.Len() {
 			break
 		}
 
-		return Filter(val.Index(index).Interface(), next_path)
+		return Filter(val.Index(index).Interface(), nextPath)
 	}
 
-	return nil, fmt.Errorf("Key does not exist: %s", this_path)
+	return nil, fmt.Errorf("Key does not exist: %s", thisPath)
 }

parser/html.go

@@ -41,25 +41,25 @@ func formatHtml(n *html.Node) map[string]interface{} {
 				out["#text"] = c.Data
 			}
 		} else {
-			existing_value, exists := out[c.Data]
+			existingValue, exists := out[c.Data]
 
-			new_value := formatHtml(c)
+			newValue := formatHtml(c)
 
 			if !exists {
-				out[c.Data] = new_value
+				out[c.Data] = newValue
 			} else {
-				val := reflect.ValueOf(existing_value)
+				val := reflect.ValueOf(existingValue)
 
 				kind := val.Kind()
 
 				if kind != reflect.Array && kind != reflect.Slice {
 					out[c.Data] = []interface{}{
-						existing_value,
-						new_value,
+						existingValue,
+						newValue,
 					}
 				} else {
 					// *this* is sick
-					out[c.Data] = reflect.Append(val, reflect.ValueOf(new_value)).Interface().([]interface{})
+					out[c.Data] = reflect.Append(val, reflect.ValueOf(newValue)).Interface().([]interface{})
 				}
 			}
 		}

parser/mime.go

@@ -8,28 +8,28 @@ import (
 )
 
 func parseMime(input []byte) (interface{}, error) {
-	input_reader := bufio.NewReader(bytes.NewReader(input))
+	inputReader := bufio.NewReader(bytes.NewReader(input))
 
-	reader := textproto.NewReader(input_reader)
+	reader := textproto.NewReader(inputReader)
 
 	headers, err := reader.ReadMIMEHeader()
 	if err != nil {
 		return nil, err
 	}
 
-	bytes_body, err := ioutil.ReadAll(input_reader)
+	bytesBody, err := ioutil.ReadAll(inputReader)
 	if err != nil {
 		return nil, err
 	}
 
-	message_headers := make(map[string]interface{})
+	messageHeaders := make(map[string]interface{})
 	for key, value := range headers {
-		message_headers[key] = value
+		messageHeaders[key] = value
 	}
 
 	message := make(map[string]interface{})
-	message["headers"] = message_headers
-	message["body"] = string(bytes_body)
+	message["headers"] = messageHeaders
+	message["body"] = string(bytesBody)
 
 	return message, nil
 }