Allow reln == null to represent not having any requirements on the label of the edge to be deleted. Essentially, it deletes all the edges between the two nodes. Still need to test the gov / dep wildcard variants of those - they seem less useful when calling iterate(), though

Author: AngledLuffa

src/edu/stanford/nlp/semgraph/semgrex/ssurgeon/RemoveEdge.java

@@ -1,6 +1,8 @@
 package edu.stanford.nlp.semgraph.semgrex.ssurgeon;
 
 import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
 
 import edu.stanford.nlp.ling.IndexedWord;
 import edu.stanford.nlp.semgraph.semgrex.SemgrexMatcher;
@@ -31,8 +33,10 @@ public RemoveEdge(GrammaticalRelation relation, String govName, String depName)
   public String toEditString() {
     StringWriter buf = new StringWriter();
     buf.write(LABEL); buf.write("\t");
-    buf.write(Ssurgeon.RELN_ARG);buf.write(" ");
-    buf.write(relation.toString()); buf.write("\t");
+    if (relation != null) {
+      buf.write(Ssurgeon.RELN_ARG);buf.write(" ");
+      buf.write(relation.toString()); buf.write("\t");
+    }
     buf.write(Ssurgeon.GOV_NODENAME_ARG);buf.write(" ");
     buf.write(govName); buf.write("\t");
     buf.write(Ssurgeon.DEP_NODENAME_ARG);buf.write(" ");
@@ -61,30 +65,57 @@ public boolean evaluate(SemanticGraph sg, SemgrexMatcher sm) {
     IndexedWord depNode = getNamedNode(depName, sm);
     boolean success = false;
 
+    List<SemanticGraphEdge> edgesToDelete = null;
     if (govNode != null && depNode != null) {
-      SemanticGraphEdge edge = sg.getEdge(govNode, depNode, relation);
-      while (edge != null) {
-        if (!sg.removeEdge(edge)) {
-          throw new IllegalStateException("Found an edge and tried to delete it, but somehow this didn't work!  " + edge);
+      if (relation == null) {
+        edgesToDelete = new ArrayList<>(sg.getAllEdges(govNode, depNode));
+      } else {
+        SemanticGraphEdge edge = sg.getEdge(govNode, depNode, relation);
+        while (edge != null) {
+          if (!sg.removeEdge(edge)) {
+            throw new IllegalStateException("Found an edge and tried to delete it, but somehow this didn't work!  " + edge);
+          }
+          edge = sg.getEdge(govNode, depNode, relation);
+          success = true;
         }
-        edge = sg.getEdge(govNode, depNode, relation);
-        success = true;
       }
     } else if (depNode != null && govWild) {
       // dep known, wildcard gov
-      for (SemanticGraphEdge edge : sg.incomingEdgeIterable(depNode)) {
-        if (edge.getRelation().equals(relation) && sg.containsEdge(edge) ) {
-          success = success || sg.removeEdge(edge);
+      if (relation == null) {
+        edgesToDelete = new ArrayList<>();
+        sg.incomingEdgeIterable(depNode).forEach(edgesToDelete::add);
+      } else {
+        edgesToDelete = new ArrayList<>();
+        for (SemanticGraphEdge edge : sg.incomingEdgeIterable(depNode)) {
+          if (edge.getRelation().equals(relation)) {
+            edgesToDelete.add(edge);
+          }
         }
       }
-    }  else if (govNode != null && depWild) {
+    } else if (govNode != null && depWild) {
       // gov known, wildcard dep
-      for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(govNode)) {
-        if (edge.getRelation().equals(relation) && sg.containsEdge(edge) ) {
-          success = success || sg.removeEdge(edge);
+      if (relation == null) {
+        edgesToDelete = new ArrayList<>();
+        sg.outgoingEdgeIterable(govNode).forEach(edgesToDelete::add);
+      } else {
+        edgesToDelete = new ArrayList<>();
+        for (SemanticGraphEdge edge : sg.outgoingEdgeIterable(govNode)) {
+          if (edge.getRelation().equals(relation)) {
+            edgesToDelete.add(edge);
+          }
+        }
+      }
+    }
+
+    if (edgesToDelete != null) {
+      for (SemanticGraphEdge edge : edgesToDelete) {
+        if (!sg.removeEdge(edge)) {
+          throw new IllegalStateException("Found an edge and tried to delete it, but somehow this didn't work!  " + edge);
         }
+        success = true;
       }
     }
+
     // will be true if at least one edge was removed
     return success;
   }

src/edu/stanford/nlp/semgraph/semgrex/ssurgeon/Ssurgeon.java

@@ -360,7 +360,11 @@ public static SsurgeonEdit parseEditLine(String editLine) {
     } else if (command.equalsIgnoreCase(DeleteGraphFromNode.LABEL)) {
       retEdit = new DeleteGraphFromNode(argsBox.node);
     } else if (command.equalsIgnoreCase(RemoveEdge.LABEL)) {
-      retEdit = new RemoveEdge(GrammaticalRelation.valueOf(argsBox.reln), argsBox.govNodeName, argsBox.dep);
+      GrammaticalRelation reln = null;
+      if (argsBox.reln != null) {
+        reln = GrammaticalRelation.valueOf(argsBox.reln);
+      }
+      retEdit = new RemoveEdge(reln, argsBox.govNodeName, argsBox.dep);
     } else if (command.equalsIgnoreCase(RemoveNamedEdge.LABEL)) {
       retEdit = new RemoveNamedEdge(argsBox.edge);
     } else if (command.equalsIgnoreCase(SetRoots.LABEL)) {

test/src/edu/stanford/nlp/semgraph/semgrex/ssurgeon/SsurgeonTest.java

@@ -118,6 +118,32 @@ public void readXMLRemoveEdgeIterate() {
   }
 
 
+  /**
+   * Test that removing an edge given its endpoints and the dependency type will remove all matching edges
+   */
+  @Test
+  public void readXMLRemoveEdgeNoRelationIterate() {
+    String doc = String.join(newline,
+                             "<ssurgeon-pattern-list>",
+                             "  <ssurgeon-pattern>",
+                             "    <uid>38</uid>",
+                             "    <notes>Test removing an edge with no relation set</notes>",
+                             "    <semgrex>" + XMLUtils.escapeXML("{word:B}=a1 > {word:E}=a2") + "</semgrex>",
+                             "    <edit-list>removeEdge -gov a1 -dep a2</edit-list>",
+                             "  </ssurgeon-pattern>",
+                             "</ssurgeon-pattern-list>");
+    Ssurgeon inst = Ssurgeon.inst();
+    List<SsurgeonPattern> patterns = inst.readFromString(doc);
+    assertEquals(patterns.size(), 1);
+    SsurgeonPattern pattern = patterns.get(0);
+
+    SemanticGraph sg = SemanticGraph.valueOf("[A-0 obj> [B-1 nsubj> E-4] obj> C-2 nsubj> [D-3 obj> E-4]]");
+    SemanticGraph newSg = pattern.iterate(sg);
+    SemanticGraph expected = SemanticGraph.valueOf("[A-0 obj> B-1 obj> C-2 nsubj> [D-3 obj> E-4]]");
+    assertEquals(newSg, expected);
+  }
+
+
   /**
    * Test that removing a named edge will remove all matching edges
    */