feat: dependent required equals, auto enum validation, JSON of Path and Reader (#49)

* feat: dependent required equals, auto enum validation

* test: adds test for new Reader and Path factory methods

Author: jbee

src/main/java/org/hisp/dhis/jsontree/JsonAbstractArray.java

@@ -1,6 +1,8 @@
 package org.hisp.dhis.jsontree;
 
+import org.hisp.dhis.jsontree.Validation.Rule;
 import org.hisp.dhis.jsontree.internal.Surly;
+import org.hisp.dhis.jsontree.validation.JsonValidator;
 
 import java.util.Collection;
 import java.util.Iterator;
@@ -111,4 +113,15 @@ default <T> int count( Function<E, T> toValue, Predicate<T> test ) {
     default E first( Predicate<E> test ) {
         return stream().filter( test ).findFirst().orElseGet( () -> get( size() ) );
     }
+
+    /**
+     * @param schema the schema to validate all elements of this array against
+     * @param rules optional set of {@link Rule}s to check, empty includes all
+     * @throws JsonSchemaException      in case this value does not match the given schema
+     * @throws IllegalArgumentException in case the given schema is not an interface
+     * @since 1.0
+     */
+    default void validateEach(Class<? extends JsonAbstractObject<?>> schema, Rule... rules) {
+        forEach( e -> JsonValidator.validate( e, schema, rules ) );
+    }
 }

src/main/java/org/hisp/dhis/jsontree/JsonArray.java

@@ -114,6 +114,8 @@ default <E extends JsonValue> JsonMultiMap<E> getMultiMap( int index, Class<E> a
         return JsonAbstractCollection.asMultiMap( getObject( index ), as );
     }
 
+
+
     /**
      * Maps this array to a lazy transformed list view where each element of the original array is transformed by the
      * given function when accessed.

src/main/java/org/hisp/dhis/jsontree/JsonMixed.java

@@ -1,5 +1,8 @@
 package org.hisp.dhis.jsontree;
 
+import java.io.Reader;
+import java.nio.file.Path;
+
 import static org.hisp.dhis.jsontree.Validation.NodeType.ARRAY;
 import static org.hisp.dhis.jsontree.Validation.NodeType.BOOLEAN;
 import static org.hisp.dhis.jsontree.Validation.NodeType.INTEGER;
@@ -73,4 +76,22 @@ static JsonMixed of( String json, JsonTypedAccessStore store ) {
     static JsonMixed ofNonStandard( String json ) {
         return of( JsonNode.ofNonStandard( json ) );
     }
+
+    /**
+     * @param file a JSON file in UTF-8 encoding
+     * @return root of the virtual tree representing the given JSON input
+     * @since 1.0
+     */
+    static JsonMixed of( Path file ) {
+        return of(JsonNode.of( file ));
+    }
+
+    /**
+     * @param json JSON input
+     * @return root of the virtual tree representing the given JSON input
+     * @since 1.0
+     */
+    static JsonMixed of( Reader json ) {
+        return of(JsonNode.of( json, null ));
+    }
 }

src/main/java/org/hisp/dhis/jsontree/JsonNode.java

@@ -29,7 +29,14 @@
 
 import org.hisp.dhis.jsontree.internal.Surly;
 
+import java.io.IOException;
+import java.io.Reader;
 import java.io.Serializable;
+import java.io.UncheckedIOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Iterator;
 import java.util.Map.Entry;
 import java.util.Optional;
@@ -132,6 +139,61 @@ static JsonNode of( String json, GetListener onGet ) {
         return JsonTree.of( json, onGet ).get( "$" );
     }
 
