Merge branch 'pr_36'

Author: iconara

jmespath-core/src/main/java/io/burt/jmespath/function/ArgumentConstraint.java

@@ -37,6 +37,12 @@ public interface ArgumentConstraint {
    */
   int maxArity();
 
+  /**
+   * @param n the number of arguments to check against minArity & maxArity
+   * @return true if any of the arity constraint failed.
+   */
+  boolean arityViolated(int n);
+
   /**
    * @return a string representation of the types accepted. Used to construct
    *   user friendly error messages.

jmespath-core/src/main/java/io/burt/jmespath/function/ArgumentConstraints.java

@@ -35,27 +35,38 @@ public final class ArgumentConstraints {
   private static final String EXPRESSION_TYPE = "expression";
 
   /**
-   * Describes a heterogenous list of arguments. Each argument is checked against
+   * Describes a heterogeneous list of arguments. Each argument is checked against
    * the corresponding constraint. An {@link ArityException} will be thrown when
    * the number of arguments does not exactly match the number of constraints.
    * <p>
    * May only be used as a top level constraint – and is already built in to
    * {@link Function}, so direct usage of this method should not be needed.
    */
   public static ArgumentConstraint listOf(ArgumentConstraint... constraints) {
-    return new HeterogenousListOf(constraints);
+    return new HeterogeneousListOf(constraints);
   }
 
   /**
-   * Descripes a homogenous list of arguments, of fixed or variable length.
+   * Describes a homogeneous list of arguments, of fixed or variable length.
    * An {@link ArityException} will be thrown when there are fewer arguments
    * than the specified minimum arity, or when there are more arguments than
    * the specified maximum arity.
    * <p>
    * May only be used as a top level constraint.
    */
   public static ArgumentConstraint listOf(int min, int max, ArgumentConstraint constraint) {
-    return new HomogenousListOf(min, max, constraint);
+    return new HomogeneousListOf(min, max, constraint);
+  }
+
+  /**
+   * Describes a homogeneous list of arguments without upper limit.
+   * An {@link ArityException} will be thrown when there are fewer arguments
+   * than the specified minimum arity.
+   * <p>
+   * May only be used as a top level constraint.
+   */
+  public static ArgumentConstraint listOf(int min, ArgumentConstraint constraint) {
+    return new VariadicListOf(min, constraint);
   }
 
   /**
@@ -115,7 +126,7 @@ public BaseArgumentConstraint(int minArity, int maxArity, String expectedTypeDes
       this.expectedTypeDescription = expectedTypeDescription;
     }
 
-    protected <T> Iterator<ArgumentError> checkNoRemaingArguments(Iterator<FunctionArgument<T>> arguments, boolean expectNoRemainingArguments) {
+    protected <T> Iterator<ArgumentError> checkNoRemainingArguments(Iterator<FunctionArgument<T>> arguments, boolean expectNoRemainingArguments) {
       if (expectNoRemainingArguments && arguments.hasNext()) {
         return singletonIterator(ArgumentError.createArityError());
       } else {
@@ -133,6 +144,9 @@ public int maxArity() {
       return maxArity;
     }
 
+    @Override
+    public boolean arityViolated(int n) { return (n < minArity || maxArity < n); }
+
     @Override
     public String expectedType() {
       return expectedTypeDescription;
@@ -147,10 +161,10 @@ protected <U> Iterator<U> emptyIterator() {
     }
   }
 
-  private static class HomogenousListOf extends BaseArgumentConstraint {
+  private static class HomogeneousListOf extends BaseArgumentConstraint {
     private final ArgumentConstraint subConstraint;
 
-    public HomogenousListOf(int minArity, int maxArity, ArgumentConstraint subConstraint) {
+    public HomogeneousListOf(int minArity, int maxArity, ArgumentConstraint subConstraint) {
       super(minArity, maxArity, subConstraint.expectedType());
       this.subConstraint = subConstraint;
     }
@@ -178,14 +192,14 @@ public <T> Iterator<ArgumentError> check(Adapter<T> runtime, Iterator<FunctionAr
           break;
         }
       }
-      return checkNoRemaingArguments(arguments, expectNoRemainingArguments);
+      return checkNoRemainingArguments(arguments, expectNoRemainingArguments);
     }
   }
 
-  private static class HeterogenousListOf extends BaseArgumentConstraint {
+  private static class HeterogeneousListOf extends BaseArgumentConstraint {
     private final ArgumentConstraint[] subConstraints;
 
-    public HeterogenousListOf(ArgumentConstraint[] subConstraints) {
+    public HeterogeneousListOf(ArgumentConstraint[] subConstraints) {
       super(calculateMinArity(subConstraints), calculateMaxArity(subConstraints), null);
       this.subConstraints = subConstraints;
     }
@@ -218,10 +232,39 @@ public <T> Iterator<ArgumentError> check(Adapter<T> runtime, Iterator<FunctionAr
           return singletonIterator(ArgumentError.createArityError());
         }
       }
-      return checkNoRemaingArguments(arguments, expectNoRemainingArguments);
+      return checkNoRemainingArguments(arguments, expectNoRemainingArguments);
+    }
+  }
+
+  private static class VariadicListOf extends BaseArgumentConstraint {
+    private final ArgumentConstraint subConstraint;
+
+    public VariadicListOf(int minArity, ArgumentConstraint subConstraint) {
+      super(minArity, -1, subConstraint.expectedType());
+      this.subConstraint = subConstraint;
+    }
+
+    @Override
+    public <T> Iterator<ArgumentError> check(Adapter<T> runtime, Iterator<FunctionArgument<T>> arguments, boolean expectNoRemainingArguments) {
+      int i = 0;
+      for ( ;arguments.hasNext(); ++i) {
+          Iterator<ArgumentError> error = subConstraint.check(runtime, arguments, false);
+          if (error.hasNext()) {
+            return error;
+          }
+      }
+      if (i < minArity()) {
+        return singletonIterator(ArgumentError.createArityError());
+      } else {
+        return emptyIterator();
+      }
     }
+
+    @Override
+    public boolean arityViolated(int n) { return n < minArity(); }
   }
 
+
   private static abstract class TypeCheck extends BaseArgumentConstraint {
     public TypeCheck(String expectedType) {
       super(1, 1, expectedType);
@@ -234,7 +277,7 @@ public <T> Iterator<ArgumentError> check(Adapter<T> runtime, Iterator<FunctionAr
         if (error.hasNext()) {
           return error;
         } else {
-          return checkNoRemaingArguments(arguments, expectNoRemainingArguments);
+          return checkNoRemainingArguments(arguments, expectNoRemainingArguments);
         }
       } else {
         return singletonIterator(ArgumentError.createArityError());
@@ -359,7 +402,7 @@ public <T> Iterator<ArgumentError> check(Adapter<T> runtime, Iterator<FunctionAr
             return singletonIterator((ArgumentError) ArgumentError.createArgumentTypeError(expectedType(), type.toString()));
           }
         }
-        return checkNoRemaingArguments(arguments, expectNoRemainingArguments);
+        return checkNoRemainingArguments(arguments, expectNoRemainingArguments);
       } else {
         return singletonIterator(ArgumentError.createArityError());
       }

jmespath-core/src/main/java/io/burt/jmespath/parser/ExpressionParser.java

@@ -300,7 +300,7 @@ public Node<T> visitFunctionExpression(JmesPathParser.FunctionExpressionContext
       errors.parseError(String.format("unknown function \"%s\"", name), token.getStartIndex());
     } else {
       ArgumentConstraint argumentConstraints = implementation.argumentConstraints();
-      if (n < argumentConstraints.minArity() || n > argumentConstraints.maxArity()) {
+      if (argumentConstraints.arityViolated(n)) {
         Token token = ctx.NAME().getSymbol();
         String message = ArityException.createMessage(implementation, n, false);
         errors.parseError(message, token.getStartIndex());