Added regex support and positive and negative numbers

bbakerman · bbakerman · commit b5f9ab781a57 · 2018-09-30T08:06:19.000+10:00
diff --git a/src/main/java/graphql/scalars/ExtendedScalars.java b/src/main/java/graphql/scalars/ExtendedScalars.java
@@ -4,6 +4,14 @@
 import graphql.scalars.datetime.DateTimeScalar;
 import graphql.scalars.datetime.FullDateScalar;
 import graphql.scalars.datetime.FullTimeScalar;
+import graphql.scalars.numbers.NegativeFloatScalar;
+import graphql.scalars.numbers.NegativeIntScalar;
+import graphql.scalars.numbers.NonNegativeFloatScalar;
+import graphql.scalars.numbers.NonNegativeIntScalar;
+import graphql.scalars.numbers.NonPositiveFloatScalar;
+import graphql.scalars.numbers.NonPositiveIntScalar;
+import graphql.scalars.numbers.PositiveFloatScalar;
+import graphql.scalars.numbers.PositiveIntScalar;
 import graphql.scalars.object.JsonScalar;
 import graphql.scalars.object.ObjectScalar;
 import graphql.scalars.url.UrlScalar;
@@ -58,4 +66,16 @@ public class ExtendedScalars {
     public static GraphQLScalarType Json = new JsonScalar();
 
     public static GraphQLScalarType Url = new UrlScalar();
+
+    public static GraphQLScalarType PositiveInt = new PositiveIntScalar();
+    public static GraphQLScalarType NegativeInt = new NegativeIntScalar();
+    public static GraphQLScalarType NonPositiveInt = new NonPositiveIntScalar();
+    public static GraphQLScalarType NonNegativeInt = new NonNegativeIntScalar();
+
+    public static GraphQLScalarType PositiveFloat = new PositiveFloatScalar();
+    public static GraphQLScalarType NegativeFloat = new NegativeFloatScalar();
+    public static GraphQLScalarType NonPositiveFloat = new NonPositiveFloatScalar();
+    public static GraphQLScalarType NonNegativeFloat = new NonNegativeFloatScalar();
+
+
 }
