Refactor discriminator

Author: justin-tay

src/main/java/com/networknt/schema/keyword/AnyOfValidator.java

@@ -113,23 +113,11 @@ && canShortCircuit(executionContext)) {
                         return;
                     } else if (this.schemaContext.isDiscriminatorKeywordEnabled()) {
                         JsonNode refNode = schema.getSchemaNode().get("$ref");
-                        DiscriminatorState state = executionContext.getDiscriminatorMapping().get(instanceLocation);
+                        DiscriminatorState discriminator = executionContext.getDiscriminatorMapping()
+                                .get(instanceLocation);
                         boolean discriminatorMatchFound = false;
                         if (refNode != null) {
-                            // Check if there is a match
-                            String mappedSchema = state.getMappedSchema();
-                            if (mappedSchema != null) {
-                                String ref = refNode.asText();
-                                if (state.isExplicitMapping() && ref.equals(mappedSchema)) {
-                                    // Explicit matching
-                                    discriminatorMatchFound = true;
-                                    state.setMatchedSchema(ref);
-                                } else if (!state.isExplicitMapping() && ref.endsWith(mappedSchema)) {
-                                    // Implicit matching
-                                    discriminatorMatchFound = true;
-                                    state.setMatchedSchema(ref);
-                                }
-                            }
+                            discriminatorMatchFound = discriminator.matches(refNode.asText());
                         }
                         if (discriminatorMatchFound) {
                             /*

src/main/java/com/networknt/schema/keyword/DiscriminatorState.java

@@ -20,12 +20,80 @@
  * Discriminator state for an instance location.
  */
 public class DiscriminatorState {
+    /**
+     * The propertyName field defined in the discriminator keyword schema.
+     */
     private String propertyName;
+    /**
+     * The discriminating value from the payload matching the property name.
+     */
     private String discriminatingValue;
+    /**
+     * The mapped schema from the mapping or the discriminating value if there is no
+     * mapping.
+     */
     private String mappedSchema = null;
+
+    /**
+     * Whether the mapped schema is explicitly mapped using mapping or is the
+     * discriminating value.
+     */
     private boolean explicitMapping = false;
+
+    /**
+     * The matched schema for the instance.
+     */
     private String matchedSchema;
 
+    /**
+     * Determines if there is a match of the mapped schema to the ref and update the
+     * matched schema if there is a match.
+     * 
+     * @param refSchema the $ref value
+     * @return true if there is a match
+     */
+    public boolean matches(String refSchema) {
+        boolean discriminatorMatchFound = false;
+        String mappedSchema = getMappedSchema();
+        if (mappedSchema != null) {
+            if (isExplicitMapping() && refSchema.equals(mappedSchema)) {
+                // Explicit matching
+                discriminatorMatchFound = true;
+                setMatchedSchema(refSchema);
+            } else if (!isExplicitMapping() && isImplicitMatch(refSchema, mappedSchema)) {
+                // Implicit matching
+                discriminatorMatchFound = true;
+                setMatchedSchema(refSchema);
+            }
+        }
+        return discriminatorMatchFound;
+    }
+
+    /**
+     * Determine if there is an implicit match of the mapped schema to the ref.
+     * 
+     * @param refSchema    the $ref value
+     * @param mappedSchema the mapped schema
+     * @return true if there is a match
+     */
+    private static boolean isImplicitMatch(String refSchema, String mappedSchema) {
+        /*
+         * To ensure that an ambiguous value (e.g. "foo") is treated as a relative URI
+         * reference by all implementations, authors MUST prefix it with the "." path
+         * segment (e.g. "./foo").
+         */
+        if (mappedSchema.startsWith(".")) {
+            return refSchema.equals(mappedSchema);
+        } else {
+            int found = refSchema.lastIndexOf('/');
+            if (found == -1) {
+                return refSchema.equals(mappedSchema);
+            } else {
+                return refSchema.substring(found + 1).equals(mappedSchema);
+            }
+        }
+    }
+
     /**
      * Gets the property name defined in the discriminator keyword schema.
      * 
@@ -149,5 +217,4 @@ public boolean hasMatchedSchema() {
         return this.matchedSchema != null;
     }
 
-    
 }

src/main/java/com/networknt/schema/keyword/DiscriminatorValidator.java

@@ -54,6 +54,16 @@ public class DiscriminatorValidator extends BaseKeywordValidator {
      */
     private final Map<String, String> mapping;
 
+    /**
+     * The schema name or URI reference to a schema that is expected to validate the
+     * structure of the model when the discriminating property is not present in the
+     * payload or contains a value for which there is no explicit or implicit
+     * mapping.
+     * <p>
+     * Since OpenAPI 3.2.0
+     */
+    private final String defaultMapping;
+
     public DiscriminatorValidator(SchemaLocation schemaLocation, NodePath evaluationPath, JsonNode schemaNode,
             Schema parentSchema, SchemaContext schemaContext) {
         super(KeywordType.DISCRIMINATOR, schemaNode, schemaLocation, parentSchema, schemaContext, evaluationPath);
@@ -77,9 +87,19 @@ public DiscriminatorValidator(SchemaLocation schemaLocation, NodePath evaluation
             } else {
                 this.mapping = Collections.emptyMap();
             }
+
+            // Check if OpenAPI 3.2.0
+            JsonNode defaultMapping = discriminator.get("defaultMapping");
+            if (defaultMapping != null) {
+                this.defaultMapping = defaultMapping.asText();
+            } else {
+                this.defaultMapping = null;
+            }
+
         } else {
             this.propertyName = "";
             this.mapping = Collections.emptyMap();
+            this.defaultMapping = null;
         }
     }
 
@@ -151,6 +171,15 @@ public void validate(ExecutionContext executionContext, JsonNode node, JsonNode
                 }
             }
         } else {
+            /*
+             * Since OpenAPI 3.2.0 if defaultMapping is set, then the property is optional.
+             */
+            if (this.defaultMapping != null) {
+                state.setMappedSchema(defaultMapping);
+                state.setExplicitMapping(true);
+                return;
+            }
+
             /*
              * The property is not present in the payload. This property SHOULD be required
              * in the payload schema, as the behavior when the property is absent is
@@ -166,6 +195,7 @@ public void validate(ExecutionContext executionContext, JsonNode node, JsonNode
              */
             if (this.schemaContext.getSchemaRegistryConfig().isStrict("discriminator", Boolean.FALSE)) {
                 executionContext.addError(error().instanceNode(node).instanceLocation(instanceLocation)
+                        .locale(executionContext.getExecutionConfig().getLocale())
                         .messageKey("discriminator.missing_discriminating_value").arguments(this.propertyName).build());
             }
         }