Add the ability to control position with + or - relative to a node

Author: AngledLuffa

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

@@ -52,7 +52,7 @@ public AddDep(String govNodeName, GrammaticalRelation relation, Map<String, Stri
     }
 
     if (position != null) {
-      if (!position.equals("-") && !position.equals("+")) {
+      if (!position.startsWith("-") && !position.startsWith("+")) {
         throw new SsurgeonParseException("Unknown position " + position + " in AddDep operation");
       }
     }
@@ -151,16 +151,38 @@ public boolean evaluate(SemanticGraph sg, SemgrexMatcher sm) {
     CoreLabel newWord = fromCheapStrings(attributes);
     IndexedWord newNode = new IndexedWord(newWord);
     final int tempIndex;
+    final int newIndex;
     if (position != null && !position.equals("+")) {
       // +2 to leave room: we will increase all other nodes with the
       // proper index, so we need +1 of room, then another +1 for
       // a temp place to put this node
       // TODO: when we implement updating the SemgrexMatcher,
       // this won't be necessary
       tempIndex = SemanticGraphUtils.maxIndex(sg) + 2;
+
+      if (position.equals("-")) {
+        newIndex = SemanticGraphUtils.minIndex(sg);
+      } else if (position.startsWith("-") || position.startsWith("+")) {
+        String targetName = position.substring(1);
+        IndexedWord target = sm.getNode(targetName);
+        if (target == null) {
+          return false;
+        }
+        if (position.startsWith("-")) {
+          // it will be exactly to the left rather than pushing over
+          // something a word earlier if we do .index(), not .index() - 1
+          newIndex = target.index();
+        } else {
+          newIndex = target.index() + 1;
+        }
+      } else {
+        throw new UnsupportedOperationException("Unknown position in AddDep: |" + position + "|");
+      }
     } else {
       tempIndex = SemanticGraphUtils.maxIndex(sg) + 1;
+      newIndex = -1;
     }
+
     newNode.setDocID(govNode.docID());
     newNode.setIndex(tempIndex);
     newNode.setSentIndex(govNode.sentIndex());
@@ -169,12 +191,6 @@ public boolean evaluate(SemanticGraph sg, SemgrexMatcher sm) {
     sg.addEdge(govNode, newNode, relation, weight, false);
 
     if (position != null && !position.equals("+")) {
-      final int newIndex;
-      if (position.equals("-")) {
-        newIndex = SemanticGraphUtils.minIndex(sg);
-      } else {
-        throw new UnsupportedOperationException("Unknown position in AddDep: |" + position + "|");
-      }
       // the payoff for tempIndex == maxIndex + 2:
       // everything will be moved one higher, unless it's the new node
       moveNodes(sg, x -> (x >= newIndex && x != tempIndex), x -> x+1);

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

@@ -683,6 +683,70 @@ public void readXMLAddDepStartPosition() {
     assertEquals("blue", blueVertex.value());
   }
 
+  /**
+   * Check that adding a word before or after a named node works as expected
+   */
+  @Test
+  public void readXMLAddDepRelativePosition() {
+    Ssurgeon inst = Ssurgeon.inst();
+
+    // use "dep" as the dependency so as to be language-agnostic in this test
+    String add = String.join(newline,
+                             "<ssurgeon-pattern-list>",
+                             "  <ssurgeon-pattern>",
+                             "    <uid>38</uid>",
+                             "    <notes>Add a word before antennae using the position</notes>",
+                             // have to bomb-proof the pattern
+                             "    <semgrex>" + XMLUtils.escapeXML("{word:antennae}=antennae !> {word:blue}") + "</semgrex>",
+                             "    <edit-list>addDep -gov antennae -reln dep -word blue -position -antennae</edit-list>",
+                             "  </ssurgeon-pattern>",
+                             "</ssurgeon-pattern-list>");
+    List<SsurgeonPattern> patterns = inst.readFromString(add);
+    assertEquals(patterns.size(), 1);
+    SsurgeonPattern addSsurgeon = patterns.get(0);
+
+    SemanticGraph sg = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> antennae-3]");
+    IndexedWord blueVertex = sg.getNodeByIndexSafe(4);
+    assertNull(blueVertex);
+    SemanticGraph newSG = addSsurgeon.iterate(sg);
+    SemanticGraph expected = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> [antennae-4 dep> blue-3]]");
+    assertEquals(expected, newSG);
+    // the Ssurgeon we just created should not put a tag on the word
+    // but it SHOULD put blue immediately before antennae
+    blueVertex = newSG.getNodeByIndexSafe(3);
+    assertNotNull(blueVertex);
+    assertNull(blueVertex.tag());
+    assertEquals("blue", blueVertex.value());
+
+    // use "dep" as the dependency so as to be language-agnostic in this test
+    add = String.join(newline,
+                      "<ssurgeon-pattern-list>",
+                      "  <ssurgeon-pattern>",
+                      "    <uid>38</uid>",
+                      "    <notes>Add a word after the word before antennae (just to test the position)</notes>",
+                      // have to bomb-proof the pattern
+                      "    <semgrex>" + XMLUtils.escapeXML("{word:antennae}=antennae - {}=prev !> {word:blue}") + "</semgrex>",
+                      "    <edit-list>addDep -gov antennae -reln dep -word blue -position +prev</edit-list>",
+                      "  </ssurgeon-pattern>",
+                      "</ssurgeon-pattern-list>");
+    patterns = inst.readFromString(add);
+    assertEquals(patterns.size(), 1);
+    addSsurgeon = patterns.get(0);
+
+    sg = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> antennae-3]");
+    blueVertex = sg.getNodeByIndexSafe(4);
+    assertNull(blueVertex);
+    newSG = addSsurgeon.iterate(sg);
+    expected = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> [antennae-4 dep> blue-3]]");
+    assertEquals(expected, newSG);
+    // the Ssurgeon we just created should not put a tag on the word
+    // but it SHOULD put blue immediately before antennae
+    blueVertex = newSG.getNodeByIndexSafe(3);
+    assertNotNull(blueVertex);
+    assertNull(blueVertex.tag());
+    assertEquals("blue", blueVertex.value());
+  }
+
   /**
    * There should be an exception for an annotation key that does not exist
    */