refactor: pre-populate Draft 4 schemas to avoid network calls

Refs: #155

Author: lppedd

src/main/kotlin/com/github/lppedd/cc/configuration/CCTokensService.kt

@@ -11,6 +11,8 @@ import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFile
 import org.codehaus.jettison.json.JSONArray
 import org.codehaus.jettison.json.JSONObject
+import java.io.Reader
+import java.net.URI
 
 /**
  * Manages bundled and custom commit message tokens.
@@ -28,12 +30,27 @@ internal class CCTokensService(private val project: Project) {
    * JSON Schema used to validate the default commit types and scopes JSON file.
    */
   private val tokensSchema: Schema by lazy {
-    val bufferedReader = getResourceAsStream("/defaults/${CC.File.Schema}").bufferedReader()
-    val schemaJson = bufferedReader.use {
-      JsonParser(bufferedReader).parse()
+    // See https://github.com/erosb/json-sKema/tree/master/src/main/resources/json-meta-schemas
+    val draft04Reader = getResourceAsStream("/json-meta-schemas/draft04/schema.json").bufferedReader()
+    val draft04Str = draft04Reader.use(Reader::readText)
+
+    val schemaReader = getResourceAsStream("/defaults/${CC.File.Schema}").bufferedReader()
+    val schemaJson = schemaReader.use {
+      JsonParser(schemaReader).parse()
     }
 
-    return@lazy SchemaLoader(schemaJson).load()
+    // Pre-populate additional Draft 4 schemas to avoid network calls.
+    // I'm not sure whether all of these are needed, but let's play on the safe side.
+    val config = SchemaLoaderConfig.createDefaultConfig(
+      mapOf(
+        URI("http://json-schema.org/draft-04/schema") to draft04Str,
+        URI("http://json-schema.org/draft-04/schema#") to draft04Str,
+        URI("https://json-schema.org/draft-04/schema") to draft04Str,
+        URI("https://json-schema.org/draft-04/schema#") to draft04Str,
+      )
+    )
+
+    return@lazy SchemaLoader(schemaJson, config).load()
   }
 
   /**

src/main/resources/json-meta-schemas/draft04/schema.json

@@ -0,0 +1,149 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}