Fix object parsing

Author: lujjjh

Sources/JSONPatcher/JSONCParser.swift

@@ -10,7 +10,9 @@ class JSONCParser {
         try scanNext()
         let value = try parseValue()
         guard scanner.token.kind == .eof else {
-            throw ParsingError.eofExpected(loc: scanner.token.loc)
+            throw ParsingError.unexpectedToken(loc: scanner.token.loc,
+                                               got: scanner.token.kind,
+                                               wanted: .eof)
         }
         return value
     }
@@ -35,7 +37,7 @@ class JSONCParser {
         case .unknown:
             fatalError()
         case .eof:
-            throw ParsingError.valueExpected(loc: token.loc)
+            throw ParsingError.valueExpected(loc: token.loc, got: .eof)
         case .leftBrace:
             return try parseObject()
         case .leftBracket:
@@ -56,7 +58,7 @@ class JSONCParser {
             try scanNext()
             return .null(token)
         default:
-            throw ParsingError.unexpectedToken(loc: token.loc, kind: token.kind)
+            throw ParsingError.unexpectedToken(loc: token.loc, got: token.kind)
         }
     }
 
@@ -74,23 +76,22 @@ class JSONCParser {
             break parseMembers
         case .comma:
             if !needsComma {
-                throw ParsingError.valueExpected(loc: scanner.token.loc)
+                throw ParsingError.valueExpected(loc: scanner.token.loc, got: .comma)
             }
             try scanNext() // ,
-        default:
+        case let kind:
             if needsComma {
-                throw ParsingError.commaExpected(loc: scanner.token.loc)
+                throw ParsingError.unexpectedToken(loc: scanner.token.loc, got: kind, wanted: .comma)
             }
         }
 
     parseMember: do {
         guard scanner.token.kind == .string else {
-            throw ParsingError.memberNameExpected(loc: scanner.token.loc)
+            throw ParsingError.memberNameExpected(loc: scanner.token.loc, got: scanner.token.kind)
         }
         let memberName = try parseValue()
-        try scanNext() // memberName
         guard scanner.token.kind == .colon else {
-            throw ParsingError.colonExpected(loc: scanner.token.loc)
+            throw ParsingError.unexpectedToken(loc: scanner.token.loc, got: scanner.token.kind, wanted: .colon)
         }
         try scanNext() // :
         let memberValue = try parseValue()
@@ -102,7 +103,7 @@ class JSONCParser {
 
         let rightBrace = scanner.token
         guard rightBrace.kind == .rightBrace else {
-            throw ParsingError.rightBraceExpected(loc: rightBrace.loc)
+            throw ParsingError.unexpectedToken(loc: rightBrace.loc, got: rightBrace.kind, wanted: .rightBrace)
         }
         try scanNext() // }
 
@@ -123,12 +124,12 @@ class JSONCParser {
             break parseElements
         case .comma:
             if !needsComma {
-                throw ParsingError.valueExpected(loc: scanner.token.loc)
+                throw ParsingError.valueExpected(loc: scanner.token.loc, got: .comma)
             }
             try scanNext() // ,
-        default:
+        case let kind:
             if needsComma {
-                throw ParsingError.commaExpected(loc: scanner.token.loc)
+                throw ParsingError.unexpectedToken(loc: scanner.token.loc, got: kind, wanted: .comma)
             }
         }
 
@@ -142,7 +143,7 @@ class JSONCParser {
 
         let rightBracket = scanner.token
         guard rightBracket.kind == .rightBracket else {
-            throw ParsingError.rightBracketExpected(loc: rightBracket.loc)
+            throw ParsingError.unexpectedToken(loc: rightBracket.loc, got: rightBracket.kind, wanted: .rightBracket)
         }
         try scanNext() // ]
 

Sources/JSONPatcher/Scanner.swift

@@ -62,12 +62,7 @@ enum ParsingError: Error {
     case invalidCharacter(loc: Loc, character: Character)
     case unexpectedEndOfString(loc: Loc)
     case invalidNumberDigit(loc: Loc, character: Character)
-    case valueExpected(loc: Loc)
-    case unexpectedToken(loc: Loc, kind: JSONCScanner.Token.Kind)
-    case commaExpected(loc: Loc)
-    case memberNameExpected(loc: Loc)
-    case colonExpected(loc: Loc)
-    case rightBraceExpected(loc: Loc)
-    case rightBracketExpected(loc: Loc)
-    case eofExpected(loc: Loc)
+    case unexpectedToken(loc: Loc, got: JSONCScanner.Token.Kind, wanted: JSONCScanner.Token.Kind? = nil)
+    case valueExpected(loc: Loc, got: JSONCScanner.Token.Kind)
+    case memberNameExpected(loc: Loc, got: JSONCScanner.Token.Kind)
 }

Tests/JSONPatcherTests/JSONCParserTests.swift

@@ -6,7 +6,39 @@ final class JSONCParserTests: XCTestCase {
         continueAfterFailure = false
     }
 
-    func testParse() throws {
-        XCTAssertEqual(try JSONCParser(jsoncString: "//comment\n[1, 42.0, /*\"Hello\", */\"World\"]").parse().encode(), "[1,42.0,\"World\"]")
+    // https://github.com/microsoft/node-jsonc-parser/blob/main/src/test/json.test.ts
+    func testParseLiterals() throws {
+        try assertValidParse("true", "true")
+        try assertValidParse("false", "false")
+        try assertValidParse("null", "null")
+        try assertValidParse("\"foo\"", "\"foo\"")
+        try assertValidParse("9//comment", "9")
+    }
+
+    func testParseObjects() throws {
+        try assertValidParse("{}", "{}")
+        try assertValidParse(#"{ "foo": true }"#, #"{"foo":true}"#)
+        try assertValidParse(#"{ "bar": 8, "xoo": "foo" }"#, #"{"bar":8,"xoo":"foo"}"#)
+        try assertValidParse(#"{ "hello": [], "world": {} }"#, #"{"hello":[],"world":{}}"#)
+        try assertValidParse(#"{ "a": false, "b": true, "c": [ 7.4 ] }"#, #"{"a":false,"b":true,"c":[7.4]}"#)
+        try assertValidParse(#"{ "lineComment": "//", "blockComment": ["/*", "*/"], "brackets": [ ["{", "}"], ["[", "]"], ["(", ")"] ] }"#, #"{"lineComment":"//","blockComment":["/*","*/"],"brackets":[["{","}"],["[","]"],["(",")"]]}"#)
+        try assertValidParse(#"{ "hello": [], "world": {} }"#, #"{"hello":[],"world":{}}"#)
+        try assertValidParse(#"{ "hello": { "again": { "inside": 5 }, "world": 1 }}"#, #"{"hello":{"again":{"inside":5},"world":1}}"#)
+        try assertValidParse(#"{ "foo": /*hello*/true }"#, #"{"foo":true}"#)
+        try assertValidParse(#"{ "": true }"#, #"{"":true}"#)
+    }
+
+    func testParseArrays() throws {
+        try assertValidParse("[]", "[]");
+        try assertValidParse("[ [],  [ [] ]]", "[[],[[]]]");
+        try assertValidParse("[ 1, 2, 3 ]", "[1,2,3]");
+        try assertValidParse(#"[ { "a": null } ]"#, #"[{"a":null}]"#);
+    }
+
+    private func assertValidParse(_ jsoncString: String, _ expected: String,
+                             in file: StaticString = #file,
+                             line: UInt = #line) throws {
+        let value = try JSONCParser(jsoncString: jsoncString).parse()
+        XCTAssertEqual(value.encode(), expected, file: file, line: line)
     }
 }