[json-node] Simplify JsonNode.Type enum

json-node/pom.xml

@@ -11,6 +11,10 @@
 
   <artifactId>avaje-json-node</artifactId>
 
+  <properties>
+<!--    <maven.compiler.release>17</maven.compiler.release>-->
+  </properties>
+
   <dependencies>
 
     <dependency>

json-node/src/main/java/io/avaje/json/node/JsonNode.java

@@ -3,62 +3,60 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Represents the code JSON types.
+ * Represents the core JSON types.
  */
-public interface JsonNode {
+public /*sealed*/ interface JsonNode
+  /*permits JsonArray, JsonObject, JsonBoolean, JsonString, JsonNumber*/ {
 
   /**
    * The types for JsonNode.
    */
   enum Type {
-    ARRAY(true, false),
-    OBJECT(false, true),
+    ARRAY(false),
+    OBJECT(false),
     NULL(),
     BOOLEAN(),
     STRING(),
-    NUMBER(true),
+    NUMBER(),
     ;
     // BINARY,
-    // MISSING,
     // POJO
     private final boolean value;
-    private final boolean numberType;
-    private final boolean arrayType;
-    private final boolean objectType;
 
     Type() {
-      this(true, false, false, false);
+      this(true);
     }
 
-    Type(boolean numberType) {
-      this(true, numberType, false, false);
-    }
-
-    Type(boolean arrayType, boolean objectType) {
-      this(false, false, arrayType, objectType);
-    }
-
-    Type(boolean value, boolean numberType, boolean arrayType, boolean objectType) {
+    Type(boolean value) {
       this.value = value;
-      this.numberType = numberType;
-      this.arrayType = arrayType;
-      this.objectType = objectType;
     }
 
+    /**
+     * True for JsonBoolean, JsonString and JsonNumber's and NULL.
+     */
     public boolean isValue() {
       return value;
     }
 
+    /**
+     * True for the JsonNumber implementations only.
+     */
     public boolean isNumber() {
-      return numberType;
+      return this == Type.NUMBER;
     }
 
+    /**
+     * True for JsonArray only.
+     */
     public boolean isArray() {
-      return arrayType;
+      return this == Type.ARRAY;
     }
 
+    /**
+     * True for JsonObject only.
+     */
     public boolean isObject() {
-      return objectType;
+      return this == Type.OBJECT;
     }
   }
 

json-node/src/main/java/io/avaje/json/node/JsonNumber.java

@@ -7,7 +7,8 @@
 /**
  * JsonNode Number type.
  */
-public interface JsonNumber extends JsonNode {
+public /*sealed*/ interface JsonNumber extends JsonNode
+  /*permits JsonInteger, JsonLong, JsonDouble, JsonDecimal*/ {
 
   /**
    * Return the int value for the number.

json-node/src/test/java/io/avaje/json/node/JsonBooleanTest.java

@@ -0,0 +1,36 @@
+package io.avaje.json.node;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JsonBooleanTest {
+
+  static final JsonBoolean jsonBoolean = JsonBoolean.of(true);
+
+  @Test
+  void type() {
+    assertThat(jsonBoolean.type()).isEqualTo(JsonNode.Type.BOOLEAN);
+    assertThat(jsonBoolean.type().isValue()).isTrue();
+    assertThat(jsonBoolean.type().isNumber()).isFalse();
+  }
+
+  @Test
+  void copy() {
+    assertThat(jsonBoolean.copy()).isSameAs(jsonBoolean);
+  }
+
+  @Test
+  void unmodifiable() {
+    assertThat(jsonBoolean.unmodifiable()).isSameAs(jsonBoolean);
+  }
+
+  @Test
+  void value() {
+    assertThat(jsonBoolean.value()).isTrue();
+    assertThat(JsonBoolean.of(false).value()).isFalse();
+  }
+
+}

json-node/src/test/java/io/avaje/json/node/JsonDecimalTest.java

@@ -0,0 +1,36 @@
+package io.avaje.json.node;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JsonDecimalTest {
+
+  static final JsonDecimal jsonDecimal = JsonDecimal.of(new BigDecimal("42.3"));
+
+  @Test
+  void type() {
+    assertThat(jsonDecimal.type()).isEqualTo(JsonNode.Type.NUMBER);
+    assertThat(jsonDecimal.type().isNumber()).isTrue();
+  }
+
+  @Test
+  void copy() {
+    assertThat(jsonDecimal.copy()).isSameAs(jsonDecimal);
+  }
+
+  @Test
+  void unmodifiable() {
+    assertThat(jsonDecimal.unmodifiable()).isSameAs(jsonDecimal);
+  }
+
+  @Test
+  void value() {
+    assertThat(jsonDecimal.doubleValue()).isEqualTo(42.3D);
+    assertThat(jsonDecimal.numberValue()).isEqualTo(new BigDecimal("42.3"));
+    assertThat(jsonDecimal.decimalValue()).isEqualByComparingTo(new BigDecimal("42.3"));
+  }
+
+}

json-node/src/test/java/io/avaje/json/node/JsonDoubleTest.java

@@ -0,0 +1,38 @@
+package io.avaje.json.node;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JsonDoubleTest {
+
+  static final JsonDouble jsonDouble = JsonDouble.of(42.3);
+
+  @Test
+  void type() {
+    assertThat(jsonDouble.type()).isEqualTo(JsonNode.Type.NUMBER);
+    assertThat(jsonDouble.type().isNumber()).isTrue();
+  }
+
+  @Test
+  void copy() {
+    assertThat(jsonDouble.copy()).isSameAs(jsonDouble);
+  }
+
+  @Test
+  void unmodifiable() {
+    assertThat(jsonDouble.unmodifiable()).isSameAs(jsonDouble);
+  }
+
+  @Test
+  void value() {
+    assertThat(jsonDouble.intValue()).isEqualTo(42);
+    assertThat(jsonDouble.longValue()).isEqualTo(42L);
+    assertThat(jsonDouble.doubleValue()).isEqualTo(42.3D);
+    assertThat(jsonDouble.numberValue()).isEqualTo(42.3D);
+    assertThat(jsonDouble.decimalValue()).isEqualByComparingTo(new BigDecimal("42.3"));
+  }
+
+}

json-node/src/test/java/io/avaje/json/node/JsonIntegerTest.java

@@ -0,0 +1,38 @@
+package io.avaje.json.node;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JsonIntegerTest {
+
+  static final JsonInteger jsonInteger = JsonInteger.of(42);
+
+  @Test
+  void type() {
+    assertThat(jsonInteger.type()).isEqualTo(JsonNode.Type.NUMBER);
+    assertThat(jsonInteger.type().isNumber()).isTrue();
+  }
+
+  @Test
+  void copy() {
+    assertThat(jsonInteger.copy()).isSameAs(jsonInteger);
+  }
+
+  @Test
+  void unmodifiable() {
+    assertThat(jsonInteger.unmodifiable()).isSameAs(jsonInteger);
+  }
+
+  @Test
+  void value() {
+    assertThat(jsonInteger.intValue()).isEqualTo(42);
+    assertThat(jsonInteger.longValue()).isEqualTo(42L);
+    assertThat(jsonInteger.doubleValue()).isEqualTo(42D);
+    assertThat(jsonInteger.numberValue()).isEqualTo(42);
+    assertThat(jsonInteger.decimalValue()).isEqualTo(BigDecimal.valueOf(42));
+  }
+
+}

json-node/src/test/java/io/avaje/json/node/JsonLongTest.java

@@ -0,0 +1,38 @@
+package io.avaje.json.node;
+
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JsonLongTest {
+
+  static final JsonLong jsonLong = JsonLong.of(42);
+
+  @Test
+  void type() {
+    assertThat(jsonLong.type()).isEqualTo(JsonNode.Type.NUMBER);
+    assertThat(jsonLong.type().isNumber()).isTrue();
+  }
+
+  @Test
+  void copy() {
+    assertThat(jsonLong.copy()).isSameAs(jsonLong);
+  }
+
+  @Test
+  void unmodifiable() {
+    assertThat(jsonLong.unmodifiable()).isSameAs(jsonLong);
+  }
+
+  @Test
+  void value() {
+    assertThat(jsonLong.intValue()).isEqualTo(42);
+    assertThat(jsonLong.longValue()).isEqualTo(42L);
+    assertThat(jsonLong.doubleValue()).isEqualTo(42D);
+    assertThat(jsonLong.numberValue()).isEqualTo(42L);
+    assertThat(jsonLong.decimalValue()).isEqualTo(BigDecimal.valueOf(42));
+  }
+
+}

json-node/src/test/java/io/avaje/json/node/JsonObjectTest.java

@@ -102,6 +102,7 @@ void findNested() {
     assertThat(personName.text()).isEqualTo("myName");
 
     assertThat(node.extract("person.name")).isEqualTo("myName");
+    assertThat(node.extract("person.missing", "SomeDefaultValue")).isEqualTo("SomeDefaultValue");
     assertThat(node.extract("person.active")).isEqualTo("true");
     assertThat(node.extract("person.active", false)).isEqualTo(true);
     assertThat(node.extract("person.missing", false)).isEqualTo(false);

json-node/src/test/java/io/avaje/json/node/JsonStringTest.java

@@ -0,0 +1,34 @@
+package io.avaje.json.node;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JsonStringTest {
+
+  static final JsonString jsonString = JsonString.of("foo");
+
+  @Test
+  void type() {
+    assertThat(jsonString.type()).isEqualTo(JsonNode.Type.STRING);
+    assertThat(jsonString.type().isValue()).isTrue();
+    assertThat(jsonString.type().isNumber()).isFalse();
+  }
+
+  @Test
+  void copy() {
+    assertThat(jsonString.copy()).isSameAs(jsonString);
+  }
+
+  @Test
+  void unmodifiable() {
+    assertThat(jsonString.unmodifiable()).isSameAs(jsonString);
+  }
+
+  @Test
+  void value() {
+    assertThat(jsonString.value()).isEqualTo("foo");
+    assertThat(jsonString.text()).isEqualTo("foo");
+  }
+
+}