+    /**
+     * @param file a JSON file in UTF-8 encoding
+     * @return the given JSON input as {@link JsonNode} tree
+     * @since 1.0
+     */
+    static JsonNode of( Path file ) {
+        return of(file, null);
+    }
+
+    /**
+     * @param file a JSON file in UTF-8 encoding
+     * @param onGet to observe all path lookup in the returned tree, may be null
+     * @return the given JSON input as {@link JsonNode} tree
+     * @since 1.0
+     */
+    static JsonNode of( Path file, GetListener onGet ) {
+        return of(file, StandardCharsets.UTF_8, onGet);
+    }
+
+    /**
+     * @param file a JSON file in the given encoding
+     * @param encoding of the given file
+     * @param onGet to observe all path lookup in the returned tree, may be null
+     * @return the given JSON input as {@link JsonNode} tree
+     * @implNote not optimized, added to allow transparent change of implementation later
+     * @since 1.0
+     */
+    static JsonNode of( Path file, Charset encoding, GetListener onGet ) {
+        try {
+            return of( Files.readString( file, encoding ), onGet );
+        } catch ( IOException ex ) {
+            throw new UncheckedIOException( ex );
+        }
+    }
+
+    /**
+     * @param json JSON input
+     * @param onGet to observe all path lookup in the returned tree, may be null
+     * @return the given JSON input as {@link JsonNode} tree
+     * @since 1.0
+     * @implNote not optimized, added to allow transparent change of implementation later
+     */
+    static JsonNode of( Reader json, GetListener onGet ) {
+        char[] buffer = new char[4096]; // a usual FS block size
+        StringBuilder jsonChars = new StringBuilder(0);
+        int numChars;
+        try {
+            while ( (numChars = json.read( buffer )) >= 0 )
+                jsonChars.append( buffer, 0, numChars );
+        } catch ( IOException ex ) {
+            throw new UncheckedIOException( ex );
+        }
+        return of(jsonChars.toString(), onGet);
+    }
+
     /**
      * @return the type of the node as derived from the node beginning
      */

src/main/java/org/hisp/dhis/jsontree/JsonValue.java

@@ -30,6 +30,8 @@
 import org.hisp.dhis.jsontree.internal.Maybe;
 import org.hisp.dhis.jsontree.internal.Surly;
 
+import java.io.Reader;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
@@ -107,6 +109,24 @@ static JsonValue of( String json, JsonTypedAccessStore store ) {
         return json == null || "null".equals( json ) ? JsonVirtualTree.NULL : JsonMixed.of( json, store );
     }
 
+    /**
+     * @param file a JSON file in UTF-8 encoding
+     * @return root of the virtual tree representing the given JSON input
+     * @since 1.0
+     */
+    static JsonValue of( Path file ) {
+        return of(JsonNode.of( file ));
+    }
+
+    /**
+     * @param json JSON input
+     * @return root of the virtual tree representing the given JSON input
+     * @since 1.0
+     */
+    static JsonValue of( Reader json ) {
+        return of(JsonNode.of( json, null ));
+    }
+
     /**
      * If the {@link JsonValue} is not yet proxied, that means it is the unchanged underlying virtual tree, the returned
      * type is {@link JsonMixed}.

src/main/java/org/hisp/dhis/jsontree/Validation.java

@@ -4,9 +4,7 @@
 import org.hisp.dhis.jsontree.internal.Surly;
 
 import java.io.Serializable;
-import java.lang.annotation.Annotation;
 import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
@@ -171,6 +169,9 @@ public String toString() {
 
     /**
      * Corresponds to JSON schema validation specified as {@code enum}.
+     * <p>
+     * If all values are strings and all start with a letter and none is {@code true}, {@code false} or {@code null}
+     * then the strings do not have to be quoted.
      *
      * @return value must be equal to one of the given JSON values
      */
