Escape strings

Author: goncalo-rodrigues

_tests/basic.hcl

@@ -1,5 +1,7 @@
 String = "bar"
 
+EscapedString = "\"\\"
+
 Int = 123
 
 Bool = true

example_test.go

@@ -111,7 +111,7 @@ func Example() {
 	//   says = "meow"
 	// }
 	//
-	// buildings {
+	// buildings =  {
 	//   Barn  = "456 Digits Drive"
 	//   House = "123 Numbers Lane"
 	// }

hclencoder_test.go

@@ -25,12 +25,14 @@ func TestEncoder(t *testing.T) {
 		{
 			ID: "basic struct",
 			Input: struct {
-				String string
-				Int    int
-				Bool   bool
-				Float  float64
+				String        string
+				EscapedString string
+				Int           int
+				Bool          bool
+				Float         float64
 			}{
 				"bar",
+				`"\`,
 				123,
 				true,
 				4.56,
@@ -222,7 +224,8 @@ func TestEncoder(t *testing.T) {
 			}
 
 			assert.NoError(t, err, test.ID)
-			assert.EqualValues(t,
+			assert.EqualValues(
+				t,
 				string(expected),
 				string(actual),
 				fmt.Sprintf("%s\nExpected:\n%s\nActual:\n%s", test.ID, expected, actual),

nodes.go

@@ -207,10 +207,12 @@ func encodeMap(in reflect.Value) (ast.Node, []*ast.ObjectKey, error) {
 			itemKey := &ast.ObjectKey{Token: tkn}
 			for _, obj := range typ.Items {
 				keys := append([]*ast.ObjectKey{itemKey}, obj.Keys...)
-				l = append(l, &ast.ObjectItem{
-					Keys: keys,
-					Val:  obj.Val,
-				})
+				l = append(
+					l, &ast.ObjectItem{
+						Keys: keys,
+						Val:  obj.Val,
+					},
+				)
 			}
 
 		default:
@@ -306,10 +308,12 @@ func encodeStruct(in reflect.Value) (ast.Node, []*ast.ObjectKey, error) {
 		if objectList, ok := val.(*ast.ObjectList); ok {
 			for _, obj := range objectList.Items {
 				objectKeys := append([]*ast.ObjectKey{itemKey}, obj.Keys...)
-				list.Add(&ast.ObjectItem{
-					Keys: objectKeys,
-					Val:  obj.Val,
-				})
+				list.Add(
+					&ast.ObjectItem{
+						Keys: objectKeys,
+						Val:  obj.Val,
+					},
+				)
 			}
 			continue
 		}
@@ -366,13 +370,18 @@ func tokenize(in reflect.Value, unquotedString bool) (t token.Token, err error)
 		}
 		return token.Token{
 			Type: token.STRING,
-			Text: fmt.Sprintf(`"%s"`, in.String()),
+			Text: fmt.Sprintf(`"%s"`, escapeString(in.String())),
 		}, nil
 	}
 
 	return t, fmt.Errorf("cannot encode primitive kind %s to token", in.Kind())
 }
 
+// escapes \ and "
+func escapeString(s string) string {
+	return strings.ReplaceAll(strings.ReplaceAll(s, `\`, `\\`), `"`, `\"`)
+}
+
 // extractFieldMeta pulls information about struct fields and the optional HCL tags
 func extractFieldMeta(f reflect.StructField) (meta fieldMeta) {
 	if f.Anonymous {

nodes_test.go

@@ -120,9 +120,11 @@ func TestEncodePrimitive(t *testing.T) {
 		},
 	}
 
-	RunAll(tests, func(value reflect.Value) (ast.Node, []*ast.ObjectKey, error) {
-		return encodePrimitive(value, false)
-	}, t)
+	RunAll(
+		tests, func(value reflect.Value) (ast.Node, []*ast.ObjectKey, error) {
+			return encodePrimitive(value, false)
+		}, t,
+	)
 }
 
 func TestEncodeList(t *testing.T) {
@@ -239,9 +241,11 @@ func TestEncodeList(t *testing.T) {
 		},
 	}
 
-	RunAll(tests, func(in reflect.Value) (ast.Node, []*ast.ObjectKey, error) {
-		return encodeList(in, false)
-	}, t)
+	RunAll(
+		tests, func(in reflect.Value) (ast.Node, []*ast.ObjectKey, error) {
+			return encodeList(in, fieldMeta{})
+		}, t,
+	)
 }
 
 func TestEncodeMap(t *testing.T) {
@@ -290,16 +294,18 @@ func TestEncodeMap(t *testing.T) {
 		},
 		{
 			ID: "keyed list",
-			Input: reflect.ValueOf(map[string][]map[string]interface{}{
-				"obj1": {
-					{"foo": "bar"},
-					{"boo": "hoo"},
-				},
-				"obj2": {
-					{"foo": "bar"},
-					{"boo": "hoo"},
+			Input: reflect.ValueOf(
+				map[string][]map[string]interface{}{
+					"obj1": {
+						{"foo": "bar"},
+						{"boo": "hoo"},
+					},
+					"obj2": {
+						{"foo": "bar"},
+						{"boo": "hoo"},
+					},
 				},
-			}),
+			),
 			Expected: &ast.ObjectType{List: &ast.ObjectList{Items: []*ast.ObjectItem{
 				&ast.ObjectItem{
 					Keys: []*ast.ObjectKey{{Token: token.Token{Type: token.IDENT, Text: "obj1"}}},