Improve constructible BSON toString (#972)

stIncMale · web-flow · commit c5f8ebcc9ef5 · 2022-06-28T14:37:43.000-06:00
diff --git a/bson/src/main/org/bson/Document.java b/bson/src/main/org/bson/Document.java
@@ -95,7 +95,7 @@ public Document(final String key, final Object value) {
      *
      * @param map initial map
      */
-    public Document(final Map<String, Object> map) {
+    public Document(final Map<String, ?> map) {
         documentAsMap = new LinkedHashMap<String, Object>(map);
     }
 
diff --git a/driver-core/src/main/com/mongodb/client/model/search/SearchScoreExpression.java b/driver-core/src/main/com/mongodb/client/model/search/SearchScoreExpression.java
@@ -101,10 +101,10 @@ public <TDocument> BsonDocument toBsonDocument(final Class<TDocument> documentCl
 
             @Override
             public String toString() {
-                return "{\"origin\": " + origin
-                        + ", \"path\": " + path
-                        + ", \"scale\": " + scale
-                        + '}';
+                return new Document("origin", origin)
+                        .append("path", path)
+                        .append("scale", scale)
+                        .toString();
             }
         };
         return new SearchConstructibleBsonElement("gauss", value);
diff --git a/driver-core/src/main/com/mongodb/internal/Iterables.java b/driver-core/src/main/com/mongodb/internal/Iterables.java
@@ -18,6 +18,10 @@
 import com.mongodb.lang.Nullable;
 
 import java.util.Iterator;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 import static com.mongodb.assertions.Assertions.fail;
 import static java.util.Arrays.asList;
@@ -27,16 +31,25 @@ public final class Iterables {
     @SafeVarargs
     @SuppressWarnings("varargs")
     public static <T> Iterable<T> concat(@Nullable final T first, @Nullable final T... more) {
-        if (more == null) {
-            return singleton(first);
-        } else {
-            Iterable<? extends T> moreIterable = asList(more);
-            return () -> new ConcatIterator<>(first, moreIterable);
-        }
+        return more == null ? singleton(first) : concat(first, asList(more));
     }
 
     public static <T> Iterable<T> concat(@Nullable final T first, final Iterable<? extends T> more) {
-        return () -> new ConcatIterator<>(first, more);
+        return new Iterable<T>() {
+            @Override
+            public Iterator<T> iterator() {
+                return new ConcatIterator<>(first, more);
+            }
+
+            @Override
+            public String toString() {
+                return '['
+                        + Stream.concat(Stream.of(first), StreamSupport.stream(more.spliterator(), false))
+                        .map(Objects::toString)
+                        .collect(Collectors.joining(", "))
+                        + ']';
+            }
+        };
     }
 
     private Iterables() {
diff --git a/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBson.java b/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBson.java
@@ -21,7 +21,10 @@
 import org.bson.codecs.configuration.CodecRegistry;
 import org.bson.conversions.Bson;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 
 /**
@@ -31,7 +34,7 @@
  * @param <S> A type introduced by the concrete class that extends this abstract class.
  * @see AbstractConstructibleBsonElement
  */
-public abstract class AbstractConstructibleBson<S extends AbstractConstructibleBson<S>> implements Bson {
+public abstract class AbstractConstructibleBson<S extends AbstractConstructibleBson<S>> implements Bson, ToMap {
     private static final Document EMPTY_DOC = new Document();
     /**
      * An {@linkplain Immutable immutable} {@link BsonDocument#isEmpty() empty} instance.
@@ -91,6 +94,16 @@ protected final S newMutated(final Consumer<Document> mutator) {
         return newSelf(base, newAppended);
     }
 
+    @Override
+    public Optional<Map<String, ?>> tryToMap() {
+        return ToMap.tryToMap(base)
+                .map(baseMap -> {
+                    Map<String, Object> result = new LinkedHashMap<>(baseMap);
+                    result.putAll(appended);
+                    return result;
+                });
+    }
+
     public static AbstractConstructibleBson<?> of(final Bson doc) {
         return doc instanceof AbstractConstructibleBson
                 // prevent double wrapping
@@ -117,9 +130,12 @@ public final int hashCode() {
 
     @Override
     public String toString() {
-        return "{base=" + base
-                + ", appended=" + appended
-                + '}';
+        return tryToMap()
+                .map(Document::new)
+                .map(Document::toString)
+                .orElseGet(() -> "ConstructibleBson{base=" + base
+                        + ", appended=" + appended
+                        + '}');
     }
 
     static BsonDocument newMerged(final BsonDocument base, final BsonDocument appended) {
diff --git a/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBsonElement.java b/driver-core/src/main/com/mongodb/internal/client/model/AbstractConstructibleBsonElement.java
@@ -21,8 +21,10 @@
 import org.bson.codecs.configuration.CodecRegistry;
 import org.bson.conversions.Bson;
 
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.Consumer;
 
 import static com.mongodb.internal.client.model.AbstractConstructibleBson.EMPTY_IMMUTABLE;
@@ -37,7 +39,7 @@
  * @param <S> A type introduced by the concrete class that extends this abstract class.
  * @see AbstractConstructibleBson
  */
-public abstract class AbstractConstructibleBsonElement<S extends AbstractConstructibleBsonElement<S>> implements Bson {
+public abstract class AbstractConstructibleBsonElement<S extends AbstractConstructibleBsonElement<S>> implements Bson, ToMap {
     private final Bson baseElement;
     private final AbstractConstructibleBson<?> appendedElementValue;
 
@@ -99,6 +101,32 @@ public final <TDocument> BsonDocument toBsonDocument(final Class<TDocument> docu
                 : new BsonDocument(baseElementName, newMerged(baseElementValueDoc, appendedElementValueDoc));
     }
 
+    @Override
+    public Optional<Map<String, ?>> tryToMap() {
+        Map<String, ?> baseElementMap = ToMap.tryToMap(baseElement).orElse(null);
+        Map<String, ?> appendedElementValueMap = baseElementMap == null ? null : appendedElementValue.tryToMap().orElse(null);
+        if (baseElementMap != null && appendedElementValueMap != null) {
+            if (baseElementMap.size() != 1) {
+                throw new IllegalStateException(format("baseElement must contain exactly one element, but contains %s", baseElementMap.size()));
+            }
+            Map.Entry<String, ?> baseEntry = baseElementMap.entrySet().iterator().next();
+            String elementName = baseEntry.getKey();
+            return ToMap.tryToMap(baseEntry.getValue())
+                    .map(elementValueMap -> {
+                        Map<String, Object> result = new LinkedHashMap<>(elementValueMap);
+                        result.putAll(appendedElementValueMap);
+                        return result;
+                    })
+                    .map(mergedElementValueMap -> {
+                        Map<String, Object> result = new LinkedHashMap<>();
+                        result.put(elementName, new Document(mergedElementValueMap));
+                        return result;
+                    });
+        } else {
+            return Optional.empty();
+        }
+    }
+
     public static AbstractConstructibleBsonElement<?> of(final Bson baseElement) {
         return baseElement instanceof AbstractConstructibleBsonElement
                 // prevent double wrapping
@@ -125,9 +153,12 @@ public final int hashCode() {
 
     @Override
     public String toString() {
-        return "{baseElement=" + baseElement
-                + ", appendedValue=" + appendedElementValue
-                + '}';
+        return tryToMap()
+                .map(Document::new)
+                .map(Document::toString)
+                .orElseGet(() -> "ConstructibleBsonElement{baseElement=" + baseElement
+                        + ", appendedElementValue=" + appendedElementValue
+                        + '}');
     }
 
     private static final class ConstructibleBsonElement extends AbstractConstructibleBsonElement<ConstructibleBsonElement> {
diff --git a/driver-core/src/main/com/mongodb/internal/client/model/ToMap.java b/driver-core/src/main/com/mongodb/internal/client/model/ToMap.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.internal.client.model;
+
+import org.bson.BsonDocument;
+import org.bson.Document;
+
+import java.util.Map;
+import java.util.Optional;
+
+interface ToMap {
+    Optional<Map<String, ?>> tryToMap();
+
+    static Optional<Map<String, ?>> tryToMap(final Object o) {
+        if (o instanceof ToMap) {
+            return ((ToMap) o).tryToMap();
+        } else if (o instanceof Document || o instanceof BsonDocument) {
+            @SuppressWarnings("unchecked")
+            Map<String, ?> map = (Map<String, ?>) o;
+            return Optional.of(map);
+        } else {
+            return Optional.empty();
+        }
+    }
+}
diff --git a/driver-core/src/test/unit/com/mongodb/internal/IterablesTest.java b/driver-core/src/test/unit/com/mongodb/internal/IterablesTest.java
@@ -50,5 +50,6 @@ void concat() {
 
     private static <T> void assertIterable(final List<? extends T> expected, final Iterable<? extends T> actual) {
         assertEquals(expected, stream(actual).collect(toList()));
+        assertEquals(expected.toString(), actual.toString());
     }
 }
diff --git a/driver-core/src/test/unit/com/mongodb/internal/client/model/AbstractConstructibleBsonElementTest.java b/driver-core/src/test/unit/com/mongodb/internal/client/model/AbstractConstructibleBsonElementTest.java
@@ -17,6 +17,7 @@
 
 import org.bson.BsonDocument;
 import org.bson.BsonString;
+import org.bson.Document;
 import org.bson.conversions.Bson;
 import org.junit.jupiter.api.Test;
 
@@ -99,6 +100,21 @@ void newWithAppendedValue() {
                 appendedConstructible.toBsonDocument());
     }
 
+    @Test
+    void tostring() {
+        assertEquals(
+                new Document("name",
+                        new Document("double", 0.5)
+                        .append("doc", new Document("i", 42))
+                        .append("constructible", new Document("s", "")))
+                        .toString(),
+                AbstractConstructibleBsonElement.of(new Document("name",
+                        AbstractConstructibleBson.of(new Document("double", 0.5))
+                                .newAppended("doc", new Document("i", 42))))
+                        .newWithAppendedValue("constructible", AbstractConstructibleBson.of(AbstractConstructibleBson.of(new Document("s", ""))))
+                        .toString());
+    }
+
     private static void assertUnmodifiable(final AbstractConstructibleBsonElement<?> constructible) {
         String expected = constructible.toBsonDocument().toJson();
         constructible.newWithAppendedValue("assertUnmodifiableN", "assertUnmodifiableV");
diff --git a/driver-core/src/test/unit/com/mongodb/internal/client/model/AbstractConstructibleBsonTest.java b/driver-core/src/test/unit/com/mongodb/internal/client/model/AbstractConstructibleBsonTest.java
@@ -15,12 +15,14 @@
  */
 package com.mongodb.internal.client.model;
 
+import org.bson.BsonArray;
 import org.bson.BsonDocument;
 import org.bson.BsonString;
 import org.bson.Document;
 import org.bson.conversions.Bson;
 import org.junit.jupiter.api.Test;
 
+import static java.util.Arrays.asList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertSame;
 
@@ -68,6 +70,23 @@ void appendedCannotBeMutatedViaToBsonDocument() {
         appendedCannotBeMutatedViaToBsonDocument(new Document("appendedName", "appendedValue"));
     }
 
+    @Test
+    void tostring() {
+        assertEquals(
+                new Document(
+                        "array", new BsonArray(asList(new BsonString("e1"), new BsonString("e2"))))
+                        .append("double", 0.5)
+                        .append("doc", new Document("i", 42))
+                        .append("constructible", new Document("s", ""))
+                        .toString(),
+                AbstractConstructibleBson.of(
+                        new BsonDocument("array", new BsonArray(asList(new BsonString("e1"), new BsonString("e2")))))
+                        .newAppended("double", 0.5)
+                        .newAppended("doc", new Document("i", 42))
+                        .newAppended("constructible", AbstractConstructibleBson.of(AbstractConstructibleBson.of(new Document("s", ""))))
+                        .toString());
+    }
+
     private static void appendedCannotBeMutatedViaToBsonDocument(final Document appended) {
         String expected = appended.toBsonDocument().toJson();
         final class Constructible extends AbstractConstructibleBson<Constructible> {

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ public Document(final String key, final Object value) {`
`95`	`95`	`*`
`96`	`96`	`* @param map initial map`
`97`	`97`	`*/`
`98`		`- public Document(final Map<String, Object> map) {`
	`98`	`+ public Document(final Map<String, ?> map) {`
`99`	`99`	`documentAsMap = new LinkedHashMap<String, Object>(map);`
`100`	`100`	`}`
`101`	`101`
Original file line number	Diff line number	Diff line change
`@@ -50,5 +50,6 @@ void concat() {`
`50`	`50`
`51`	`51`	`private static <T> void assertIterable(final List<? extends T> expected, final Iterable<? extends T> actual) {`
`52`	`52`	`assertEquals(expected, stream(actual).collect(toList()));`
	`53`	`+ assertEquals(expected.toString(), actual.toString());`
`53`	`54`	`}`
`54`	`55`	`}`