Finish implementing new JSON writer

2 files changed, 355 insertions, 253 deletions

diff --git a/json/write.go b/json/write.go
index 97b3f4e..c2a220e 100644
--- a/json/write.go
+++ b/json/write.go
@@ -4,32 +4,8 @@ import (
 	"bufio"
 	"fmt"
 	"main/walk"
-	// "text/scanner"
 )
 
-func isInt(segment walk.PathSegment) bool {
-	_, isInt := segment.(int)
-	return isInt
-}
-
-func isString(segment walk.PathSegment) bool {
-	_, isString := segment.(string)
-	return isString
-}
-
-func segmentEqual(left walk.PathSegment, right walk.PathSegment) bool {
-	switch left := left.(type) {
-	case int:
-		_, isInt := right.(int)
-		return isInt
-	case string:
-		right, isString := right.(string)
-		return isString && left == right
-	default:
-		panic("Invalid path segment type")
-	}
-}
-
 type JSONWriterState int
 const (
 	JSONWriterStateBeforeValue JSONWriterState = iota
@@ -232,275 +208,260 @@ func (writer *JSONWriter) navigateTo(keepLen int, path []walk.PathSegment, state
 	}
 }
 
-func (writer *JSONWriter) Write(value walk.Value) error {
-	return nil
-}
+func (writer *JSONWriter) inMapAt(keepLen int, path []walk.PathSegment) bool {
+	if keepLen < len(path) {
+		return false
+	}
 
-func (writer *JSONWriter) pathWrite(value walk.Value, path []walk.PathSegment) error {
-	switch value := value.(type) {
-	case walk.NullValue:
-		return writer.write(path, value)
-	case walk.BoolValue:
-		return writer.write(path, value)
-	case walk.NumberValue:
-		return writer.write(path, value)
-	case walk.StringValue:
-		return writer.write(path, value)
-	case walk.ArrayValue:
-		if len(value) == 0 {
-			return writer.write(path, value)
-		} else {
-			for _, element := range value {
-				err := writer.pathWrite(element.Value, append(path, element.Index))
-				if err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	case walk.MapValue:
-		if len(value) == 0 {
-			return writer.write(path, value)
-		} else {
-			for _, element := range value {
-				err := writer.pathWrite(element.Value, append(path, element.Key))
-				if err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-	case walk.RuneValue:
-		panic("Cannot write rune value")
-	default:
-		panic("Unrecognised value type")
+	if keepLen == len(writer.path) {
+		return writer.state == JSONWriterStateInMap
 	}
+
+	_, isString := writer.path[keepLen].(string)
+	return isString
 }
 
-func (writer *JSONWriter) indent(level int) {
-	for i := 0; i < level; i += 1 {
-		writer.writer.WriteRune('\t')
+func (writer *JSONWriter) inArrayAt(keepLen int, path []walk.PathSegment) bool {
+	if keepLen < len(path) {
+		return false
+	}
+
+	if keepLen == len(writer.path) {
+		return writer.state == JSONWriterStateInArray
 	}
+
+	_, isInt := writer.path[keepLen].(int)
+	return isInt
 }
 
-func (writer *JSONWriter) write(targetPath []walk.PathSegment, value walk.Value) error {
-	diversionPoint := 0
-	for diversionPoint < len(writer.path) && diversionPoint < len(targetPath) && segmentEqual(writer.path[diversionPoint], targetPath[diversionPoint]) {
-		diversionPoint += 1
+func countPrefix(current []walk.PathSegment, target []walk.PathSegment) int {
+	for i, c := range current {
+		if i >= len(target) || c != target[i] {
+			return i
+		}
 	}
+	return len(current)
+}
 
-	switch writer.state {
-	case JSONWriterStateBeforeValue:
-		goto beforeValue
-	case JSONWriterStateAfterValue:
-		goto afterValue
-	case JSONWriterStateInArray:
-		goto inArray
-	case JSONWriterStateInMap:
-		goto inMap
+/*
+{
+	"a": {
+		"b": {
+			"c": null
+		},
+		"d": [],
+		"e": {},
+		"f": {"g": 5}
 	}
+}
 
-	beforeValue: {
-		if diversionPoint < len(writer.path) {
-			panic("Writing a value before doing a necessary leave")
-		}
-		if diversionPoint < len(targetPath) {
-			segment := targetPath[diversionPoint]
-			switch segment.(type) {
-			case int:
-				writer.writer.WriteString("[\n")
-				goto inArray
-			case string:
-				writer.writer.WriteString("{\n")
-				goto inMap
-			default:
-				panic("Invalid path segment")
-			}
-		}
+write(true, true, [], {"a": ...})
+	write(true, true, ["a"], {"b": ..., "d": [], "e": {}, "f": ...})
+		write(true, false, ["a", "b"], {"c": null})
+			write(true, false, ["a", "b", "c"], null)
+				navigateTo(["a", "b", "c"], BeforeValue)
+			> null
+		> }
+	> , "d":
+		write(false, false, ["a", "d"], [])
+		> []
+	> , "e":
+		write(false, false, ["a", "e"], {})
+		> {}
+	> , "f":
+		write(false, true, ["a", "f"], {"g": 5})
+		> {"g":
+			write(false, true, ["a", "f", "g"], 5)
+			> 5
+			path = ["a", "f", "g"]
+			state = AfterValue
+*/
 
-		switch value := value.(type) {
-		case walk.NullValue:
-			writer.writer.WriteString("null")
+/*
+{
+	"a": {}
+}
+
+write(true, true, [], {"a": {}})
+	write(true, true, ["a"], {})
+		if not in map at ["a"]
+			navigateTo(["a"], InMap)
+*/
+
+/*
+{
+	"a": {},
+	"b": null,
+	"c": {}
+}
+
+write(true, true, [], {...})
+	write(true, false, ["a"], {})
+		if in map at ["a"]
+			navigateTo(["a"], AfterValue)
+		else
+			navigateTo(["a"], BeforeValue)
+			> {}
+> , "b":
+	write(false, false, ["b"], null)
+	> null
+> , "c":
+	write(false, true, ["c"], {})
+	> {
+	path = ["c"]
+	state = InMap
+*/
+
+func (writer *JSONWriter) write(first bool, last bool, path []walk.PathSegment, value walk.Value) {
+	switch value := value.(type) {
+	case walk.NullValue:
+		if first {
+			keepLen := countPrefix(writer.path, path)
+			writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateBeforeValue)
+		}
+		writer.writer.WriteString("null")
+		if last {
+			writer.path = path
 			writer.state = JSONWriterStateAfterValue
-			return nil
-		case walk.BoolValue:
-			if value {
-				writer.writer.WriteString("true")
-			} else {
-				writer.writer.WriteString("false")
-			}
+		}
+	case walk.BoolValue:
+		if first {
+			keepLen := countPrefix(writer.path, path)
+			writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateBeforeValue)
+		}
+		if value {
+			writer.writer.WriteString("true")
+		} else {
+			writer.writer.WriteString("false")
+		}
+		if last {
+			writer.path = path
 			writer.state = JSONWriterStateAfterValue
-			return nil
-		case walk.NumberValue:
-			writer.writer.WriteString(fmt.Sprintf("%v", value))
+		}
+	case walk.NumberValue:
+		if first {
+			keepLen := countPrefix(writer.path, path)
+			writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateBeforeValue)
+		}
+		fmt.Fprintf(writer.writer, "%v", value)
+		if last {
+			writer.path = path
 			writer.state = JSONWriterStateAfterValue
-			return nil
-		case walk.StringValue:
-			writer.writer.WriteString(fmt.Sprintf("%q", value))
+		}
+	case walk.StringValue:
+		if first {
+			keepLen := countPrefix(writer.path, path)
+			writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateBeforeValue)
+		}
+		fmt.Fprintf(writer.writer, "%q", value)
+		if last {
+			writer.path = path
 			writer.state = JSONWriterStateAfterValue
-			return nil
-		case walk.ArrayValue:
-			// TODO: write the contents of the structures
-			writer.writer.WriteString("[\n")
-			writer.state = JSONWriterStateInArray
-			return nil
-		case walk.MapValue:
-			writer.writer.WriteString("{\n")
-			writer.state = JSONWriterStateInMap
-			return nil
-		default:
-			panic("Invalid value type")
 		}
-	}
-
-	afterValue: {
-		if diversionPoint < len(writer.path) {
-			if diversionPoint == len(writer.path) - 1 && diversionPoint < len(targetPath) {
-				segment := writer.path[diversionPoint]
-				switch segment.(type) {
-				case int:
-					_, isNumber := targetPath[diversionPoint].(walk.NumberValue)
-					if isNumber {
-						writer.writer.WriteString(",\n")
-						writer.path = writer.path[:diversionPoint]
-						goto inArray
+	case walk.ArrayValue:
+		if len(value) == 0 {
+			if first {
+				if last {
+					keepLen := countPrefix(writer.path, path)
+					if !writer.inArrayAt(keepLen, path[keepLen:]) {
+						writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateInArray)
 					}
-				case string:
-					_, isString := targetPath[diversionPoint].(walk.StringValue)
-					if isString {
-						writer.writer.WriteString(",\n")
-						writer.path = writer.path[:diversionPoint]
-						goto inMap
+				} else {
+					keepLen := countPrefix(writer.path, path)
+					if writer.inArrayAt(keepLen, path[keepLen:]) {
+						writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateAfterValue)
+					} else {
+						writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateBeforeValue)
+						writer.writer.WriteString("[]")
 					}
-				default:
-					panic("Invalid segment type")
+				}
+			} else {
+				if last {
+					writer.writer.WriteRune('[')
+					writer.path = path
+					writer.state = JSONWriterStateInArray
+				} else {
+					writer.writer.WriteString("[]")
 				}
 			}
-
-			writer.writer.WriteString("\n")
-			switch writer.path[len(writer.path) - 1].(type) {
-			case int:
-				writer.path = writer.path[:len(writer.path) - 1]
-				goto inArray
-			case string:
-				writer.path = writer.path[:len(writer.path) - 1]
-				goto inMap
-			default:
-				panic("Invalid segment type")
+		} else {
+			if !first {
+				writer.writer.WriteRune('[')
 			}
-		}
-
-		// TODO: handle len(writer.path) == 0
-		if diversionPoint < len(targetPath) {
-			if len(writer.path) == 0 {
-				writer.writer.WriteString("\n")
-				goto beforeValue
+			for i, el := range value {
+				if i != 0 {
+					writer.writer.WriteRune(',')
+				}
+				writer.write(first && i == 0, last && i == len(value) - 1, append(path, el.Index), el.Value)
 			}
-			segment := writer.path[diversionPoint - 1]
-			writer.writer.WriteString(",")
-			diversionPoint--
-			writer.path = writer.path[:diversionPoint]
-			switch segment.(type) {
-			case int:
-				goto inArray
-			case string:
-				goto inMap
-			default:
-				panic("Invalid segment type")
+			if !last {
+				writer.writer.WriteRune(']')
 			}
 		}
-
-		if len(writer.path) == 0 {
-			writer.writer.WriteString("\n")
-			goto beforeValue
-		}
-		segment := writer.path[diversionPoint - 1]
-		writer.writer.WriteString(",\n")
-		diversionPoint--
-		writer.path = writer.path[:diversionPoint]
-		switch segment.(type) {
-		case int:
-			goto inArray
-		case string:
-			goto inMap
-		default:
-			panic("Invalid segment type")
-		}
-	}
-
-	inArray: {
-		if diversionPoint < len(writer.path) {
-			writer.indent(len(writer.path))
-			writer.writer.WriteString("]")
-			goto afterValue
-		}
-
-		if diversionPoint < len(targetPath) {
-			switch s := targetPath[diversionPoint].(type) {
-			case int:
-				writer.path = append(writer.path, s)
-				diversionPoint++
-				writer.indent(len(writer.path))
-				goto beforeValue
-			case string:
-				writer.indent(len(writer.path))
-				writer.writer.WriteString("]")
-				goto afterValue
-			default:
-				panic("Invalid segment type")
+	case walk.MapValue:
+		if len(value) == 0 {
+			if first {
+				if last {
+					keepLen := countPrefix(writer.path, path)
+					if !writer.inMapAt(keepLen, path[keepLen:]) {
+						writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateInMap)
+					}
+				} else {
+					keepLen := countPrefix(writer.path, path)
+					if writer.inMapAt(keepLen, path[keepLen:]) {
+						writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateAfterValue)
+					} else {
+						writer.navigateTo(keepLen, path[keepLen:], JSONWriterStateBeforeValue)
+						writer.writer.WriteString("{}")
+					}
+				}
+			} else {
+				if last {
+					writer.writer.WriteRune('{')
+					writer.path = path
+					writer.state = JSONWriterStateInMap
+				} else {
+					writer.writer.WriteString("{}")
+				}
 			}
-		}
-
-		writer.indent(len(writer.path))
-		writer.writer.WriteString("]")
-		goto afterValue
-	}
-
-	inMap: {
-		if diversionPoint < len(writer.path) {
-			writer.indent(len(writer.path))
-			writer.writer.WriteString("}")
-			goto afterValue
-		}
-
-		if diversionPoint < len(targetPath) {
-			switch s := targetPath[diversionPoint].(type) {
-			case int:
-				writer.indent(len(writer.path))
-				writer.writer.WriteString("}")
-				goto afterValue
-			case string:
-				writer.path = append(writer.path, s)
-				diversionPoint++
-				writer.indent(len(writer.path))
-				writer.writer.WriteString(fmt.Sprintf("%q: ", s))
-				goto beforeValue
+		} else {
+			if !first {
+				writer.writer.WriteRune('{')
+			}
+			for i, el := range value {
+				if i != 0 {
+					writer.writer.WriteRune(',')
+				}
+				if i != 0 || !first {
+					fmt.Fprintf(writer.writer, "%q:", el.Key)
+				}
+				writer.write(first && i == 0, last && i == len(value) - 1, append(path, el.Key), el.Value)
+			}
+			if !last {
+				writer.writer.WriteRune('}')
 			}
 		}
-
-		writer.indent(len(writer.path))
-		writer.writer.WriteString("}")
-		goto afterValue
 	}
 }
 
+func (writer *JSONWriter) Write(value walk.Value) error {
+	writer.write(true, true, nil, value)
+	return nil
+}
+
 func (writer *JSONWriter) AssertDone() {
 	switch writer.state {
 	case JSONWriterStateInArray:
-		writer.writer.WriteString("]")
+		writer.writer.WriteRune(']')
 	case JSONWriterStateInMap:
-		writer.writer.WriteString("}")
+		writer.writer.WriteRune('}')
 	}
 	for i := len(writer.path) - 1; i >= 0; i -= 1 {
 		switch writer.path[i].(type) {
 		case int:
-			writer.writer.WriteString("\n")
-			writer.indent(i)
-			writer.writer.WriteString("]")
+			writer.writer.WriteRune(']')
 		case string:
-			writer.writer.WriteString("\n")
-			writer.indent(i)
-			writer.writer.WriteString("}")
+			writer.writer.WriteRune('}')
 		default:
 			panic("Invalid path segment type")
 		}
diff --git a/json/write_test.go b/json/write_test.go
index 508ccfa..05b228e 100644
--- a/json/write_test.go
+++ b/json/write_test.go
@@ -103,3 +103,144 @@ func TestNavigateTo(t *testing.T) {
 		}
 	}
 }
+
+func TestWrite(t *testing.T) {
+	type testCase struct {
+		values []walk.Value
+		expected string
+	}
+
+	tests := []testCase {
+		{
+			values: []walk.Value {
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue {{
+						Key: "b",
+						Value: walk.StringValue("c"),
+					}},
+				}},
+			},
+			expected: `{"a":{"b":"c"}}`,
+		},
+		{
+			values: []walk.Value {
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue {{
+						Key: "b",
+						Value: walk.StringValue("c"),
+					}},
+				}},
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue {{
+						Key: "d",
+						Value: walk.NullValue{},
+					}},
+				}},
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue{},
+				}},
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue {{
+						Key: "e",
+						Value: walk.NumberValue(-4.3),
+					}},
+				}},
+			},
+			expected: `{"a":{"b":"c","d":null,"e":-4.3}}`,
+		},
+		{
+			values: []walk.Value {
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue{{
+						Key: "aa",
+						Value: walk.StringValue("aav"),
+					}},
+				}},
+				walk.MapValue {{
+					Key: "a",
+					Value: walk.MapValue{},
+				}, {
+					Key: "b",
+					Value: walk.MapValue {{
+						Key: "bb",
+						Value: walk.StringValue("bbv"),
+					}},
+				}, {
+					Key: "c",
+					Value: walk.MapValue{},
+				}},
+				walk.MapValue {{
+					Key: "c",
+					Value: walk.MapValue {{
+						Key: "cc",
+						Value: walk.StringValue("ccv"),
+					}},
+				}},
+			},
+			expected: `{"a":{"aa":"aav"},"b":{"bb":"bbv"},"c":{"cc":"ccv"}}`,
+		},
+		{
+			values: []walk.Value {
+				walk.ArrayValue {{
+					Index: 0,
+					Value: walk.ArrayValue {{
+						Index: 5,
+						Value: walk.NumberValue(100),
+					}},
+				}},
+				walk.ArrayValue {{
+					Index: 0,
+					Value: walk.ArrayValue{},
+				}, {
+					Index: 0,
+					Value: walk.ArrayValue{},
+				}},
+				walk.ArrayValue {{
+					Index: 0,
+					Value: walk.NullValue{},
+				}, {
+					Index: 0,
+					Value: walk.ArrayValue{},
+				}},
+				walk.ArrayValue {{
+					Index: 0,
+					Value: walk.ArrayValue{},
+				}},
+				walk.ArrayValue {{
+					Index: 0,
+					Value: walk.ArrayValue {{
+						Index: 200,
+						Value: walk.NumberValue(200),
+					}},
+				}},
+			},
+			expected: `[[100],[],null,[200]]`,
+		},
+	}
+
+	for i, test := range tests {
+		var writer strings.Builder
+		jsonWriter := &JSONWriter {
+			path: nil,
+			writer: bufio.NewWriter(&writer),
+			state: JSONWriterStateBeforeValue,
+		}
+
+		for _, value := range test.values {
+			jsonWriter.Write(value)
+		}
+		jsonWriter.AssertDone()
+
+		jsonWriter.writer.Flush()
+		res := writer.String()
+		if res != test.expected {
+			t.Errorf(`Test %d: Expected '%s' found '%s'`, i, test.expected, res)
+		}
+	}
+}