Fix decoding of quoted keys

This removes a few issues related to quoted keys:

- Escape sequences now work in table headers and KeyValue keys.
- Empty keys are allowed when quoted.
- The decoder doesn't see the quotes anymore. This already worked
  for (inline) tables because the parser split the key manually after
  decoding, removing quotes. The new version integrates the splitting
  into the grammar so there is only one place that handles keys.

Fixes #37

decode_test.go

@@ -780,7 +780,7 @@ d = 2`, nil,
 		},
 		{
 			data:   `"-" = "value"`,
-			err:    lineError(1, fmt.Errorf("field corresponding to `\"-\"' is not defined in toml.testIgnoredFieldStruct")),
+			err:    lineError(1, fmt.Errorf("field corresponding to `-' is not defined in toml.testIgnoredFieldStruct")),
 			expect: &testIgnoredFieldStruct{},
 		},
 		{
@@ -1192,6 +1192,24 @@ foo = 1
 `,
 			expect: map[string]interface{}{"name": "evan", "foo": int64(1)},
 		},
+		{
+			data: `[""]
+a = 1
+`,
+			expect: map[string]interface{}{"": map[string]interface{}{"a": int64(1)}},
+		},
+		{
+			data: `["table"]
+a = 1
+`,
+			expect: map[string]interface{}{"table": map[string]interface{}{"a": int64(1)}},
+		},
+		{
+			data: `["\u2222"]
+		a = 1
+		`,
+			expect: map[string]interface{}{"\u2222": map[string]interface{}{"a": int64(1)}},
+		},
 		{
 			data: `[p]
 first = "evan"
@@ -1204,6 +1222,13 @@ bar = 2
 `,
 			expect: map[testTextUnmarshaler]int{"Unmarshaled: foo": 1, "Unmarshaled: bar": 2},
 		},
+		{
+			data: `"foo" = 1
+"foo.bar" = 2
+`,
+			expect: map[testTextUnmarshaler]int{"Unmarshaled: foo": 1, "Unmarshaled: foo.bar": 2},
+		},
+
 		{
 			data: `1 = 1
 -2 = 2
@@ -1229,6 +1254,13 @@ func TestUnmarshal_WithQuotedKeyValue(t *testing.T) {
 	}
 
 	testUnmarshal(t, []testcase{
+		{data: `"a" = 1`, expect: map[string]int{"a": 1}},
+		{data: `"a.b" = 1`, expect: map[string]int{"a.b": 1}},
+		{data: `"\u2222" = 1`, expect: map[string]int{"\u2222": 1}},
+		{data: `"\"" = 1`, expect: map[string]int{"\"": 1}},
+		{data: `"" = 1`, expect: map[string]int{"": 1}},
+		{data: `'a' = 1`, expect: map[string]int{}, err: lineError(1, errParse)},
+		// Inline tables:
 		{
 			data: `
 [table]
@@ -1238,6 +1270,14 @@ func TestUnmarshal_WithQuotedKeyValue(t *testing.T) {
 				"some.key": {Truthy: true},
 			}},
 		},
+		{
+			data: `
+"some.key" = [{truthy = true}]
+`,
+			expect: map[string][]nestedStruct{
+				"some.key": {{Truthy: true}},
+			},
+		},
 	})
 }
 

parse.go

@@ -97,6 +97,7 @@ type toml struct {
 	currentTable *ast.Table
 	s            string
 	key          string
+	tableKeys    []string
 	val          ast.Value
 	arr          *array
 	stack        []*stack
@@ -180,12 +181,12 @@ func (p *tomlParser) SetArray(begin, end int) {
 }
 
 func (p *toml) SetTable(buf []rune, begin, end int) {
-	p.setTable(p.table, buf, begin, end)
+	rawName := string(buf[begin:end])
+	p.setTable(p.table, rawName, p.tableKeys)
+	p.tableKeys = nil
 }
 
-func (p *toml) setTable(parent *ast.Table, buf []rune, begin, end int) {
-	name := string(buf[begin:end])
-	names := splitTableKey(name)
+func (p *toml) setTable(parent *ast.Table, name string, names []string) {
 	parent, err := p.lookupTable(parent, names[:len(names)-1])
 	if err != nil {
 		p.Error(err)
@@ -230,12 +231,12 @@ func (p *tomlParser) SetTableString(begin, end int) {
 }
 
 func (p *toml) SetArrayTable(buf []rune, begin, end int) {
-	p.setArrayTable(p.table, buf, begin, end)
+	rawName := string(buf[begin:end])
+	p.setArrayTable(p.table, rawName, p.tableKeys)
+	p.tableKeys = nil
 }
 
-func (p *toml) setArrayTable(parent *ast.Table, buf []rune, begin, end int) {
-	name := string(buf[begin:end])
-	names := splitTableKey(name)
+func (p *toml) setArrayTable(parent *ast.Table, name string, names []string) {
 	parent, err := p.lookupTable(parent, names[:len(names)-1])
 	if err != nil {
 		p.Error(err)
@@ -260,11 +261,11 @@ func (p *toml) setArrayTable(parent *ast.Table, buf []rune, begin, end int) {
 func (p *toml) StartInlineTable() {
 	p.skip = false
 	p.stack = append(p.stack, &stack{p.key, p.currentTable})
-	buf := []rune(p.key)
+	names := []string{p.key}
 	if p.arr == nil {
-		p.setTable(p.currentTable, buf, 0, len(buf))
+		p.setTable(p.currentTable, names[0], names)
 	} else {
-		p.setArrayTable(p.currentTable, buf, 0, len(buf))
+		p.setArrayTable(p.currentTable, names[0], names)
 	}
 }
 
@@ -282,6 +283,13 @@ func (p *toml) AddLineCount(i int) {
 
 func (p *toml) SetKey(buf []rune, begin, end int) {
 	p.key = string(buf[begin:end])
+	if len(p.key) > 0 && p.key[0] == '"' {
+		p.key = p.unquote(p.key)
+	}
+}
+
+func (p *toml) AddTableKey() {
+	p.tableKeys = append(p.tableKeys, p.key)
 }
 
 func (p *toml) AddKeyValue() {
@@ -352,25 +360,3 @@ func (p *toml) lookupTable(t *ast.Table, keys []string) (*ast.Table, error) {
 	}
 	return t, nil
 }
-
-func splitTableKey(tk string) []string {
-	key := make([]byte, 0, 1)
-	keys := make([]string, 0, 1)
-	inQuote := false
-	for i := 0; i < len(tk); i++ {
-		k := tk[i]
-		switch {
-		case k == tableSeparator && !inQuote:
-			keys = append(keys, string(key))
-			key = key[:0] // reuse buffer.
-		case k == '"':
-			inQuote = !inQuote
-		case (k == ' ' || k == '\t') && !inQuote:
-			// skip.
-		default:
-			key = append(key, k)
-		}
-	}
-	keys = append(keys, string(key))
-	return keys
-}

parse.peg

@@ -29,7 +29,7 @@ key <- bareKey / quotedKey
 
 bareKey <- <[0-9A-Za-z\-_]+> { p.SetKey(p.buffer, begin, end) }
 
-quotedKey <- '"' <basicChar+> '"' { p.SetKey(p.buffer, begin-1, end+1) }
+quotedKey <- < '"' basicChar* '"' > { p.SetKey(p.buffer, begin, end) }
 
 val <- (
     <datetime>    { p.SetTime(begin, end) }
@@ -55,7 +55,9 @@ inlineTable <- (
 
 inlineTableKeyValues <- (keyval inlineTableValSep?)*
 
-tableKey <- key (tableKeySep key)*
+tableKey <- tableKeyComp (tableKeySep tableKeyComp)*
+
+tableKeyComp <- key { p.AddTableKey() }
 
 tableKeySep <- ws '.' ws