diff --git a/src/main/java/graphql/scalars/numbers/FloatCoercing.java b/src/main/java/graphql/scalars/numbers/FloatCoercing.java
@@ -0,0 +1,33 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.Coercing;
+import graphql.schema.CoercingParseLiteralException;
+import graphql.schema.CoercingParseValueException;
+import graphql.schema.CoercingSerializeException;
+
+import java.util.function.Function;
+
+import static graphql.Scalars.GraphQLFloat;
+
+abstract class FloatCoercing implements Coercing<Double, Double> {
+
+    abstract protected Double check(Double d, Function<String, RuntimeException> exceptionMaker);
+
+    @Override
+    public Double serialize(Object input) throws CoercingSerializeException {
+        Double d = (Double) GraphQLFloat.getCoercing().serialize(input);
+        return check(d, CoercingSerializeException::new);
+    }
+
+    @Override
+    public Double parseValue(Object input) throws CoercingParseValueException {
+        Double d = (Double) GraphQLFloat.getCoercing().parseValue(input);
+        return check(d, CoercingParseValueException::new);
+    }
+
+    @Override
+    public Double parseLiteral(Object input) throws CoercingParseLiteralException {
+        Double d = (Double) GraphQLFloat.getCoercing().parseLiteral(input);
+        return check(d, CoercingParseLiteralException::new);
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/IntCoercing.java b/src/main/java/graphql/scalars/numbers/IntCoercing.java
@@ -0,0 +1,33 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.Coercing;
+import graphql.schema.CoercingParseLiteralException;
+import graphql.schema.CoercingParseValueException;
+import graphql.schema.CoercingSerializeException;
+
+import java.util.function.Function;
+
+import static graphql.Scalars.GraphQLInt;
+
+abstract class IntCoercing implements Coercing<Integer, Integer> {
+
+    abstract protected Integer check(Integer i, Function<String, RuntimeException> exceptionMaker);
+
+    @Override
+    public Integer serialize(Object input) throws CoercingSerializeException {
+        Integer i = (Integer) GraphQLInt.getCoercing().serialize(input);
+        return check(i, CoercingSerializeException::new);
+    }
+
+    @Override
+    public Integer parseValue(Object input) throws CoercingParseValueException {
+        Integer i = (Integer) GraphQLInt.getCoercing().parseValue(input);
+        return check(i, CoercingParseValueException::new);
+    }
+
+    @Override
+    public Integer parseLiteral(Object input) throws CoercingParseLiteralException {
+        Integer i = (Integer) GraphQLInt.getCoercing().parseLiteral(input);
+        return check(i, CoercingParseLiteralException::new);
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/NegativeFloatScalar.java b/src/main/java/graphql/scalars/numbers/NegativeFloatScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class NegativeFloatScalar extends GraphQLScalarType {
+    public NegativeFloatScalar() {
+        super("NegativeFloat", "An Float scalar that must be a negative value", new FloatCoercing() {
+            @Override
+            protected Double check(Double d, Function<String, RuntimeException> exceptionMaker) {
+                if (!(d < 0)) {
+                    throw exceptionMaker.apply("The value must be a negative value");
+                }
+                return d;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/NegativeIntScalar.java b/src/main/java/graphql/scalars/numbers/NegativeIntScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class NegativeIntScalar extends GraphQLScalarType {
+    public NegativeIntScalar() {
+        super("NegativeInt", "An Int scalar that must be a negative value", new IntCoercing() {
+            @Override
+            protected Integer check(Integer i, Function<String, RuntimeException> exceptionMaker) {
+                if (!(i < 0)) {
+                    throw exceptionMaker.apply("The value must be a negative integer");
+                }
+                return i;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/NonNegativeFloatScalar.java b/src/main/java/graphql/scalars/numbers/NonNegativeFloatScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class NonNegativeFloatScalar extends GraphQLScalarType {
+    public NonNegativeFloatScalar() {
+        super("NonNegativeFloat", "An Float scalar that must be greater than or equal to zero", new FloatCoercing() {
+            @Override
+            protected Double check(Double d, Function<String, RuntimeException> exceptionMaker) {
+                if (!(d >= 0)) {
+                    throw exceptionMaker.apply("The value must be greater than or equal to zero");
+                }
+                return d;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/NonNegativeIntScalar.java b/src/main/java/graphql/scalars/numbers/NonNegativeIntScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class NonNegativeIntScalar extends GraphQLScalarType {
+    public NonNegativeIntScalar() {
+        super("NonNegativeInt", "An Int scalar that must be greater than or equal to zero", new IntCoercing() {
+            @Override
+            protected Integer check(Integer i, Function<String, RuntimeException> exceptionMaker) {
+                if (!(i >= 0)) {
+                    throw exceptionMaker.apply("The value must be greater than or equal to zero");
+                }
+                return i;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/NonPositiveFloatScalar.java b/src/main/java/graphql/scalars/numbers/NonPositiveFloatScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class NonPositiveFloatScalar extends GraphQLScalarType {
+    public NonPositiveFloatScalar() {
+        super("NonPositiveFloat", "An Float scalar that must be less than or equal to zero", new FloatCoercing() {
+            @Override
+            protected Double check(Double d, Function<String, RuntimeException> exceptionMaker) {
+                if (!(d <= 0)) {
+                    throw exceptionMaker.apply("The value must be less than or equal to zero");
+                }
+                return d;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/NonPositiveIntScalar.java b/src/main/java/graphql/scalars/numbers/NonPositiveIntScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class NonPositiveIntScalar extends GraphQLScalarType {
+    public NonPositiveIntScalar() {
+        super("NonPositiveInt", "An Int scalar that must be less than or equal to zero", new IntCoercing() {
+            @Override
+            protected Integer check(Integer i, Function<String, RuntimeException> exceptionMaker) {
+                if (!(i <= 0)) {
+                    throw exceptionMaker.apply("The value must be less than or equal to zero");
+                }
+                return i;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/PositiveFloatScalar.java b/src/main/java/graphql/scalars/numbers/PositiveFloatScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class PositiveFloatScalar extends GraphQLScalarType {
+    public PositiveFloatScalar() {
+        super("PositiveFloat", "An Float scalar that must be a positive value", new FloatCoercing() {
+            @Override
+            protected Double check(Double d, Function<String, RuntimeException> exceptionMaker) {
+                if (!(d > 0)) {
+                    throw exceptionMaker.apply("The value must be a positive value");
+                }
+                return d;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/numbers/PositiveIntScalar.java b/src/main/java/graphql/scalars/numbers/PositiveIntScalar.java
@@ -0,0 +1,19 @@
+package graphql.scalars.numbers;
+
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+
+public class PositiveIntScalar extends GraphQLScalarType {
+    public PositiveIntScalar() {
+        super("PositiveInt", "An Int scalar that must be a positive value", new IntCoercing() {
+            @Override
+            protected Integer check(Integer i, Function<String, RuntimeException> exceptionMaker) {
+                if (!(i > 0)) {
+                    throw exceptionMaker.apply("The value must be a positive integer");
+                }
+                return i;
+            }
+        });
+    }
+}
diff --git a/src/main/java/graphql/scalars/regex/RegexScalar.java b/src/main/java/graphql/scalars/regex/RegexScalar.java
@@ -0,0 +1,118 @@
+package graphql.scalars.regex;
+
+import graphql.Assert;
+import graphql.language.StringValue;
+import graphql.schema.Coercing;
+import graphql.schema.CoercingParseLiteralException;
+import graphql.schema.CoercingParseValueException;
+import graphql.schema.CoercingSerializeException;
+import graphql.schema.GraphQLScalarType;
+
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static graphql.scalars.util.Kit.typeName;
+
+/**
+ * This is really a scalar factory for creating new scalar String types that are based on a value matching
+ * a regular expression.
+ */
+public class RegexScalar extends GraphQLScalarType {
+
+    private RegexScalar(String name, String description, Coercing coercing) {
+        super(name, description, coercing);
+    }
+
+    /**
+     * Creates a new scalar that uses the specified {@link java.util.regex.Pattern} to control
+     * the values that are allowed.
+     *
+     * @param name    the name of the scalar
+     * @param pattern the allowable values pattern
+     *
+     * @return a new regex scalar
+     */
+    public static RegexScalar regexScalar(String name, Pattern pattern) {
+        return regexScalarImpl(name, null, pattern);
+    }
+
+    /**
+     * Creates a new scalar that uses the specified {@link java.util.regex.Pattern} to control
+     * the values that are allowed.
+     *
+     * @param name        the name of the scalar
+     * @param description the description of the scalar
+     * @param pattern     the allowable values pattern
+     *
+     * @return a new regex scalar
+     */
+    public static RegexScalar regexScalar(String name, String description, Pattern pattern) {
+        return regexScalarImpl(name, description, pattern);
+    }
+
+    /**
+     * Creates a new scalar that uses the specified {@link java.util.regex.Pattern}s to control
+     * the values that are allowed.
+     *
+     * @param name     the name of the scalar
+     * @param patterns the allowable values patterns
+     *
+     * @return a new regex scalar
+     */
+    public static RegexScalar regexScalar(String name, Pattern... patterns) {
+        return regexScalarImpl(name, null, patterns);
+    }
+
+    /**
+     * Creates a new scalar that uses the specified {@link java.util.regex.Pattern}s to control
+     * the values that are allowed.
+     *
+     * @param name        the name of the scalar
+     * @param description the description of the scalar
+     * @param patterns    the allowable values patterns
+     *
+     * @return a new regex scalar
+     */
+    public static RegexScalar regexScalar(String name, String description, Pattern... patterns) {
+        return regexScalarImpl(name, description, patterns);
+    }
+
+    private static RegexScalar regexScalarImpl(String name, String description, Pattern... patterns) {
+        Assert.assertNotNull(patterns);
+        return new RegexScalar(name, description, new Coercing<String, String>() {
+            @Override
+            public String serialize(Object input) throws CoercingSerializeException {
+                String value = String.valueOf(input);
+                return matches(value, CoercingSerializeException::new);
+            }
+
+            @Override
+            public String parseValue(Object input) throws CoercingParseValueException {
+                String value = String.valueOf(input);
+                return matches(value, CoercingParseValueException::new);
+            }
+
+            @Override
+            public String parseLiteral(Object input) throws CoercingParseLiteralException {
+                if (!(input instanceof StringValue)) {
+                    throw new CoercingParseLiteralException(
+                            "Expected AST type 'StringValue' but was '" + typeName(input) + "'."
+                    );
+                }
+                String value = ((StringValue) input).getValue();
+                return matches(value, CoercingParseLiteralException::new);
+            }
+
+            private String matches(String value, Function<String, RuntimeException> exceptionMaker) {
+                for (Pattern pattern : patterns) {
+                    Matcher matcher = pattern.matcher(value);
+                    if (matcher.matches()) {
+                        return value;
+                    }
+                }
+                throw exceptionMaker.apply("Unable to accept a value into the '" + name + "' scalar.  It does not match the regular expressions.");
+            }
+        });
+    }
+}
diff --git a/src/test/groovy/graphql/scalars/numbers/NegativeFloatScalarTest.groovy b/src/test/groovy/graphql/scalars/numbers/NegativeFloatScalarTest.groovy
diff --git a/src/test/groovy/graphql/scalars/numbers/NegativeIntScalarTest.groovy b/src/test/groovy/graphql/scalars/numbers/NegativeIntScalarTest.groovy
diff --git a/src/test/groovy/graphql/scalars/numbers/PositiveFloatScalarTest.groovy b/src/test/groovy/graphql/scalars/numbers/PositiveFloatScalarTest.groovy
diff --git a/src/test/groovy/graphql/scalars/numbers/PositiveIntScalarTest.groovy b/src/test/groovy/graphql/scalars/numbers/PositiveIntScalarTest.groovy
diff --git a/src/test/groovy/graphql/scalars/regex/RegexScalarTest.groovy b/src/test/groovy/graphql/scalars/regex/RegexScalarTest.groovy
diff --git a/src/test/groovy/graphql/scalars/util/TestKit.groovy b/src/test/groovy/graphql/scalars/util/TestKit.groovy