@@ -183,6 +184,14 @@ public String toString() {
      */
     Class<? extends Enum> enumeration() default Enum.class;
 
+    /**
+     * {@link YesNo#AUTO} is not case-insensitive.
+     *
+     * @return to allow {@link #enumeration()} names to be of different case
+     * @since 1.0
+     */
+    YesNo caseInsensitive() default YesNo.AUTO;
+
     /*
      Validations for Strings
      */

src/main/java/org/hisp/dhis/jsontree/validation/JsonValidator.java

@@ -1,6 +1,7 @@
 package org.hisp.dhis.jsontree.validation;
 
 import org.hisp.dhis.jsontree.JsonAbstractObject;
+import org.hisp.dhis.jsontree.JsonArray;
 import org.hisp.dhis.jsontree.JsonMixed;
 import org.hisp.dhis.jsontree.JsonPathException;
 import org.hisp.dhis.jsontree.JsonSchemaException;

src/main/java/org/hisp/dhis/jsontree/validation/ObjectValidation.java

@@ -45,6 +45,7 @@
 import static org.hisp.dhis.jsontree.Validation.NodeType.NUMBER;
 import static org.hisp.dhis.jsontree.Validation.NodeType.OBJECT;
 import static org.hisp.dhis.jsontree.Validation.NodeType.STRING;
+import static org.hisp.dhis.jsontree.Validation.YesNo.AUTO;
 import static org.hisp.dhis.jsontree.Validation.YesNo.YES;
 
 /**
@@ -221,7 +222,8 @@ private static PropertyValidation fromItems( AnnotatedElement src ) {
     @Surly
     private static PropertyValidation toPropertyValidation( Class<?> type ) {
         ValueValidation values = !type.isPrimitive() ? null : new ValueValidation( YES, Set.of(), Set.of(), List.of() );
-        return new PropertyValidation( anyOfTypes( type ), values, null, null, null, null, null );
+        StringValidation strings = !type.isEnum() ? null : new StringValidation( anyOfStrings( type ), AUTO,-1, -1, "" );
+        return new PropertyValidation( anyOfTypes( type ), values, strings, null, null, null, null );
     }
 
     @Surly
@@ -239,7 +241,7 @@ private static PropertyValidation toPropertyValidation( @Surly Validation src )
 
     @Maybe
     private static ValueValidation toValueValidation( @Surly Validation src ) {
-        boolean oneOfValuesEmpty = src.oneOfValues().length == 0;
+        boolean oneOfValuesEmpty = src.oneOfValues().length == 0 || isAutoUnquotedJsonStrings( src.oneOfValues() );
         boolean dependentRequiresEmpty = src.dependentRequired().length == 0;
         if ( src.required().isAuto() && oneOfValuesEmpty && dependentRequiresEmpty ) return null;
         Set<String> oneOfValues = oneOfValuesEmpty
@@ -248,11 +250,29 @@ private static ValueValidation toValueValidation( @Surly Validation src ) {
         return new ValueValidation( src.required(), Set.of( src.dependentRequired() ), oneOfValues, List.of() );
     }
 
+    private static boolean isAutoUnquotedJsonStrings(String[] values) {
+        return values.length > 0 && Stream.of( values ).allMatch( v -> !v.isEmpty()
+                && Character.isLetter( v.charAt( 0 ) )
+                && !"true".equals( v )
+                && !"false".equals( v )
+                && !"null".equals( v ));
+    }
+
     @Maybe
     private static StringValidation toStringValidation( @Surly Validation src ) {
-        if ( src.enumeration() == Enum.class && src.minLength() < 0 && src.maxLength() < 0 && src.pattern().isEmpty() )
+        if ( src.enumeration() == Enum.class && src.minLength() < 0 && src.maxLength() < 0 && src.pattern().isEmpty()
+            && src.caseInsensitive().isAuto() && !isAutoUnquotedJsonStrings( src.oneOfValues() ))
             return null;
-        return new StringValidation( src.enumeration(), src.minLength(), src.maxLength(), src.pattern() );
+        Set<String> anyOfStrings = anyOfStrings( src.enumeration() );
+        if (anyOfStrings.isEmpty() && isAutoUnquotedJsonStrings( src.oneOfValues() ))
+            anyOfStrings = Set.of(src.oneOfValues());
+        return new StringValidation(anyOfStrings, src.caseInsensitive(), src.minLength(), src.maxLength(), src.pattern() );
+    }
+
+    private static Set<String> anyOfStrings( @Surly Class<?> type ) {
+        return type == Enum.class || !type.isEnum()
+            ? Set.of()
+            : Set.copyOf( Stream.of( type.getEnumConstants() ).map( e -> ((Enum<?>)e).name() ).toList() );
     }
 
     @Maybe