graphql-java · andimarek · Dec 15, 2018 · Dec 1, 2018 · Dec 1, 2018 · Dec 1, 2018
diff --git a/src/main/java/graphql/analysis/ChildrenOfSelectionProvider.java b/src/main/java/graphql/analysis/ChildrenOfSelectionProvider.java
@@ -51,15 +51,15 @@ public TraversalControl visitField(Field node, TraverserContext<Node> context) {
 
     @Override
     public TraversalControl visitSelectionSet(SelectionSet node, TraverserContext<Node> context) {
-        context.setResult(node.getSelections());
+        context.setAccumulate(node.getSelections());
         return TraversalControl.CONTINUE;
     }
 
     private void getSelectionSetChildren(SelectionSet node, TraverserContext<Node> context) {
         if (node == null) {
-            context.setResult(Collections.emptyList());
+            context.setAccumulate(Collections.emptyList());
         } else {
-            context.setResult(node.getSelections());
+            context.setAccumulate(node.getSelections());
         }
     }
 

diff --git a/src/main/java/graphql/execution2/result/ExecutionResultMultiZipper.java b/src/main/java/graphql/execution2/result/ExecutionResultMultiZipper.java
@@ -8,11 +8,16 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.toList;
+
 @Internal
 public class ExecutionResultMultiZipper {
 
+
     private final ExecutionResultNode commonRoot;
     private final List<ExecutionResultZipper> zippers;
 
@@ -68,7 +73,7 @@ public ExecutionResultMultiZipper withReplacedZipper(ExecutionResultZipper oldZi
 
     private List<ExecutionResultZipper> getDeepestZippers(List<ExecutionResultZipper> zippers) {
         Map<Integer, List<ExecutionResultZipper>> grouped =
-                zippers.stream().collect(Collectors.groupingBy(executionResultZipper -> executionResultZipper.getBreadcrumbList().size()));
+                zippers.stream().collect(Collectors.groupingBy(executionResultZipper -> executionResultZipper.getBreadcrumbList().size(), LinkedHashMap::new, mapping(Function.identity(), toList())));
         Integer maxLevel = Collections.max(grouped.keySet());
         return grouped.get(maxLevel);
     }
@@ -85,7 +90,7 @@ private ExecutionResultZipper moveUp(ExecutionResultNode parent, List<ExecutionR
     }
 
     private Map<ExecutionResultNode, List<ExecutionResultZipper>> zipperWithSameParent(List<ExecutionResultZipper> zippers) {
-        return zippers.stream().collect(Collectors.groupingBy(ExecutionResultZipper::getParent));
+        return zippers.stream().collect(Collectors.groupingBy(ExecutionResultZipper::getParent, LinkedHashMap::new, mapping(Function.identity(), toList())));
     }
 
 }
diff --git a/src/main/java/graphql/language/AbstractNode.java b/src/main/java/graphql/language/AbstractNode.java
@@ -52,5 +52,4 @@ protected <V extends Node> List<V> deepCopy(List<? extends Node> list) {
         }
         return list.stream().map(Node::deepCopy).map(node -> (V) node).collect(Collectors.toList());
     }
-
 }
diff --git a/src/main/java/graphql/language/Argument.java b/src/main/java/graphql/language/Argument.java
@@ -10,11 +10,15 @@
 import java.util.List;
 import java.util.function.Consumer;
 
