Make EditorSettings throw for invalid JSON

Author: jkmassel

android/Gutenberg/src/main/java/org/wordpress/gutenberg/model/EditorSettings.kt

@@ -41,22 +41,18 @@ data class EditorSettings(
          * be cached.
          *
          * @param data The raw JSON string from the block editor settings endpoint.
+         * @throws kotlinx.serialization.SerializationException if [data] is not valid JSON.
          */
         fun fromData(data: String): EditorSettings {
-            val jsonValue = try {
-                json.parseToJsonElement(data)
-            } catch (e: Exception) {
-                null
-            }
+            val jsonValue = json.parseToJsonElement(data)
+            val stringValue = jsonValue.toString().orEmpty()
 
-            val stringValue = jsonValue?.toString() ?: ""
-
-            val themeStyles = try {
-                val settings = json.decodeFromString<InternalEditorSettings>(data)
-                settings.styles.mapNotNull { it.css }.joinToString("\n")
-            } catch (e: Exception) {
-                ""
-            }
+            val themeStyles = runCatching {
+                json.decodeFromString<InternalEditorSettings>(data)
+                    .styles
+                    .mapNotNull { it.css }
+                    .joinToString("\n")
+            }.getOrDefault("")
 
             return EditorSettings(
                 jsonValue = jsonValue,

android/Gutenberg/src/test/java/org/wordpress/gutenberg/model/EditorSettingsTest.kt

@@ -4,13 +4,23 @@ import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
 import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class EditorSettingsTest {
 
     private val json = Json { ignoreUnknownKeys = true }
 
+    @Test
+    fun `throws when JSON is invalid`() {
+        val invalidJSON = "not valid json"
+
+        assertThrows(Exception::class.java, {
+            EditorSettings.fromData(invalidJSON)
+        })
+    }
+
     // MARK: - themeStyles Tests
 
     @Test
@@ -48,13 +58,6 @@ class EditorSettingsTest {
         assertEquals("h1 { font-size: 2em; }", settings.themeStyles)
     }
 
-    @Test
-    fun `themeStyles is empty when JSON is invalid`() {
-        val invalidJSON = "not valid json"
-        val settings = EditorSettings.fromData(invalidJSON)
-        assertTrue(settings.themeStyles.isEmpty())
-    }
-
     @Test
     fun `themeStyles is empty when styles key is missing`() {
         val jsonString = """{"otherKey": "value"}"""

ios/Sources/GutenbergKit/Sources/Model/EditorSettings.swift

@@ -25,18 +25,15 @@ public struct EditorSettings: Sendable, Codable, Equatable, Hashable {
     /// be cached.
     ///
     /// - Parameter data: The raw JSON data from the block editor settings endpoint.
-    init(data: Data) {
-        let json = try? JSON(data)
+    init(data: Data) throws {
+        let json = try JSON(data)
         self.jsonValue = json
 
-        let encodedJSON = try? JSONEncoder().encode(json)
-        self.stringValue = String(decoding: encodedJSON ?? Data(), as: UTF8.self)
+        let encodedJSON = try JSONEncoder().encode(json)
+        self.stringValue = String(decoding: encodedJSON, as: UTF8.self)
 
-        if let settings = try? JSONDecoder().decode(InternalEditorSettings.self, from: data) {
-            self.themeStyles = settings.styles.compactMap { $0.css }.joined(separator: "\n")
-        } else {
-            self.themeStyles = ""
-        }
+        let settings = try JSONDecoder().decode(InternalEditorSettings.self, from: data)
+        self.themeStyles = settings.styles?.compactMap { $0.css }.joined(separator: "\n") ?? ""
     }
 
     private init(
@@ -67,5 +64,5 @@ struct InternalEditorSettings: Decodable {
     }
 
     /// All style entries from the theme.
-    let styles: [CSSStyle]
+    let styles: [CSSStyle]?
 }

ios/Sources/GutenbergKit/Sources/RESTAPIRepository.swift

@@ -72,7 +72,7 @@ public struct RESTAPIRepository: Sendable {
         let request = URLRequest(method: .GET, url: editorSettingsUrl)
         let response = try await self.httpClient.perform(request)
 
-        let editorSettings = EditorSettings(data: response.0)
+        let editorSettings = try EditorSettings(data: response.0)
 
         let urlResponse = EditorURLResponse((try JSONEncoder().encode(editorSettings), response.1))
         try self.cache.store(urlResponse, for: editorSettingsUrl, httpMethod: .GET)