Fixing regex handling in "patternProperties"

core/pom.xml

@@ -21,7 +21,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.everit.json</groupId>
     <artifactId>org.everit.json.schema</artifactId>
-    <version>1.9.0</version>
+    <version>1.9.1</version>
     <packaging>bundle</packaging>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

core/src/main/java/org/everit/json/schema/ObjectSchema.java

@@ -1,7 +1,9 @@
 package org.everit.json.schema;
 
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.toMap;
 
+import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -10,10 +12,12 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.regex.Pattern;
 
 import org.everit.json.schema.internal.JSONPrinter;
-
-import com.google.re2j.Pattern;
+import org.everit.json.schema.regexp.JavaUtilRegexpFactory;
+import org.everit.json.schema.regexp.Regexp;
+import org.everit.json.schema.regexp.RegexpFactory;
 
 /**
  * Object schema validator.
@@ -25,7 +29,13 @@ public class ObjectSchema extends Schema {
      */
     public static class Builder extends Schema.Builder<ObjectSchema> {
 
-        private final Map<Pattern, Schema> patternProperties = new HashMap<>();
+        private static final RegexpFactory DEFAULT_REGEXP_FACTORY = new JavaUtilRegexpFactory();
+
+        private static final Regexp toRegexp(String pattern) {
+            return DEFAULT_REGEXP_FACTORY.createHandler(pattern);
+        }
+
+        private final Map<Regexp, Schema> patternProperties = new HashMap<>();
 
         private boolean requiresObject = true;
 
@@ -89,13 +99,21 @@ public Builder minProperties(Integer minProperties) {
             return this;
         }
 
+        @Deprecated
         public Builder patternProperty(java.util.regex.Pattern pattern, Schema schema) {
-            this.patternProperties.put(Pattern.compile(pattern.toString()), schema);
-            return this;
+            Regexp handler = toRegexp(pattern.toString());
+            return patternProperty(handler, schema);
         }
 
+        @Deprecated
         public Builder patternProperty(String pattern, Schema schema) {
-            return patternProperty(java.util.regex.Pattern.compile(pattern), schema);
+            Regexp handler = toRegexp(pattern);
+            return patternProperty(handler, schema);
+        }
+
+        public Builder patternProperty(Regexp pattern, Schema schema) {
+            this.patternProperties.put(pattern, schema);
+            return this;
         }
 
         /**
@@ -112,7 +130,7 @@ public Builder patternProperty(String pattern, Schema schema) {
         public Builder propertyDependency(String ifPresent, String mustBePresent) {
             Set<String> dependencies = propertyDependencies.get(ifPresent);
             if (dependencies == null) {
-                dependencies = new HashSet<String>(1);
+                dependencies = new HashSet<>(1);
                 propertyDependencies.put(ifPresent, dependencies);
             }
             dependencies.add(mustBePresent);
@@ -169,7 +187,7 @@ private static <K, V> Map<K, V> copyMap(Map<K, V> original) {
 
     private final boolean requiresObject;
 
-    private final Map<Pattern, Schema> patternProperties;
+    private final Map<Regexp, Schema> patternProperties;
 
     /**
      * Constructor.
@@ -206,10 +224,20 @@ public Integer getMinProperties() {
         return minProperties;
     }
 
-    public Map<Pattern, Schema> getPatternProperties() {
+    Map<Regexp, Schema> getRegexpPatternProperties() {
         return patternProperties;
     }
 
+    @Deprecated
+    public Map<Pattern, Schema> getPatternProperties() {
+        return patternProperties.entrySet().stream()
+                .map(entry -> new AbstractMap.SimpleEntry<>(java.util.regex.Pattern.compile(entry.getKey().toString()), entry.getValue()))
+                .collect(toMap(
+                        (Map.Entry<java.util.regex.Pattern, Schema> entry) -> entry.getKey(),
+                        (Map.Entry<java.util.regex.Pattern, Schema> entry) -> entry.getValue()
+                ));
+    }
+
     public Map<String, Set<String>> getPropertyDependencies() {
         return propertyDependencies;
     }
@@ -277,9 +305,10 @@ private boolean definesSchemaProperty(String current, String remaining) {
     }
 
     private boolean definesPatternProperty(String current, String remaining) {
-        for (Pattern pattern : patternProperties.keySet()) {
-            if (pattern.matcher(current).matches()) {
-                if (remaining == null || patternProperties.get(pattern).definesProperty(remaining)) {
+        for (Map.Entry<Regexp, Schema> entry : patternProperties.entrySet()) {
+            Regexp pattern = entry.getKey();
+            if (!pattern.patternMatchingFailure(current).isPresent()) {
+                if (remaining == null || entry.getValue().definesProperty(remaining)) {
                     return true;
                 }
             }
@@ -373,10 +402,10 @@ void describePropertiesTo(JSONPrinter writer) {
     private void describePropertyDependenciesTo(JSONPrinter writer) {
         writer.key("dependencies");
         writer.object();
-        propertyDependencies.entrySet().forEach(entry -> {
-            writer.key(entry.getKey());
+        propertyDependencies.forEach((key, value) -> {
+            writer.key(key);
             writer.array();
-            entry.getValue().forEach(writer::value);
+            value.forEach(writer::value);
             writer.endArray();
         });
         writer.endObject();

core/src/main/java/org/everit/json/schema/ObjectSchemaValidatingVisitor.java

@@ -3,10 +3,11 @@
 import static java.lang.String.format;
 import static java.util.Objects.requireNonNull;
 
-import com.google.re2j.Pattern;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
+
+import org.everit.json.schema.regexp.Regexp;
 import org.json.JSONObject;
 
 class ObjectSchemaValidatingVisitor extends Visitor {
@@ -119,21 +120,21 @@ private List<String> getAdditionalProperties() {
     }
 
     private boolean matchesAnyPattern(String key) {
-        for (Pattern pattern : schema.getPatternProperties().keySet()) {
-            if (pattern.matcher(key).find()) {
+        for (Regexp pattern : schema.getRegexpPatternProperties().keySet()) {
+            if (!pattern.patternMatchingFailure(key).isPresent()) {
                 return true;
             }
         }
         return false;
     }
 
-    @Override void visitPatternPropertySchema(Pattern propertyNamePattern, Schema schema) {
+    @Override void visitPatternPropertySchema(Regexp propertyNamePattern, Schema schema) {
         String[] propNames = JSONObject.getNames(objSubject);
         if (propNames == null || propNames.length == 0) {
             return;
         }
         for (String propName : propNames) {
-            if (propertyNamePattern.matcher(propName).find()) {
+            if (!propertyNamePattern.patternMatchingFailure(propName).isPresent()) {
                 ValidationException failure = owner.getFailureOfSchema(schema, objSubject.get(propName));
                 if (failure != null) {
                     owner.failure(failure.prepend(propName));

core/src/main/java/org/everit/json/schema/Visitor.java

@@ -6,8 +6,6 @@
 
 import org.everit.json.schema.regexp.Regexp;
 
-import com.google.re2j.Pattern;
-
 abstract class Visitor {
 
     void visitNumberSchema(NumberSchema numberSchema) {
@@ -121,7 +119,7 @@ void visitObjectSchema(ObjectSchema objectSchema) {
         }
         visitAdditionalProperties(objectSchema.permitsAdditionalProperties());
         visitSchemaOfAdditionalProperties(objectSchema.getSchemaOfAdditionalProperties());
-        for (Map.Entry<Pattern, Schema> entry : objectSchema.getPatternProperties().entrySet()) {
+        for (Map.Entry<Regexp, Schema> entry : objectSchema.getRegexpPatternProperties().entrySet()) {
             visitPatternPropertySchema(entry.getKey(), entry.getValue());
         }
         for (Map.Entry<String, Schema> schemaDep : objectSchema.getSchemaDependencies().entrySet()) {
@@ -141,7 +139,7 @@ void visitPropertySchema(String properyName, Schema schema) {
     void visitSchemaDependency(String propKey, Schema schema) {
     }
 
-    void visitPatternPropertySchema(Pattern propertyNamePattern, Schema schema) {
+    void visitPatternPropertySchema(Regexp propertyNamePattern, Schema schema) {
     }
 
     void visitSchemaOfAdditionalProperties(Schema schemaOfAdditionalProperties) {

core/src/main/java/org/everit/json/schema/loader/ObjectSchemaLoader.java

@@ -5,6 +5,7 @@
 
 import org.everit.json.schema.ObjectSchema;
 import org.everit.json.schema.Schema;
+import org.everit.json.schema.regexp.Regexp;
 
 /**
  * @author erosb
@@ -40,7 +41,8 @@ ObjectSchema.Builder load() {
                 .ifPresent(patternProps -> {
                     patternProps.keySet().forEach(pattern -> {
                         Schema patternSchema = defaultLoader.loadChild(patternProps.require(pattern)).build();
-                        builder.patternProperty(pattern, patternSchema);
+                        Regexp regexp = ls.config.regexpFactory.createHandler(pattern);
+                        builder.patternProperty(regexp, patternSchema);
                     });
                 });
         ls.schemaJson().maybe("dependencies").map(JsonValue::requireObject)

core/src/test/java/org/everit/json/schema/ObjectSchemaTest.java

@@ -16,26 +16,40 @@
 package org.everit.json.schema;
 
 import static java.util.Arrays.asList;
+import static java.util.stream.Collectors.toMap;
 import static org.everit.json.schema.TestSupport.buildWithLocation;
 import static org.everit.json.schema.TestSupport.loadAsV6;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import com.google.re2j.Pattern;
+import java.util.AbstractMap;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.Callable;
 
 import org.everit.json.schema.loader.SchemaLoader;
 import org.json.JSONObject;
 import org.json.JSONPointer;
 import org.junit.Test;
 
+import com.google.re2j.Pattern;
+
 import nl.jqno.equalsverifier.EqualsVerifier;
 import nl.jqno.equalsverifier.Warning;
 
 public class ObjectSchemaTest {
 
+    private static final Map<String, Schema> toStringToSchemaMap(Map<java.util.regex.Pattern, Schema> original) {
+        return original.entrySet().stream()
+                .map(entry -> new AbstractMap.SimpleEntry<>(entry.getKey().toString(), entry.getValue()))
+                .collect(toMap(
+                        entry -> entry.getKey(),
+                        entry -> entry.getValue()
+                ));
+    }
+
     private static final JSONObject OBJECTS = ResourceLoader.DEFAULT.readObj("objecttestcases.json");
 
     private ResourceLoader loader = ResourceLoader.DEFAULT;
@@ -241,6 +255,16 @@ public void patternPropertyOnEmptyObjct() {
                 .build().validate(new JSONObject());
     }
 
+    @Test
+    public void patternPropertyTranslation() {
+        ObjectSchema subject = ObjectSchema.builder()
+                .patternProperty(java.util.regex.Pattern.compile("b_.*"), BooleanSchema.INSTANCE)
+                .build();
+        Map<java.util.regex.Pattern, Schema> expected = new HashMap<>();
+        expected.put(java.util.regex.Pattern.compile("b_.*"), BooleanSchema.INSTANCE);
+        assertEquals(toStringToSchemaMap(expected), toStringToSchemaMap(subject.getPatternProperties()));
+    }
+
     @Test
     public void patternPropertyOverridesAdditionalPropSchema() {
         ObjectSchema.builder()

core/src/test/java/org/everit/json/schema/loader/DefinesPropertyTest.java

@@ -1,5 +1,7 @@
 package org.everit.json.schema.loader;
 
+import static org.junit.Assert.assertFalse;
+
 import org.everit.json.schema.BooleanSchema;
 import org.everit.json.schema.CombinedSchema;
 import org.everit.json.schema.ObjectSchema;
@@ -10,8 +12,6 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-import static org.junit.Assert.assertFalse;
-
 public class DefinesPropertyTest {
 
     private static JSONObject ALL_SCHEMAS = ResourceLoader.DEFAULT.readObj("testschemas.json");
@@ -53,7 +53,7 @@ public void patternPropertiesHasField() {
         Assert.assertTrue(actual.definesProperty("#/aaa"));
         Assert.assertTrue(actual.definesProperty("#/aaaa"));
         Assert.assertTrue(actual.definesProperty("#/aaaaa"));
-
+        
         assertFalse(actual.definesProperty("b"));
     }
 

core/src/test/resources/org/everit/jsonvalidator/testschemas.json

@@ -1,7 +1,7 @@
 {
   "patternProperties": {
     "patternProperties": {
-      "a*": {
+      "aa*": {
         "type": "integer"
       },
       "aaa*": {

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>org.everit.json</groupId>
     <artifactId>org.everit.json.schema.parent</artifactId>
-    <version>1.9.0</version>
+    <version>1.9.1</version>
 
     <packaging>pom</packaging>
 

tests/pom.xml

@@ -24,7 +24,7 @@
     <parent>
         <groupId>org.everit.json</groupId>
         <artifactId>org.everit.json.schema.parent</artifactId>
-        <version>1.9.0</version>
+        <version>1.9.1</version>
     </parent>
 
     <artifactId>org.everit.json.schema.tests</artifactId>