Merge pull request SwiftGen#786 from SwiftGen/bugfix/json-integer-parsing

JSON: fix 0/1 integer parsing

Author: djbe

CHANGELOG.md

@@ -37,6 +37,9 @@ _None_
 * JSON/YAML: the `inline` templates incorrectly generated `1`/`0` as values, instead of `true`/`false` as expected.  
   [David Jennes](https://github.com/djbe)
   [#783](https://github.com/SwiftGen/SwiftGen/pull/783)
+* JSON: the parser now correctly recognizes `0` and `1` as `Int` (instead of `Bool`).  
+  [David Jennes](https://github.com/djbe)
+  [#786](https://github.com/SwiftGen/SwiftGen/pull/786)
 
 ### Internal Changes
 

Sources/SwiftGenKit/Utils/Metadata.swift

@@ -31,37 +31,43 @@ enum Metadata {
   /// for complex types (such as arrays and dictionaries), describing the type information of sub-elements (such as an
   /// array's element, or each of a dictionary's properties).
   ///
-  /// Note: this is used for the Plist and YAML Stencil contexts
+  /// Note: this is used for the JSON, Plist and YAML Stencil contexts
   ///
   /// - Parameter data: The value to describe
   /// - Returns: Dictionary with type information about the value (for Stencil context)
   static func generate(for data: Any) -> [String: Any] {
-    switch data {
-    case is String:
+    let dataType = type(of: data)
+
+    // We want to use toll-free briding using `data is X`, to for example easily check if something is a `String` (or
+    // `String`-like). In other cases we actually want to avoid it, and use `dataType == X.self`. TFB to `NSNumber` for
+    // example leads to confusion for ambiguous values (0, 1, true, false, ...). 
+    if data is String {
       return [Key.type: ValueType.string]
-    case is Bool:
+    } else if dataType == Bool.self {
       return [Key.type: ValueType.bool]
-    case is Int:
+    } else if dataType == Int.self {
       return [Key.type: ValueType.int]
-    case is Double:
+    } else if dataType == Double.self {
       return [Key.type: ValueType.double]
-    case is Date:
+    } else if data is Date {
       return [Key.type: ValueType.date]
-    case is Data:
+    } else if data is Data {
       return [Key.type: ValueType.data]
-    case let data as [Any]:
+    } else if let data = data as? NSNumber {
+      return [Key.type: valueType(for: data)]
+    } else if let data = data as? [Any] {
       return [
         Key.type: ValueType.array,
         Key.element: Metadata.describe(arrayElement: data)
       ]
-    case let data as [String: Any]:
+    } else if let data = data as? [String: Any] {
       return [
         Key.type: ValueType.dictionary,
         Key.properties: Metadata.describe(dictionary: data)
       ]
-    case is NSNull, nil:
+    } else if dataType == NSNull.self || Mirror(reflecting: data).displayStyle == .optional {
       return [Key.type: ValueType.optional]
-    default:
+    } else {
       return [Key.type: ValueType.any]
     }
   }
@@ -77,12 +83,8 @@ enum Metadata {
   private static func describe(arrayElement array: [Any]) -> [String: Any] {
     if array is [String] {
       return [Key.type: ValueType.string]
-    } else if array is [Bool] {
-      return [Key.type: ValueType.bool]
-    } else if array is [Int] {
-      return [Key.type: ValueType.int]
-    } else if array is [Double] {
-      return [Key.type: ValueType.double]
+    } else if let array = array as? [NSNumber], let valueType = elementValueType(for: array) {
+      return [Key.type: valueType]
     } else if array is [Date] {
       return [Key.type: ValueType.date]
     } else if array is [Data] {
@@ -104,4 +106,44 @@ enum Metadata {
       ]
     }
   }
+
+  /// Get the value type of a number if possible.
+  ///
+  /// `NSNumber` does not provide an easy way for checking the internal value type. Therefore we first have to check if
+  /// it's a boolean, and if not try to match the CF type to something Swift-y.
+  ///
+  /// - Parameter number: The value to describe
+  /// - Returns: `ValueType` case (may be `any` if no match is found)
+  private static func valueType(for number: NSNumber) -> String {
+    if CFGetTypeID(number) == CFBooleanGetTypeID() {
+      return ValueType.bool
+    } else {
+      switch CFNumberGetType(number) {
+      case .sInt8Type, .sInt16Type, .sInt32Type, .sInt64Type, .charType, .intType, .longType, .longLongType,
+        .nsIntegerType:
+        return ValueType.int
+      case .float32Type, .float64Type, .floatType, .doubleType, .cgFloatType:
+        return ValueType.double
+      default:
+        return ValueType.any
+      }
+    }
+  }
+
+  /// Returns the element value type, if all elements have the same type.
+  ///
+  /// The problem with `NSNumber` arrays is that they can contain mixed content, such as `[0.1, 2, true]`. Therefore,
+  /// we have to check the type of each element.
+  ///
+  /// - Parameter array: The value to describe
+  /// - Returns: `ValueType` case if array is uniform (`nil` otherwise)
+  private static func elementValueType(for array: [NSNumber]) -> String? {
+    let valueTypes = Set(array.map(valueType(for:)))
+
+    if valueTypes.count < 2, let elementType = valueTypes.first {
+      return elementType
+    } else {
+      return nil
+    }
+  }
 }

Sources/SwiftGenKit/Utils/YamsSerialization.swift

@@ -54,14 +54,29 @@ extension NSData: ScalarRepresentable {
 
 extension NSNumber: ScalarRepresentable {
   public func represented() -> Node.Scalar {
-    if let value = Bool(exactly: self) {
-      return value.represented()
-    } else if let value = Double(exactly: self), floor(value) != value {
-      return value.represented()
-    } else if let value = Int(exactly: self) {
-      return value.represented()
+    if CFGetTypeID(self) == CFBooleanGetTypeID() {
+      return boolValue.represented()
     } else {
-      return Double.nan.represented()
+      switch CFNumberGetType(self) {
+      case .sInt8Type:
+        return int8Value.represented()
+      case .sInt16Type:
+        return int16Value.represented()
+      case .sInt32Type:
+        return int32Value.represented()
+      case .sInt64Type:
+        return int64Value.represented()
+      case .charType:
+        return uint8Value.represented()
+      case .intType, .longType, .longLongType, .nsIntegerType:
+        return intValue.represented()
+      case .float32Type, .floatType:
+        return floatValue.represented()
+      case .float64Type, .doubleType, .cgFloatType:
+        return doubleValue.represented()
+      default:
+        return Double.nan.represented()
+      }
     }
   }
 }