Swift: Rely on Swift's Codable and configure it properly for the expected serialization

Author: badboy

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Swift: Rely on Swift's Codable and configure it properly for the expected serialization ([#815](https://github.com/mozilla/glean_parser/pull/815))
+
 ## 18.0.5
 
 - BUGFIX: Kotlin: correctly build a serial descriptor

glean_parser/templates/swift.jinja2

@@ -44,21 +44,22 @@ struct {{ obj.name|Camelize }}{{ suffix }}: EventExtras {
     }
 {% endmacro %}
 
-{%- macro generate_structure(name, struct) %}
+{%- macro generate_structure(name, struct, toplevel) %}
 {%- if struct.type == "oneof" -%}
-    enum {{ name }}: Codable, Equatable, ObjectSerialize {
+    enum {{ name }}: Codable, Equatable {
         {% for ty in struct.subtypes %}
           case {{ty}}({{ty|structure_type_name}})
         {% endfor %}
 
-          func intoSerializedObject() -> String {
-              switch self {
-              {% for ty in struct.subtypes %}
-                case .{{ty}}(let val):
-                    return val.intoSerializedObject()
-              {% endfor %}
-              }
-          }
+        func encode(to __encoder: Encoder) throws {
+            var __container = __encoder.singleValueContainer()
+            switch self {
+            {% for ty in struct.subtypes %}
+              case .{{ty}}(let __val):
+                try __container.encode(__val)
+            {% endfor %}
+            }
+        }
     }
 
 {%- elif struct.type == "array" -%}
@@ -67,7 +68,7 @@ struct {{ obj.name|Camelize }}{{ suffix }}: EventExtras {
     {{ generate_structure(name ~ "Item", struct["items"]) }}
 
 {%- elif struct.type == "object" -%}
-    struct {{ name }}: Codable, Equatable, ObjectSerialize {
+    struct {{ name }}: Codable, Equatable {% if toplevel %}, ObjectSerialize{% endif %} {
         {% for itemname, val in struct.properties.items() %}
           {%- set varname = itemname|camelize|variable_name -%}
           {% if val.type == "array" %}
@@ -81,26 +82,36 @@ struct {{ obj.name|Camelize }}{{ suffix }}: EventExtras {
           {% endif %}
         {% endfor %}
 
-        func intoSerializedObject() -> String {
-            var __obj = [String]()
+        enum CodingKeys: String, CodingKey {
+        {% for itemname, val in struct.properties.items() %}
+          {%- set varname = itemname|camelize|variable_name -%}
+          case {{varname}} = "{{ itemname }}"
+        {% endfor %}
+        }
+
+        func encode(to encoder: Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
             {% for itemname, val in struct.properties.items() %}
-                {%- set varname = itemname|camelize|variable_name -%}
-                {% if val.type == "array" %}
-                if {{varname}}.count > 0 {
-                    let {{varname}} = self.{{varname}}
-                {% else %}
-                if let {{varname}} = self.{{varname}} {
-                {% endif %}
-                    var __elem = "\"{{itemname}}\":"
-                    __elem.append({{varname}}.intoSerializedObject())
-                    __obj.append(__elem)
-                }
+              {%- set varname = itemname|camelize|variable_name -%}
+              {% if val.type == "array" %}
+              if {{varname}}.count > 0 {
+                let {{varname}} = self.{{varname}}
+              {% else %}
+              if let {{varname}} = self.{{varname}} {
+              {% endif %}
+              try container.encode({{varname}}, forKey: .{{varname}})
+              }
             {% endfor %}
-            var __json = "{"
-            __json.append(__obj.joined(separator: ","))
-            __json.append("}")
-            return __json
+    }
+
+        {% if toplevel %}
+        func intoSerializedObject() -> String {
+            let jsonEncoder = JSONEncoder()
+            let jsonData = try! jsonEncoder.encode(self)
+            let json = String(data: jsonData, encoding: String.Encoding.utf8)!
+            return json
         }
+        {% endif %}
     }
 
     {% for itemname, val in struct.properties.items() %}
@@ -191,7 +202,7 @@ extension {{ namespace }} {
     enum {{ category.name|Camelize }} {
     {% for obj in category.objs.values() %}
         {% if obj|attr("_generate_structure") %}
-        {{ generate_structure(obj.name|Camelize ~ "Object", obj._generate_structure) }}
+        {{ generate_structure(obj.name|Camelize ~ "Object", obj._generate_structure, true) }}
         {%- endif %}
         {% if obj|attr("_generate_enums") %}
         {% for name, suffix in obj["_generate_enums"] %}

tests/data/object.yaml

@@ -39,6 +39,28 @@ complex.types:
         items:
           type: boolean
 
+  toplevel_object:
+    type: object
+    description: Top-level object
+    bugs:
+      - https://bugzilla.mozilla.org/11137353
+    data_reviews:
+      - http://example.com/reviews
+    notification_emails:
+      - [email protected]
+    expires: never
+    structure:
+      type: object
+      properties:
+        key1:
+          type: string
+        another_value:
+          type: number
+        sub_array:
+          type: array
+          items:
+            type: number
+
   oneof:
     type: object
     description: |

tests/test_swift.py

@@ -370,12 +370,12 @@ def test_object_metric(tmp_path):
         assert "ObjectMetricType<ThreadsObject>" in content
         assert "typealias ThreadsObject = [ThreadsObjectItem]" in content
         assert (
-            "struct ThreadsObjectItem: Codable, Equatable, ObjectSerialize {" in content
+            "struct ThreadsObjectItem: Codable, Equatable {" in content
         )
         assert "var frames: ThreadsObjectItemFrames" in content
 
         assert (
-            "struct ThreadsObjectItemFramesItem: Codable, Equatable, ObjectSerialize {"
+            "struct ThreadsObjectItemFramesItem: Codable, Equatable {"
             in content
         )
         assert "var moduleIndex: Int64?" in content