Merge pull request rarestype#125 from rarestype/convenience-constructors

[minor]: add some common sense convenience constructors to `JSON.Node`

Author: tayloraswift

Sources/JQTests/AccessArrayTests.swift

@@ -145,10 +145,10 @@ import Testing
 
         var nested: JSON.Node = [[[false, true], [true, false]]]
         try nested[0][1] & {
-            $0 = .number(.init(1))
+            $0 = .number(1)
         }
 
-        #expect("\(nested)" == "\([[[false, true], .number(.init(1))]] as JSON.Node)")
+        #expect("\(nested)" == "\([[[false, true], .number(1)]] as JSON.Node)")
 
         try nested[0][] & {
             $0 = [true]

Sources/JQTests/AccessObjectTests.swift

@@ -71,16 +71,16 @@ import Testing
     @Test static func Modify() throws {
         var node: JSON.Node = ["a": ["x": false, "y": true]]
         try node["a"]["y"] & {
-            $0 = .number(.init(1))
+            $0 = .number(1)
         }
 
-        #expect("\(node)" == "\(["a": ["x": false, "y": .number(.init(1))]] as JSON.Node)")
+        #expect("\(node)" == "\(["a": ["x": false, "y": .number(1)]] as JSON.Node)")
 
         try node["a"] & {
-            $0 = .number(.init(1))
+            $0 = .number(1)
         }
 
-        #expect("\(node)" == "\(["a": .number(.init(1))] as JSON.Node)")
+        #expect("\(node)" == "\(["a": .number(1)] as JSON.Node)")
 
         try node["a"] & {
             $0 = [true, false]

Sources/JSONAST/JSON.Node.swift

@@ -20,64 +20,24 @@ extension JSON {
     }
 }
 extension JSON.Node {
-    // TODO: optimize this, it should operate at the utf8 level, and be @inlinable
+    /// A shorthand for constructing the payload of ``string(_:) [case]``.
+    @inlinable public static func string(_ unescaped: consuming String) -> Self {
+        .string(JSON.Literal<String>.init(unescaped))
+    }
 
-    /// Escapes and formats a string as a JSON string literal, including the
-    /// beginning and ending quote characters. This function is used for debug reflection only;
-    /// it is less efficient than the UTF-8 escaping implementation used by the encoder.
-    ///
-    /// -   Parameters:
-    ///     - string: A string to escape.
-    /// -   Returns: A string literal, which includes the `""` delimiters.
-    ///
-    /// This function escapes the following characters: `"`, `\`, `\b`, `\t`, `\n`,
-    /// `\f`, and `\r`. It does not escape forward slashes (`/`).
-    ///
-    /// JSON string literals may contain unicode characters, even after escaping.
-    /// Do not assume the output of this function is ASCII.
-    ///
-    /// >   Important: This function should *not* be called on an input to the ``string(_:)``
-    ///     case  constructor. The library performs string escaping lazily; calling this
-    ///     function explicitly will double-escape the input.
-    // static
-    // func escape<S>(_ string:S) -> String where S:StringProtocol
-    // {
-    //     var escaped:String = "\""
-    //     for character:Character in string
-    //     {
-    //         switch character
-    //         {
-    //         case "\"":      escaped += "\\\""
-    //         case "\\":      escaped += "\\\\"
-    //         // slash escape is not mandatory, and does not improve legibility
-    //         // case "/":       escaped += "\\/"
-    //         case "\u{08}":  escaped += "\\b"
-    //         case "\u{09}":  escaped += "\\t"
-    //         case "\u{0A}":  escaped += "\\n"
-    //         case "\u{0C}":  escaped += "\\f"
-    //         case "\u{0D}":  escaped += "\\r"
-    //         default:        escaped.append(character)
-    //         }
-    //     }
-    //     escaped += "\""
-    //     return escaped
-    // }
-}
-extension JSON.Node: CustomStringConvertible {
-    /// Returns this value serialized as a minified string.
-    ///
-    /// Reparsing and reserializing this string is guaranteed to return the
-    /// same string.
-    public var description: String {
-        switch self {
-        case .null: "null"
-        case .bool(true): "true"
-        case .bool(false): "false"
-        case .string(let self): .init(self)
-        case .number(let self): "\(self)"
-        case .array(let self): "\(self)"
-        case .object(let self): "\(self)"
-        }
+    /// A shorthand for constructing the payload of ``number(_:) [case]``.
+    @inlinable public static func number<T>(_ value: T) -> Self where T: UnsignedInteger {
+        .number(JSON.Number.init(value))
+    }
+    /// A shorthand for constructing the payload of ``number(_:) [case]``.
+    @inlinable public static func number<T>(_ value: T) -> Self where T: SignedInteger {
+        .number(JSON.Number.init(value))
+    }
+    /// A shorthand for constructing the payload of ``number(_:) [case]``.
+    @inlinable public static func number<T>(
+        _ value: T
+    ) -> Self where T: BinaryFloatingPoint & LosslessStringConvertible {
+        .number(JSON.Number.init(value))
     }
 }
 extension JSON.Node: ExpressibleByDictionaryLiteral {
@@ -90,17 +50,33 @@ extension JSON.Node: ExpressibleByArrayLiteral {
         self = .array(.init(arrayLiteral))
     }
 }
-extension JSON.Node: ExpressibleByStringLiteral {
+extension JSON.Node: ExpressibleByStringLiteral, ExpressibleByStringInterpolation {
     @inlinable public init(stringLiteral: String) {
-        self = .string(JSON.Literal<String>.init(stringLiteral))
+        self = .string(stringLiteral)
     }
 }
 extension JSON.Node: ExpressibleByBooleanLiteral {
     @inlinable public init(booleanLiteral: Bool) {
         self = .bool(booleanLiteral)
     }
 }
-
+extension JSON.Node: CustomStringConvertible {
+    /// Returns this value serialized as a minified string.
+    ///
+    /// Reparsing and reserializing this string is guaranteed to return the
+    /// same string.
+    public var description: String {
+        switch self {
+        case .null: "null"
+        case .bool(true): "true"
+        case .bool(false): "false"
+        case .string(let self): .init(self)
+        case .number(let self): "\(self)"
+        case .array(let self): "\(self)"
+        case .object(let self): "\(self)"
+        }
+    }
+}
 extension JSON.Node {
     /// Promotes a `nil` result to a thrown ``TypecastError``.
     ///

Sources/JSONParsing/Rules/JSON.NodeRule.swift

@@ -18,7 +18,7 @@ extension JSON.NodeRule: ParsingRule {
             return .number(number)
         } else if
             let string: String = input.parse(as: JSON.StringRule<Location>?.self) {
-            return .string(JSON.Literal<String>.init(string))
+            return .string(string)
         } else if
             let items: [(JSON.Key, JSON.Node)] = input.parse(as: Object?.self) {
             return .object(.init(items))

Sources/JSONTests/IntegerOverflow.swift

@@ -78,7 +78,7 @@ extension IntegerOverflow {
         where Signed: SignedInteger & JSONDecodable {
         let field: JSON.FieldDecoder<Never?> = .init(
             key: nil,
-            value: .number(.init(value))
+            value: .number(value)
         )
 
         #expect(throws: JSON.DecodingError<Never?>.self) {
@@ -91,7 +91,7 @@ extension IntegerOverflow {
     ) throws where Signed: SignedInteger & JSONDecodable {
         let field: JSON.FieldDecoder<Never?> = .init(
             key: nil,
-            value: .number(.init(value))
+            value: .number(value)
         )
 
         #expect(try field.decode() == value)