+import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
+
 @PublicApi
 public class Argument extends AbstractNode<Argument> implements NamedNode<Argument> {
 
-    private String name;
-    private Value value;
+    private final String name;
+    private final Value value;
+
+    public static final String CHILD_VALUE = "value";
 
     @Internal
     protected Argument(String name, Value value, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars) {
@@ -42,21 +46,26 @@ public Value getValue() {
         return value;
     }
 
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public void setValue(Value value) {
-        this.value = value;
-    }
-
     @Override
     public List<Node> getChildren() {
         List<Node> result = new ArrayList<>();
         result.add(value);
         return result;
     }
 
+    @Override
+    public NodeChildrenContainer getNamedChildren() {
+        return newNodeChildrenContainer()
+                .child(CHILD_VALUE, value)
+                .build();
+    }
+
+    @Override
+    public Argument withNewChildren(NodeChildrenContainer newChildren) {
+        return transform(builder -> builder
+                .value(newChildren.getChildOrNull(CHILD_VALUE))
+        );
+    }
 
     @Override
     public boolean isEqualTo(Node o) {

diff --git a/src/main/java/graphql/language/ArrayValue.java b/src/main/java/graphql/language/ArrayValue.java
@@ -10,11 +10,15 @@
 import java.util.List;
 import java.util.function.Consumer;
 
+import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
+
 @PublicApi
 public class ArrayValue extends AbstractNode<ArrayValue> implements Value<ArrayValue> {
 
     private final List<Value> values = new ArrayList<>();
 
+    public static final String CHILD_VALUES = "values";
+
     @Internal
     protected ArrayValue(List<Value> values, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars) {
         super(sourceLocation, comments, ignoredChars);
@@ -39,6 +43,20 @@ public List<Node> getChildren() {
         return new ArrayList<>(values);
     }
 
+    @Override
+    public NodeChildrenContainer getNamedChildren() {
+        return newNodeChildrenContainer()
+                .children(CHILD_VALUES, values)
+                .build();
+    }
+
+    @Override
+    public ArrayValue withNewChildren(NodeChildrenContainer newChildren) {
+        return transform(builder -> builder
+                .values(newChildren.getChildren(CHILD_VALUES))
+        );
+    }
+
     @Override
     public boolean isEqualTo(Node o) {
         if (this == o) {

diff --git a/src/main/java/graphql/language/AstBreadcrumb.java b/src/main/java/graphql/language/AstBreadcrumb.java
@@ -0,0 +1,57 @@
+package graphql.language;
+
+import graphql.PublicApi;
+
+import java.util.Objects;
+
+/**
+ * Used by {@link AstZipper} to identify the position of the current node inside the tree:
+ * the breadcrumbs lead you to the root node.
+ */
+@PublicApi
+public class AstBreadcrumb {
+
+    private final Node node;
+    private final NodeLocation location;
+
+    public AstBreadcrumb(Node node, NodeLocation location) {
+        this.node = node;
+        this.location = location;
+    }
+
+    public Node getNode() {
+        return node;
+    }
+
+    public NodeLocation getLocation() {
+        return location;
+    }
+
+
+    @Override
+    public String toString() {
+        return "AstBreadcrumb{" +
+                "node=" + node +
+                ", location=" + location +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        AstBreadcrumb that = (AstBreadcrumb) o;
+        return Objects.equals(node, that.node) &&
+                Objects.equals(location, that.location);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(node, location);
+    }
+}
+
diff --git a/src/main/java/graphql/language/AstMultiZipper.java b/src/main/java/graphql/language/AstMultiZipper.java
@@ -0,0 +1,127 @@
+package graphql.language;
+
+import graphql.PublicApi;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static graphql.Assert.assertNotEmpty;
+import static graphql.Assert.assertTrue;
+import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.mapping;
+import static java.util.stream.Collectors.toList;
+
+/**
+ * A collection of {@link AstZipper} sharing all the same root node.
+ * It is used to track multiple changes at once, while {@link AstZipper} focus on one Node.
+ */
+@PublicApi
+public class AstMultiZipper {
+    private final Node commonRoot;
+    private final List<AstZipper> zippers;
+
+    public AstMultiZipper(Node commonRoot, List<AstZipper> zippers) {
+        this.commonRoot = commonRoot;
+        this.zippers = new ArrayList<>(zippers);
+    }
+
+    public Node toRootNode() {
+        if (zippers.size() == 0) {
+            return commonRoot;
+        }
+
+        List<AstZipper> curZippers = new ArrayList<>(zippers);
+        while (curZippers.size() > 1) {
+
+            List<AstZipper> deepestZippers = getDeepestZippers(curZippers);
+            Map<Node, List<AstZipper>> sameParent = zipperWithSameParent(deepestZippers);
+
+            List<AstZipper> newZippers = new ArrayList<>();
+            for (Map.Entry<Node, List<AstZipper>> entry : sameParent.entrySet()) {
+                AstZipper newZipper = moveUp(entry.getKey(), entry.getValue());
+                Optional<AstZipper> zipperToBeReplaced = curZippers.stream().filter(zipper -> zipper.getCurNode() == entry.getKey()).findFirst();
+                zipperToBeReplaced.ifPresent(curZippers::remove);
+                newZippers.add(newZipper);
+            }
+            curZippers.removeAll(deepestZippers);
+            curZippers.addAll(newZippers);
+        }
+        assertTrue(curZippers.size() == 1, "unexpected state: all zippers must share the same root node");
+        return curZippers.get(0).toRoot();
+    }
+
+    public Node getCommonRoot() {
+        return commonRoot;
+    }
+
+    public List<AstZipper> getZippers() {
+        return new ArrayList<>(zippers);
+    }
+
+    public AstMultiZipper withReplacedZippers(List<AstZipper> zippers) {
+        return new AstMultiZipper(commonRoot, zippers);
+    }
+
+    public AstMultiZipper withNewZipper(AstZipper newZipper) {
+        List<AstZipper> newZippers = getZippers();
+        newZippers.add(newZipper);
+        return new AstMultiZipper(commonRoot, newZippers);
+    }
+
+    public AstMultiZipper withReplacedZipper(AstZipper oldZipper, AstZipper newZipper) {
+        int index = zippers.indexOf(oldZipper);
+        assertTrue(index >= 0, "oldZipper not found");
+        List<AstZipper> newZippers = new ArrayList<>(zippers);
+        newZippers.set(index, newZipper);
+        return new AstMultiZipper(commonRoot, newZippers);
+    }
+
+
+    private List<AstZipper> getDeepestZippers(List<AstZipper> zippers) {
+        Map<Integer, List<AstZipper>> grouped = zippers
+                .stream()
+                .collect(groupingBy(astZipper -> astZipper.getBreadcrumbs().size(), LinkedHashMap::new, mapping(Function.identity(), toList())));
+
+        Integer maxLevel = Collections.max(grouped.keySet());
+        return grouped.get(maxLevel);
+    }
+
+    private AstZipper moveUp(Node parent, List<AstZipper> sameParent) {
+        assertNotEmpty(sameParent, "expected at least one zipper");
+        Map<String, List<Node>> childrenMap = parent.getNamedChildren().getChildren();
+
+        for (AstZipper zipper : sameParent) {
+            NodeLocation location = zipper.getBreadcrumbs().get(0).getLocation();
+            childrenMap.computeIfAbsent(location.getName(), (key) -> new ArrayList<>());
+            List<Node> childrenList = childrenMap.get(location.getName());
+            if (childrenList.size() > location.getIndex()) {
+                childrenList.set(location.getIndex(), zipper.getCurNode());
+            } else {
+                childrenList.add(zipper.getCurNode());
+            }
+        }
+        Node newNode = parent.withNewChildren(newNodeChildrenContainer(childrenMap).build());
+        List<AstBreadcrumb> newBreadcrumbs = sameParent.get(0).getBreadcrumbs().subList(1, sameParent.get(0).getBreadcrumbs().size());
+        return new AstZipper(newNode, newBreadcrumbs);
+    }
+
+    private Map<Node, List<AstZipper>> zipperWithSameParent(List<AstZipper> zippers) {
+        return zippers.stream().collect(groupingBy(AstZipper::getParent, LinkedHashMap::new,
+                mapping(Function.identity(), Collectors.toList())));
+    }
+
+    @Override
+    public String toString() {
+        return "AstMultiZipper{" +
+                "commonRoot=" + commonRoot.getClass() +
+                ", zippersCount=" + zippers.size() +
+                '}';
+    }
+}
-Original file line number
+Diff line change
@@ Expand Up @@
             }
             return list.stream().map(Node::deepCopy).map(node -> (V) node).collect(Collectors.toList());
         }
     }