[core] Update javadoc and readme + rename internal DSimpleMapper

json-core/README.md

@@ -12,7 +12,7 @@ Provides the core API including JsonAdapter, JsonReader, JsonWriter, JsonStream
 </dependency>
 ```
 
-## SimpleMapper
+## JsonMapper
 
 If you only have simple use cases you can use avaje-json
 without avaje-jsonb.
@@ -26,9 +26,9 @@ For use cases that only want to map to the following types:
 - Map<String, Object>
 - List<Object>
 
-### Create a SimpleMapper
+### Create a JsonMapper
 
-static final SimpleMapper mapper = SimpleMapper.builder().build()
+static final JsonMapper mapper = JsonMapper.builder().build()
 
 
 ### Map example

json-core/src/main/java/io/avaje/json/mapper/DSimpleMapper.java → json-core/src/main/java/io/avaje/json/mapper/DJsonMapper.java

@@ -11,14 +11,14 @@
 import java.util.Map;
 import java.util.function.Function;
 
-final class DSimpleMapper implements JsonMapper {
+final class DJsonMapper implements JsonMapper {
 
   private final JsonStream jsonStream;
   private final Type<Object> objectType;
   private final Type<Map<String,Object>> mapType;
   private final Type<List<Object>> listType;
 
-  DSimpleMapper(JsonStream jsonStream, CoreTypes.CoreAdapters adapters) {
+  DJsonMapper(JsonStream jsonStream, CoreTypes.CoreAdapters adapters) {
     this.jsonStream = jsonStream;
     this.objectType = new DTypeMapper<>(adapters.objectAdapter(), jsonStream);
     this.mapType = new DTypeMapper<>(adapters.mapAdapter(), jsonStream);

json-core/src/main/java/io/avaje/json/mapper/DSimpleMapperBuilder.java → json-core/src/main/java/io/avaje/json/mapper/DJsonMapperBuilder.java

@@ -3,7 +3,7 @@
 import io.avaje.json.core.CoreTypes;
 import io.avaje.json.stream.JsonStream;
 
-final class DSimpleMapperBuilder implements JsonMapper.Builder {
+final class DJsonMapperBuilder implements JsonMapper.Builder {
 
   private JsonStream jsonStream;
 
@@ -17,6 +17,6 @@ public JsonMapper.Builder jsonStream(JsonStream jsonStream) {
   public JsonMapper build() {
     final var stream = jsonStream != null ? jsonStream : JsonStream.builder().build();
     final var coreAdapters = CoreTypes.createCoreAdapters();
-    return new DSimpleMapper(stream, coreAdapters);
+    return new DJsonMapper(stream, coreAdapters);
   }
 }

json-core/src/main/java/io/avaje/json/mapper/JsonExtract.java

@@ -15,9 +15,9 @@
  * <pre>{@code
  *
  *   String json = "{\"name\":\"Rob\",\"score\":4.5,\"whenActive\":\"2025-10-20\",\"address\":{\"street\":\"Pall Mall\"}}";
- *   Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+ *   Map<String, Object> mapFromJson = jsonMapper.fromJsonObject(json);
  *
- *   JsonExtract jsonExtract = simpleMapper.extract(mapFromJson);
+ *   JsonExtract jsonExtract = jsonMapper.extract(mapFromJson);
  *
  *   String name = jsonExtract.extract("name");
  *   double score = jsonExtract.extract("score", -1D);

json-core/src/main/java/io/avaje/json/mapper/JsonMapper.java

@@ -20,28 +20,32 @@
  * This supports the basic Java types of String, Boolean, Integer, Long, Double and
  * Maps and List of these.
  * <p>
+ * If avaje-jsonb is available then you will use that and NOT use this JsonMapper at all.
+ * This JsonMapper is intended to be used by code that ONLY wants to depend on avaje-json-core
+ * and process the basic Java types or provide its own JsonAdapters.
+ * <p>
  * For full support with more types and binding to custom types use avaje-jsonb instead.
  *
  * <h3>Example</h3>
  * <pre>{@code
  *
- *   static final SimpleMapper simpleMapper = SimpleMapper.builder().build();
+ *   static final JsonMapper jsonMapper = JsonMapper.builder().build();
  *
  *   Map<String, Long> map = new LinkedHashMap<>();
  *   map.put("one", 45L);
  *   map.put("two", 93L);
  *
- *   String asJson = simpleMapper.toJson(map);
+ *   String asJson = jsonMapper.toJson(map);
  *
  * }</pre>
  */
 public interface JsonMapper {
 
   /**
-   * Create a new builder for SimpleMapper.
+   * Create a new builder for JsonMapper.
    */
   static Builder builder() {
-    return new DSimpleMapperBuilder();
+    return new DJsonMapperBuilder();
   }
 
   /**
@@ -141,7 +145,7 @@ static Builder builder() {
    * Return a Type specific mapper using a function that creates a JsonAdapter.
    * <p>
    * Often the adapterFunction is the constructor of the custom JsonAdapter where
-   * the constructor takes SimpleMapper as the only argument.
+   * the constructor takes JsonMapper as the only argument.
    *
    * @param adapterFunction The function that creates a JsonAdapter.
    * @param <T>             The type of the class to map to/from json.

json-core/src/test/java/io/avaje/json/mapper/CustomAdapter2Test.java

@@ -10,15 +10,15 @@
 
 class CustomAdapter2Test {
 
-  static final JsonMapper simpleMapper = JsonMapper.builder().build();
+  static final JsonMapper mapper = JsonMapper.builder().build();
 
   @Test
   void mapUsingCustomAdapter() {
 
-    PropertyNames names = simpleMapper.properties("foo", "bar");
+    PropertyNames names = mapper.properties("foo", "bar");
     MyAdapterUsingRaw myAdapter = new MyAdapterUsingRaw(names);
 
-    JsonMapper.Type<MyOtherType> type = simpleMapper.type(myAdapter);
+    JsonMapper.Type<MyOtherType> type = mapper.type(myAdapter);
 
     MyOtherType source = new MyOtherType();
     source.foo = "hi";

json-core/src/test/java/io/avaje/json/mapper/CustomAdapterTest.java

@@ -15,9 +15,9 @@
 class CustomAdapterTest {
 
   static final JsonStream jsonStream = JsonStream.builder().build();
-  static final JsonMapper simpleMapper = JsonMapper.builder().jsonStream(jsonStream).build();
-  static final MyAdapter myAdapter = new MyAdapter(simpleMapper);
-  static final JsonMapper.Type<MyCustomType> type = simpleMapper.type(myAdapter);
+  static final JsonMapper mapper = JsonMapper.builder().jsonStream(jsonStream).build();
+  static final MyAdapter myAdapter = new MyAdapter(mapper);
+  static final JsonMapper.Type<MyCustomType> type = mapper.type(myAdapter);
 
   @Test
   void mapUsingCustomAdapter() {
@@ -92,8 +92,8 @@ static class MyAdapter implements JsonAdapter<MyCustomType> {
 
     private final JsonMapper.Type<Map<String, Object>> map;
 
-    public MyAdapter(JsonMapper simpleMapper) {
-      this.map = simpleMapper.map();
+    public MyAdapter(JsonMapper mapper) {
+      this.map = mapper.map();
     }
 
     @Override

json-core/src/test/java/io/avaje/json/mapper/SimpleMapperTest.java → json-core/src/test/java/io/avaje/json/mapper/JsonMapperTest.java

@@ -14,9 +14,9 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-class SimpleMapperTest {
+class JsonMapperTest {
 
-  static final JsonMapper simpleMapper = JsonMapper.builder().build();
+  static final JsonMapper mapper = JsonMapper.builder().build();
 
   @Test
   void mapToJsonFromJson() {
@@ -25,20 +25,20 @@ void mapToJsonFromJson() {
     map.put("one", 45L);
     map.put("two", 93L);
 
-    String asJson = simpleMapper.toJson(map);
+    String asJson = mapper.toJson(map);
     assertThat(asJson).isEqualTo("{\"one\":45,\"two\":93}");
 
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(asJson);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(asJson);
 
     assertThat(mapFromJson).containsKeys("one", "two");
     assertThat(mapFromJson.toString()).isEqualTo("{one=45, two=93}");
 
-    Map<String, Object> mapFromJson2 = simpleMapper.map().fromJson(asJson);
+    Map<String, Object> mapFromJson2 = mapper.map().fromJson(asJson);
     assertThat(mapFromJson2).isEqualTo(mapFromJson);
 
     JsonStream jsonStream = JsonStream.builder().build();
     try (JsonReader reader = jsonStream.reader(asJson)) {
-      Map<String, Object> mapFromJson3 = simpleMapper.fromJsonObject(reader);
+      Map<String, Object> mapFromJson3 = mapper.fromJsonObject(reader);
       assertThat(mapFromJson3).isEqualTo(mapFromJson);
     }
   }
@@ -47,67 +47,67 @@ void mapToJsonFromJson() {
   void toJsonWriter_scalar() {
     JsonStream jsonStream = JsonStream.builder().build();
     BufferedJsonWriter writer0 = jsonStream.bufferedWriter();
-    simpleMapper.toJson("hi", writer0);
+    mapper.toJson("hi", writer0);
     assertThat(writer0.result()).isEqualTo("\"hi\"");
   }
 
   @Test
   void toJsonWriter_map() {
     JsonStream jsonStream = JsonStream.builder().build();
     BufferedJsonWriter writer0 = jsonStream.bufferedWriter();
-    simpleMapper.toJson(Map.of("key", 0), writer0);
+    mapper.toJson(Map.of("key", 0), writer0);
     assertThat(writer0.result()).isEqualTo("{\"key\":0}");
   }
 
   @Test
   void toJsonWriter_list() {
     JsonStream jsonStream = JsonStream.builder().build();
     BufferedJsonWriter writer0 = jsonStream.bufferedWriter();
-    simpleMapper.toJson(List.of("a", 0), writer0);
+    mapper.toJson(List.of("a", 0), writer0);
     assertThat(writer0.result()).isEqualTo("[\"a\",0]");
   }
 
   @Test
   void nullDirectly() {
-    var mapFromJson = simpleMapper.fromJson("null");
+    var mapFromJson = mapper.fromJson("null");
     assertThat(mapFromJson).isNull();
   }
 
   @Test
   void objectJsonReader() {
     try (var reader = JsonStream.builder().build().reader("\"hi\"")) {
-      var fromJson = simpleMapper.fromJson(reader);
+      var fromJson = mapper.fromJson(reader);
       assertThat(fromJson).isEqualTo("hi");
     }
   }
 
   @Test
   void mapWithNull() {
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject("{\"one\":1,\"two\":null,\"three\":3}");
+    Map<String, Object> mapFromJson = mapper.fromJsonObject("{\"one\":1,\"two\":null,\"three\":3}");
 
     assertThat(mapFromJson).containsKeys("one", "two", "three");
     assertThat(mapFromJson.toString()).isEqualTo("{one=1, two=null, three=3}");
 
-    assertThat(simpleMapper.toJson(mapFromJson)).isEqualTo("{\"one\":1,\"three\":3}");
+    assertThat(mapper.toJson(mapFromJson)).isEqualTo("{\"one\":1,\"three\":3}");
   }
 
   @Test
   void listWithNull() {
-    List<Object> listFromJson = simpleMapper.fromJsonArray("[1,null,3]");
+    List<Object> listFromJson = mapper.fromJsonArray("[1,null,3]");
 
     assertThat(listFromJson).hasSize(3);
     assertThat(listFromJson.get(1)).isNull();
 
-    assertThat(simpleMapper.toJson(listFromJson)).isEqualTo("[1,3]");
+    assertThat(mapper.toJson(listFromJson)).isEqualTo("[1,3]");
   }
 
   @Test
   void listWithReader() {
     try (JsonReader reader = JsonStream.builder().build().reader("[1,2]")) {
-      List<Object> listFromJson = simpleMapper.fromJsonArray(reader);
+      List<Object> listFromJson = mapper.fromJsonArray(reader);
 
       assertThat(listFromJson).hasSize(2);
-      assertThat(simpleMapper.toJson(listFromJson)).isEqualTo("[1,2]");
+      assertThat(mapper.toJson(listFromJson)).isEqualTo("[1,2]");
     }
   }
 
@@ -123,24 +123,24 @@ void arrayToJsonFromJson() {
 
     List<Map<String, Long>> list = List.of(map0, map1);
 
-    String asJson = simpleMapper.toJson(list);
+    String asJson = mapper.toJson(list);
     assertThat(asJson).isEqualTo("[{\"one\":45,\"two\":93},{\"one\":27}]");
 
-    List<Object> listFromJson = simpleMapper.fromJsonArray(asJson);
+    List<Object> listFromJson = mapper.fromJsonArray(asJson);
 
     assertThat(listFromJson).hasSize(2);
     assertThat(listFromJson.toString()).isEqualTo("[{one=45, two=93}, {one=27}]");
 
-    List<Object> list2 = simpleMapper.list().fromJson(asJson);
+    List<Object> list2 = mapper.list().fromJson(asJson);
     assertThat(list2).isEqualTo(listFromJson);
   }
 
   @Test
   void extract_example() {
     String json = "{\"name\":\"Rob\",\"score\":4.5,\"whenActive\":\"2025-10-20\",\"address\":{\"street\":\"Pall Mall\"}}";
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(json);
 
-    JsonExtract extract = simpleMapper.extract(mapFromJson);
+    JsonExtract extract = mapper.extract(mapFromJson);
 
     String name = extract.extract("name");
     double score = extract.extract("score", -1D);
@@ -158,9 +158,9 @@ void extract_example() {
   @Test
   void extract() {
     String json = "{\"one\":1,\"two\":4.5,\"three\":3,\"four\":\"2025-10-20\",\"five\":true}";
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(json);
 
-    JsonExtract extract = simpleMapper.extract(mapFromJson);
+    JsonExtract extract = mapper.extract(mapFromJson);
     assertThat(extract.extract("one", 0)).isEqualTo(1);
     assertThat(extract.extract("two", 0D)).isEqualTo(4.5D);
     assertThat(extract.extract("three", 0L)).isEqualTo(3L);
@@ -180,7 +180,7 @@ void extract() {
   @Test
   void JsonExtractOf() {
     String json = "{\"one\":1}";
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(json);
 
     JsonExtract extract = JsonExtract.of(mapFromJson);
     assertThat(extract.extract("one", 0)).isEqualTo(1);
@@ -189,9 +189,9 @@ void JsonExtractOf() {
   @Test
   void extract_whenMissing() {
     String json = "{}";
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(json);
 
-    JsonExtract extract = simpleMapper.extract(mapFromJson);
+    JsonExtract extract = mapper.extract(mapFromJson);
     assertThat(extract.extract("one", 0)).isEqualTo(0);
     assertThat(extract.extract("two", 0D)).isEqualTo(0D);
     assertThat(extract.extract("three", 0L)).isEqualTo(0L);
@@ -211,9 +211,9 @@ void extract_whenMissing() {
   @Test
   void extractNumber_whenNotANumber_expect_missingValue() {
     String json = "{\"text\":\"foo\",\"bool\":true,\"isNull\":null}";
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(json);
 
-    JsonExtract extract = simpleMapper.extract(mapFromJson);
+    JsonExtract extract = mapper.extract(mapFromJson);
     assertThat(extract.extract("text", 7)).isEqualTo(7);
     assertThat(extract.extract("text", 7L)).isEqualTo(7L);
     assertThat(extract.extract("text", 7.4D)).isEqualTo(7.4D);
@@ -228,9 +228,9 @@ void extractNumber_whenNotANumber_expect_missingValue() {
   @Test
   void extract_nestedPath() {
     String json = "{\"outer\":{\"a\":\"v0\", \"b\":1, \"c\":true,\"d\":{\"x\":\"x0\",\"y\":42,\"date\":\"2025-10-20\"}}}";
-    Map<String, Object> mapFromJson = simpleMapper.fromJsonObject(json);
+    Map<String, Object> mapFromJson = mapper.fromJsonObject(json);
 
-    JsonExtract extract = simpleMapper.extract(mapFromJson);
+    JsonExtract extract = mapper.extract(mapFromJson);
     assertThat(extract.extract("outer.b", 0)).isEqualTo(1);
     assertThat(extract.extract("outer.d.y", 0)).isEqualTo(42);
     assertThat(extract.extract("outer.d.y", "junk")).isEqualTo("42");