Refactor SizeTester to be cleaner.

src/main/lombok/org/leumasjaffe/json/schema/factory/SchemaV6Factory.java

@@ -55,17 +55,17 @@ class SchemaV6Factory extends SchemaFactory {
 		case "exclusiveMaximum": return NumberTester.exclusiveMaximum(value.asDouble());
 		case "minimum": return NumberTester.minimum(value.asDouble());
 		case "exclusiveMinimum": return NumberTester.exclusiveMinimum(value.asDouble());
-		case "maxLength": return new SizeTester(STRING, i -> i <= value.asInt());
-		case "minLength": return new SizeTester(STRING, i -> i >= value.asInt(0));
+		case "maxLength": return SizeTester.maxLength(value.asInt());
+		case "minLength": return SizeTester.minLength(value.asInt());
 		case "pattern": return new SimpleTester(STRING, j -> j.asText().matches(value.asText()));
 		case "additionalItems": return new AllItemsTester(ARRAY, create(value));
 		case "items": return value.isArray() ? new ItemsTester(createArray(value)) : new AllItemsTester(ARRAY, create(value));
-		case "maxItems": return new SizeTester(ARRAY, i -> i <= value.asInt());
-		case "minItems": return new SizeTester(ARRAY, i -> i >= value.asInt(0));
+		case "maxItems": return SizeTester.maxItems(value.asInt());
+		case "minItems": return SizeTester.minItems(value.asInt(0));
 		case "uniqueItems": return value.asBoolean() ? UniqueItemTester.INSTANCE : FixedTester.ACCEPT;
 		case "contains": return new ContainsTester(create(value));
-		case "maxProperties": return new SizeTester(OBJECT, i -> i <= value.asInt());
-		case "minProperties": return new SizeTester(OBJECT, i -> i >= value.asInt(0));
+		case "maxProperties": return SizeTester.maxProperties(value.asInt());
+		case "minProperties": return SizeTester.minProperties(value.asInt(0));
 		case "required": {
 			final List<String> reqKeys = JsonHelper.toArray(value, JsonNode::asText);
 			return new SimpleTester(OBJECT, json -> reqKeys.stream().allMatch(json::has));

src/main/lombok/org/leumasjaffe/json/schema/tester/SizeTester.java

@@ -1,7 +1,5 @@
 package org.leumasjaffe.json.schema.tester;
 
-import java.util.function.IntPredicate;
-
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
@@ -11,11 +9,48 @@ import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
 import lombok.experimental.FieldDefaults;
 
-@RequiredArgsConstructor
+@RequiredArgsConstructor(access=AccessLevel.PRIVATE)
 @FieldDefaults(level=AccessLevel.PRIVATE, makeFinal=true)
 public class SizeTester implements Tester {
+	private static enum Rule {
+		MIN_ELEMS, MAX_ELEMS;
+
+		public boolean test(int elems, int size) {
+			switch(this) {
+			case MIN_ELEMS: return elems <= size;
+			case MAX_ELEMS: return elems >= size;
+			default: return false;
+			}
+		}
+	}
+	
+	public static SizeTester minLength(int elems) {
+		return new SizeTester(JsonNodeType.STRING, Rule.MIN_ELEMS, elems);
+	}
+	
+	public static SizeTester maxLength(int elems) {
+		return new SizeTester(JsonNodeType.STRING, Rule.MAX_ELEMS, elems);
+	}
+	
+	public static SizeTester minItems(int elems) {
+		return new SizeTester(JsonNodeType.ARRAY, Rule.MIN_ELEMS, elems);
+	}
+	
+	public static SizeTester maxItems(int elems) {
+		return new SizeTester(JsonNodeType.ARRAY, Rule.MAX_ELEMS, elems);
+	}
+	
+	public static SizeTester minProperties(int elems) {
+		return new SizeTester(JsonNodeType.OBJECT, Rule.MIN_ELEMS, elems);
+	}
+	
+	public static SizeTester maxProperties(int elems) {
+		return new SizeTester(JsonNodeType.OBJECT, Rule.MAX_ELEMS, elems);
+	}
+	
 	JsonNodeType type;
-	IntPredicate pred;
+	Rule rule;
+	int elems;
 	
 	@Override
 	public JsonNodeType[] acceptedTypes() {
@@ -24,7 +59,7 @@ public class SizeTester implements Tester {
 
 	@Override
 	public boolean accepts(JsonNode node) {
-		return node.getNodeType() == type && pred.test(getSize(node));
+		return node.getNodeType() == type && rule.test(elems, getSize(node));
 	}
 
 	private int getSize(JsonNode node) {

src/test/java/org/leumasjaffe/json/schema/SchemaTest.java

@@ -62,8 +62,8 @@ public class SchemaTest {
 	
 	private Schema getStringSchema() {
 		Map<String, Tester> tests = new HashMap<>();
-		tests.put("maxLength", new SizeTester(STRING, s -> s <= 30));
-		tests.put("minLength", new SizeTester(STRING, s -> s >= 10));
+		tests.put("maxLength", SizeTester.maxLength(30));
+		tests.put("minLength", SizeTester.minLength(10));
 		tests.put("pattern", (StubTester) j -> j.asText().matches("^https://.*"));
 		tests.put("format", FormatTester.forCode("uri"));
 		return new Schema(tests);
@@ -71,8 +71,8 @@ public class SchemaTest {
 	
 	private Schema getArraySchema() {
 		Map<String, Tester> tests = new HashMap<>();
-		tests.put("maxItems", new SizeTester(ARRAY, s -> s <= 3));
-		tests.put("minItems", new SizeTester(ARRAY, s -> s >= 1));
+		tests.put("maxItems", SizeTester.maxItems(3));
+		tests.put("minItems", SizeTester.minItems(1));
 		tests.put("uniqueItems", new UniqueItemTester());
 		tests.put("contains", new ContainsTester(getNumberSchema()));
 		return new Schema(tests);
@@ -80,8 +80,8 @@ public class SchemaTest {
 
 	private Schema getObjectSchema() {
 		Map<String, Tester> tests = new HashMap<>();
-		tests.put("maxProperties", new SizeTester(OBJECT, s -> s <= 3));
-		tests.put("minProperties", new SizeTester(OBJECT, s -> s >= 2));
+		tests.put("maxProperties", SizeTester.maxProperties(3));
+		tests.put("minProperties", SizeTester.minProperties(2));
 		tests.put("required", (StubTester) json -> json.has("string"));
 		tests.put("propertyNames", new PropertyNameTester((StubTester) j -> j.asText().matches("^[a-z]*$")));
 		// TODO Dependencies

src/test/java/org/leumasjaffe/json/schema/tester/SizeTesterTest.java

@@ -5,8 +5,6 @@ import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
 import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
 import static org.leumasjaffe.json.schema.matcher.Not.not;
 
-import java.util.function.IntPredicate;
-
 import static com.fasterxml.jackson.databind.node.JsonNodeType.ARRAY;
 import static com.fasterxml.jackson.databind.node.JsonNodeType.OBJECT;
 import static com.fasterxml.jackson.databind.node.JsonNodeType.STRING;
@@ -22,62 +20,57 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.databind.node.TextNode;
 
 public class SizeTesterTest {
-	static IntPredicate NON_ZERO = i -> i > 0;
-
 	@Test
 	public void testAcceptedTypeIsArgument() {
-		assertThat(new SizeTester(ARRAY, NON_ZERO),
-				acceptsTypes(ARRAY));
-		assertThat(new SizeTester(OBJECT, NON_ZERO),
-				acceptsTypes(OBJECT));
-		assertThat(new SizeTester(STRING, NON_ZERO),
-				acceptsTypes(STRING));
+		assertThat(SizeTester.minItems(0), acceptsTypes(ARRAY));
+		assertThat(SizeTester.minProperties(0), acceptsTypes(OBJECT));
+		assertThat(SizeTester.minLength(0),	acceptsTypes(STRING));
 	}
 
 	@Test
 	public void arrayMatcherRejectsObject() {
-		final SizeTester notEmptyArray = new SizeTester(ARRAY, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minItems(0);
 		final JsonNode node = new ObjectNode(JsonNodeFactory.instance);
 		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void objectMatcherRejectsArray() {
-		final SizeTester notEmptyArray = new SizeTester(OBJECT, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minProperties(0);
 		final JsonNode node = new ArrayNode(JsonNodeFactory.instance);
 		assertThat(notEmptyArray, not(accepts(node)));
 	}
 	
 	@Test
 	public void textMatcherRejectsArray() {
-		final SizeTester notEmptyArray = new SizeTester(STRING, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minLength(0);
 		final JsonNode node = new ArrayNode(JsonNodeFactory.instance);
 		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void arrayMatcherRejectsTooSmall() {
-		final SizeTester notEmptyArray = new SizeTester(ARRAY, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minItems(1);
 		final JsonNode node = new ArrayNode(JsonNodeFactory.instance);
 		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void objectMatcherRejectsTooSmall() {
-		final SizeTester notEmptyArray = new SizeTester(OBJECT, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minProperties(1);
 		final JsonNode node = new ObjectNode(JsonNodeFactory.instance);
 		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void testMatcherRejectsTooSmall() {
-		final SizeTester notEmptyArray = new SizeTester(STRING, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minLength(1);
 		assertThat(notEmptyArray, not(accepts(new TextNode(""))));
 	}
 
 	@Test
 	public void arrayMatcherAcceptsGoodSize() {
-		final SizeTester notEmptyArray = new SizeTester(ARRAY, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minItems(1);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(NullNode.getInstance());
 		assertThat(notEmptyArray, accepts(node));
@@ -85,7 +78,7 @@ public class SizeTesterTest {
 
 	@Test
 	public void objectMatcherAcceptsGoodSize() {
-		final SizeTester notEmptyArray = new SizeTester(OBJECT, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minProperties(1);
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("_", NullNode.getInstance());
 		assertThat(notEmptyArray, accepts(node));
@@ -93,7 +86,7 @@ public class SizeTesterTest {
 
 	@Test
 	public void testMatcherAcceptsGoodSize() {
-		final SizeTester notEmptyArray = new SizeTester(STRING, NON_ZERO);
+		final SizeTester notEmptyArray = SizeTester.minLength(1);
 		assertThat(notEmptyArray, accepts(new TextNode("_")));
 	}