Add an 'iterate' method to Ssurgeon which repeats an operation until it no longer does anything new

Can now use valueOf() and assertEquals to make sure the graph is as expected in the unittest - much simpler than taking apart the graph

Leave a comment on something we need to figure out regarding the iteration

Author: AngledLuffa

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

@@ -154,6 +154,47 @@ public Collection<SemanticGraph> execute(SemanticGraph sg) {
     return generated;
   }
 
+  /**
+   * This alternative processing style repeatedly matches the graph
+   * and executes patterns until all of the matches are exhausted and
+   * there are no more edits performed.
+   *<br>
+   * Note that this means "bomb" patterns will go infinite.  In
+   * particular, adding a node without a check that the node already
+   * exists is a problem.  Most other patterns are self-limiting, in
+   * that the change will not be repeated more than once.
+   *<br>
+   * The graph is always copied, although operations which change the
+   * text or otherwise edit a word node will affect the original graph.
+   *<br>
+   * It's not clear what to do with a multiple edit pattern.
+   * Currently we just operate until one edit occurs, then break.
+   * This makes it harder to do consecutive operations using the
+   * same match, but there are a couple issues to easily doing that:
+   * <ul>
+   * <li> what do we do when an edit doesn't fire?  keep going or break?
+   * <li> what node names do the later edits get?  rearranging nodes
+   *   may change the indices, affecting the match
+   * </ul>
+   */
+  public SemanticGraph iterate(SemanticGraph sg) {
+    SemanticGraph copied = new SemanticGraph(sg);
+
+    SemgrexMatcher matcher = semgrexPattern.matcher(copied);
+    while (matcher.find()) {
+      // We reset the named node map with each edit set, since these edits
+      // should exist in a separate graph for each unique Semgrex match.
+      nodeMap = Generics.newHashMap();
+      for (SsurgeonEdit edit : editScript) {
+        if (edit.evaluate(copied, matcher)) {
+          matcher = semgrexPattern.matcher(copied);
+          break;
+        }
+      }
+    }
+    return copied;
+  }
+
   /**
    * Executes the Ssurgeon edit, but with the given Semgrex Pattern, instead of the one attached to this
    * pattern.

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

@@ -10,8 +10,10 @@
 import edu.stanford.nlp.ling.CoreAnnotations;
 import edu.stanford.nlp.ling.IndexedWord;
 import edu.stanford.nlp.semgraph.SemanticGraph;
+import edu.stanford.nlp.semgraph.SemanticGraphEdge;
 import edu.stanford.nlp.semgraph.semgrex.SemgrexPattern;
 import edu.stanford.nlp.trees.EnglishGrammaticalRelations;
+import edu.stanford.nlp.util.XMLUtils;
 
 public class SsurgeonTest {
 
@@ -31,15 +33,16 @@ public void readXMLEmptyPattern() {
     assertEquals(pattern.size(), 1);
   }
 
+  static final String newline = System.getProperty("line.separator");
+
   @Test
-  public void readXMLEdit() {
-    String newline = System.getProperty("line.separator");
+  public void readXMLAddEdgeExecute() {
     String doc = String.join(newline,
                              "<ssurgeon-pattern-list>",
                              "  <ssurgeon-pattern>",
                              "    <uid>38</uid>",
                              "    <notes>This is a simple test of addEdge</notes>",
-                             "    <semgrex>{}=a1 &gt; {}=a2</semgrex>",
+                             "    <semgrex>" + XMLUtils.escapeXML("{}=a1 > {}=a2") + "</semgrex>",
                              "    <edit-list>addEdge -gov a1 -dep a2 -reln dep -weight 0.5</edit-list>",
                              "  </ssurgeon-pattern>",
                              "</ssurgeon-pattern-list>");
@@ -50,11 +53,37 @@ public void readXMLEdit() {
 
     SemanticGraph sg = SemanticGraph.valueOf("[A obj> B obj> C]");
     Collection<SemanticGraph> newSgs = pattern.execute(sg);
-    // TODO: perhaps it would be better to have an execution scheme
-    // where one graph has all possible modifications applied
     assertEquals(newSgs.size(), 2);
   }
 
+
+  /**
+   * Test that AddEdge, when iterated, adds exactly one more edge
+   * between each parent/child pair if they matched the target relation
+   */
+  @Test
+  public void readXMLAddEdgeIterate() {
+    String doc = String.join(newline,
+                             "<ssurgeon-pattern-list>",
+                             "  <ssurgeon-pattern>",
+                             "    <uid>38</uid>",
+                             "    <notes>This is a simple test of addEdge</notes>",
+                             "    <semgrex>" + XMLUtils.escapeXML("{}=a1 >obj {}=a2") + "</semgrex>",
+                             "    <edit-list>addEdge -gov a1 -dep a2 -reln dep -weight 0.5</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 obj> B obj> C nsubj> [D obj> E]]");
+    SemanticGraph newSg = pattern.iterate(sg);
+    SemanticGraph expected = SemanticGraph.valueOf("[A-0 obj> B-1 dep> B-1 obj> C-2 dep> C-2 nsubj> [D-3 obj> E-4 dep> E-4]]");
+
+    assertEquals(newSg, expected);
+  }
+
   /**
    * Simple test of an Ssurgeon edit script.  This instances a simple semantic graph,
    * a semgrex pattern, and then the resulting actions over the named nodes in the