Add a RelabelNamedEdge.

This operation puts the named edge into the SemgrexMatcher after relabeling something.
If the edge already exists, a duplicate is not created.

Add a test of this operation

Author: AngledLuffa

src/edu/stanford/nlp/semgraph/semgrex/SemgrexMatcher.java

@@ -231,6 +231,10 @@ public Set<String> getEdgeNames() {
     return namesToEdges.keySet();
   }
 
+  public SemanticGraphEdge putNamedEdge(String name, SemanticGraphEdge edge) {
+    return namesToEdges.put(name, edge);
+  }
+
   @Override
   public abstract String toString();
 

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

@@ -0,0 +1,98 @@
+package edu.stanford.nlp.semgraph.semgrex.ssurgeon;
+
+import java.io.StringWriter;
+
+import edu.stanford.nlp.semgraph.semgrex.SemgrexMatcher;
+import edu.stanford.nlp.semgraph.SemanticGraph;
+import edu.stanford.nlp.semgraph.SemanticGraphEdge;
+
+import edu.stanford.nlp.trees.EnglishGrammaticalRelations;
+import edu.stanford.nlp.trees.GrammaticalRelation;
+
+/**
+ * Given a named edge, change that edge from the SemanticGraph,
+ * then put it back with the updated relation.
+ *<br>
+ * If an edge already exists with the new named relation,
+ * <i>that</i> edge is deleted permanently.  That way, named
+ * references to the first edge should still work.
+ *
+ * @author John Bauer
+ *
+ */
+public class RelabelNamedEdge extends SsurgeonEdit {  
+  public static final String LABEL = "relabelNamedEdge";
+
+  protected final String edgeName; // Name of the matched edge in the SemgrexPattern
+
+  protected final GrammaticalRelation relation; // Type of relation to add between these edges
+
+  public RelabelNamedEdge(String edgeName, GrammaticalRelation relation) {
+    if (edgeName == null) {
+      throw new SsurgeonParseException("RelabelNamedEdge created with no edge name!");
+    }
+    if (relation == null) {
+      throw new SsurgeonParseException("RelabelNamedEdge created with no relation!");
+    }
+
+    this.edgeName = edgeName;
+    this.relation = relation;
+  }
+
+  public static RelabelNamedEdge createEngRelabel(String edgeName, String relation) {
+    GrammaticalRelation reln = EnglishGrammaticalRelations.valueOf(relation);
+    return new RelabelNamedEdge(edgeName, reln);
+  }
+
+  @Override
+  public String toEditString() {
+    StringWriter buf = new StringWriter();
+    buf.write(LABEL); buf.write("\t");
+
+    buf.write(Ssurgeon.EDGE_NAME_ARG);buf.write(" ");    
+    buf.write(edgeName); buf.write("\t");
+
+    buf.write(Ssurgeon.RELN_ARG);buf.write(" ");
+    buf.write(relation.toString()); buf.write("\t");
+
+    return buf.toString();
+  }
+
+  /**
+   * "Rename" the named edge by removing it and then recreating it
+   */
+  @Override
+  public boolean evaluate(SemanticGraph sg, SemgrexMatcher sm) {
+    SemanticGraphEdge edge = sm.getEdge(edgeName);
+
+    if (edge != null) {
+      boolean success = sg.removeEdge(edge);
+      if (!success) {
+        // maybe it was already removed somehow by a previous operation
+        return false;
+      }
+      final SemanticGraphEdge newEdge;
+      found: {
+        for (SemanticGraphEdge existingEdge : sg.getAllEdges(edge.getSource(), edge.getTarget())) {
+          if (existingEdge.getRelation().equals(this.relation)) {
+            newEdge = existingEdge;
+            break found;
+          }
+        }
+        newEdge = new SemanticGraphEdge(edge.getSource(),
+                                        edge.getTarget(),
+                                        this.relation,
+                                        edge.getWeight(),
+                                        edge.isExtra());
+        sg.addEdge(newEdge);
+      }
+      // whether we recreated a new edge with the new relation,
+      // or found an existing edge with the relation we wanted,
+      // update the named edge in the SemgrexMatcher so future
+      // iterations have the name connected to the edge
+      sm.putNamedEdge(edgeName, newEdge);
+      return true;
+    }
+    return false;
+  }
+}

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

