adding support for custom format validators

src/main/kotlin/com/github/erosb/jsonsKema/SchemaLoader.kt

@@ -139,6 +139,8 @@ class SchemaLoader(
 
     constructor(schemaJson: IJsonValue) : this(schemaJson, createDefaultConfig()) {}
 
+    constructor(schemaJson: String) : this(JsonParser(schemaJson)(), createDefaultConfig()) {}
+
     private val regexpFactory: RegexpFactory = JavaUtilRegexpFactory()
 
     private val keywordLoaders: Map<String, KeywordLoader> = mapOf(
@@ -468,8 +470,6 @@ class SchemaLoader(
         val subschemas = mutableSetOf<Schema>()
         var title: IJsonString? = null
         var description: IJsonString? = null
-        var readOnly: IJsonBoolean? = null
-        var writeOnly: IJsonBoolean? = null
         var deprecated: IJsonBoolean? = null
         var default: IJsonValue? = null
         var dynamicRef: DynamicReference? = null
@@ -478,7 +478,7 @@ class SchemaLoader(
         var patternPropertySchemas: Map<Regexp, Schema> = emptyMap()
         var unevaluatedItemsSchema: Schema? = null
         var unevaluatedPropertiesSchema: Schema? = null
-        var unprocessedProperties: MutableMap<IJsonString, IJsonValue> = mutableMapOf()
+        val unprocessedProperties: MutableMap<IJsonString, IJsonValue> = mutableMapOf()
         var definedSubschemas: Map<IJsonString, Schema> = emptyMap()
         return enterScope(schemaJson) {
             schemaJson.properties.forEach { (name, value) ->

src/main/kotlin/com/github/erosb/jsonsKema/Validator.kt

@@ -47,13 +47,16 @@ enum class ReadWriteContext {
 
 data class ValidatorConfig @JvmOverloads constructor(
     val validateFormat: FormatValidationPolicy = FormatValidationPolicy.DEPENDS_ON_VOCABULARY,
-    val readWriteContext: ReadWriteContext = ReadWriteContext.NONE) {
+    val readWriteContext: ReadWriteContext = ReadWriteContext.NONE,
+    val additionalFormatValidators: Map<String, FormatValidator> = emptyMap()
+) {
     companion object {
 
         class ValidatorConfigBuilder {
 
             var readWriteContext: ReadWriteContext = ReadWriteContext.NONE
             var validateFormat: FormatValidationPolicy = FormatValidationPolicy.DEPENDS_ON_VOCABULARY;
+            val additionalFormatValidators: MutableMap<String, FormatValidator> = mutableMapOf()
 
             fun readWriteContext(readWriteContext: ReadWriteContext): ValidatorConfigBuilder {
                 this.readWriteContext = readWriteContext
@@ -65,8 +68,12 @@ data class ValidatorConfig @JvmOverloads constructor(
                 return this
             }
 
-            fun build() = ValidatorConfig(validateFormat, readWriteContext)
+            fun additionalFormatValidator(formatName: String, formatValidator: FormatValidator): ValidatorConfigBuilder {
+                additionalFormatValidators[formatName] = formatValidator
+                return this;
+            }
 
+            fun build() = ValidatorConfig(validateFormat, readWriteContext, additionalFormatValidators)
         }
 
         @JvmStatic
@@ -661,7 +668,7 @@ private class DefaultValidator(
         "ipv4" to ipv4FormatValidator,
         "ipv6" to ipv6FormatValidator,
         "uuid" to uuidFormatValidator
-    )
+    ) + config.additionalFormatValidators
 
     override fun visitFormatSchema(schema: FormatSchema): ValidationFailure? =
         if (validateFormat) {

src/test/kotlin/com/github/erosb/jsonsKema/FormatTest.kt

@@ -39,4 +39,58 @@ class FormatTest {
 
         assertThat(actual).isNull()
     }
+
+    @Test
+    fun `custom format`() {
+        val validator = Validator.create(SchemaLoader("""
+            {
+                "format": "parens"
+            }
+        """)(), config = ValidatorConfig.builder()
+            .additionalFormatValidator("parens") { instance, schema ->
+                instance.maybeString { str ->
+                    var openCount = 0
+                    for (ch in str.value) {
+                        if (ch == '(') {
+                            ++openCount
+                        } else if (ch == ')') {
+                            --openCount
+                            if (openCount < 0) {
+                                return@maybeString FormatValidationFailure(schema, instance)
+                            }
+                        }
+                    }
+                    return@maybeString if (openCount != 0) FormatValidationFailure(schema, instance) else null
+                }
+            }
+            .build()
+        )
+
+        val noFailure = validator.validate(JsonString("asd((asd))"))
+        assertThat(noFailure).isNull()
+
+        val failure = validator.validate(JsonString("asd(((asd))"))
+        assertThat(failure).isInstanceOf(FormatValidationFailure::class.java)
+    }
+
+    @Test
+    fun `format override`() {
+        val validator = Validator.create(SchemaLoader("""
+            {
+                "format": "email"
+            }
+        """)(), config = ValidatorConfig.builder()
+            .additionalFormatValidator("email") { instance, schema ->
+                instance.maybeString { if (it.value.endsWith(".com")) null else FormatValidationFailure(schema, instance) }
+            }
+            .build()
+        )
+
+        val noFailure = validator.validate(JsonString("asdasd.com"))
+        assertThat(noFailure).isNull()
+
+        val failure = validator.validate(JsonString("erosb@github.io"))
+        assertThat(failure).isNotNull()
+        assertThat(failure!!.message).isEqualTo("instance does not match format 'email'")
+    }
 }