@@ -372,6 +372,11 @@ public static SsurgeonEdit parseEditLine(String editLine) {
       retEdit = AddEdge.createEngAddEdge(argsBox.govNodeName, argsBox.dep, argsBox.reln, argsBox.weight);
     } else if (command.equalsIgnoreCase(DeleteGraphFromNode.LABEL)) {
       retEdit = new DeleteGraphFromNode(argsBox.node);
+    } else if (command.equalsIgnoreCase(RelabelNamedEdge.LABEL)) {
+      // TODO: pass around a Language (perhaps via ssurgeon argument)
+      // rather than hardcoding English, which is probably not even true
+      // compared to UniversalEnglish these days
+      retEdit = RelabelNamedEdge.createEngRelabel(argsBox.edge, argsBox.reln);
     } else if (command.equalsIgnoreCase(RemoveEdge.LABEL)) {
       GrammaticalRelation reln = null;
       if (argsBox.reln != null) {

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

@@ -178,6 +178,91 @@ public void readXMLRemoveNamedEdgeIterate() {
     assertEquals(newSg, expected);
   }
 
+  /**
+   * Test a few various relabel edge operations
+   */
+  @Test
+  public void readXMLRelabelEdgeIterate() {
+    String doc = String.join(newline,
+                             "<ssurgeon-pattern-list>",
+                             "  <ssurgeon-pattern>",
+                             "    <uid>38</uid>",
+                             "    <notes>This is a simple test of RelabelNamedEdge</notes>",
+                             "    <semgrex>" + XMLUtils.escapeXML("{}=a1 >obj=foo {}=a2") + "</semgrex>",
+                             "    <edit-list>relabelNamedEdge -edge foo -reln dep</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);
+
+    // check a simple case of relabeling
+    SemanticGraph sg = SemanticGraph.valueOf("[A-0 obj> B-1]");
+    SemanticGraph expected = SemanticGraph.valueOf("[A-0 dep> B-1]");
+    SemanticGraph newSg = pattern.iterate(sg);
+    assertEquals(newSg, expected);
+
+    // check iteration over multiple edges
+    sg = SemanticGraph.valueOf("[A-0 obj> [B-1 obj> C-2]]");
+    expected = SemanticGraph.valueOf("[A-0 dep> [B-1 dep> C-2]]");
+    newSg = pattern.iterate(sg);
+    assertEquals(newSg, expected);
+
+    // check that relabeling doesn't change a non-matching edge
+    // (how would it?)
+    sg = SemanticGraph.valueOf("[A-0 iobj> B-1]");
+    expected = SemanticGraph.valueOf("[A-0 iobj> B-1]");
+    newSg = pattern.iterate(sg);
+    assertEquals(newSg, expected);
+
+    // check that you don't get double edges if an update
+    // makes two edges into the same edge
+    sg = SemanticGraph.valueOf("[A-0 obj> B-1 dep> B-1]");
+    expected = SemanticGraph.valueOf("[A-0 dep> B-1]");
+    newSg = pattern.iterate(sg);
+    assertEquals(newSg, expected);
+  }
+
+
+  /**
+   * Test that the RelabelNamedEdge operation updates the name of the edge in the SemgrexMatcher
+   */
+  @Test
+  public void readXMLRelabelEdgeUpdateNamedEdge() {
+    String doc = String.join(newline,
+                             "<ssurgeon-pattern-list>",
+                             "  <ssurgeon-pattern>",
+                             "    <uid>38</uid>",
+                             "    <notes>This is a simple test of RelabelNamedEdge</notes>",
+                             "    <semgrex>" + XMLUtils.escapeXML("{}=a1 >obj=foo {}=a2") + "</semgrex>",
+                             "    <edit-list>relabelNamedEdge -edge foo -reln dep</edit-list>",
+                             "    <edit-list>relabelNamedEdge -edge foo -reln gov</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);
+
+    // check the result of a double relabel - should wind up as gov
+    SemanticGraph sg = SemanticGraph.valueOf("[A-0 obj> B-1]");
+    SemanticGraph expected = SemanticGraph.valueOf("[A-0 gov> B-1]");
+    SemanticGraph newSg = pattern.iterate(sg);
+    assertEquals(newSg, expected);
+
+    // in this case, the dep should acquire the name of the obj
+    // in the SemgrexMatcher.  the subsequent operation will pick up
+    // that edge (with the original edge being deleted) and the
+    // result will be one edge with the name "gov"
+    // if the matcher did not update the named edge as expected,
+    // the second operation would not fire
+    sg = SemanticGraph.valueOf("[A-0 obj> B-1 dep> B-1]");
+    expected = SemanticGraph.valueOf("[A-0 gov> B-1]");
+    newSg = pattern.iterate(sg);
+    assertEquals(newSg, expected);
+  }
+
   /**
    * Check that cutting a graph with two nodes into two pieces, then
    * pruning any disjoint pieces, results in a graph with just the root