Add a Language field to the Ssurgeon. This will allow the tool to make edges with the proper dependency scheme. Also, use the version of GrammaticalRelation.valueOf which creates an edge if it doesn't currently exist. This will allow for unknown dependency schemes to work for the most part (although perhaps some bug will crop up anyway)

Author: AngledLuffa

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

@@ -33,15 +33,6 @@ public class AddDep extends SsurgeonEdit {
   final String position;
   final double weight;
 
-  /**
-   * Creates an EnglishGrammaticalRelation AddDep edit.
-   * @param newNode String representation of new dependent IndexedFeatureNode map.
-   */
-  public static AddDep createEngAddDep(String govNodeName, String engRelation,  Map<String, String> attributes, String position) {
-    GrammaticalRelation relation = EnglishGrammaticalRelations.valueOf(engRelation);
-    return new AddDep(govNodeName, relation, attributes, position);
-  }
-
   public AddDep(String govNodeName, GrammaticalRelation relation, Map<String, String> attributes, String position) {
     this(govNodeName, relation, attributes, position, 0.0);
   }

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

@@ -39,11 +39,6 @@ public RelabelNamedEdge(String edgeName, GrammaticalRelation relation) {
     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();

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

@@ -24,6 +24,7 @@
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
+import edu.stanford.nlp.international.Language;
 import edu.stanford.nlp.ling.AnnotationLookup;
 import edu.stanford.nlp.ling.CoreAnnotation;
 import edu.stanford.nlp.semgraph.SemanticGraph;
@@ -359,7 +360,7 @@ private static SsurgeonArgs parseArgsBox(String args) {
   /**
    * Given a string entry, converts it into a SsurgeonEdit object.
    */
-  public static SsurgeonEdit parseEditLine(String editLine) {
+  public static SsurgeonEdit parseEditLine(String editLine, Language language) {
     try {
       // Extract the operation name first
       final String[] tuples1 = editLine.split("\\s+", 2);
@@ -380,20 +381,29 @@ public static SsurgeonEdit parseEditLine(String editLine) {
       final SsurgeonArgs argsBox = parseArgsBox(tuples1.length == 1 ? "" : tuples1[1]);
 
       if (command.equalsIgnoreCase(AddDep.LABEL)) {
-        return AddDep.createEngAddDep(argsBox.govNodeName, argsBox.reln, argsBox.annotations, argsBox.position);
+        if (argsBox.reln == null) {
+          throw new SsurgeonParseException("Relation not specified for AddDep");
+        }
+        GrammaticalRelation reln = GrammaticalRelation.valueOf(language, argsBox.reln);
+        return new AddDep(argsBox.govNodeName, reln, argsBox.annotations, argsBox.position);
       } else if (command.equalsIgnoreCase(AddNode.LABEL)) {
         return AddNode.createAddNode(argsBox.nodeString, argsBox.name);
       } else if (command.equalsIgnoreCase(AddEdge.LABEL)) {
-        return AddEdge.createEngAddEdge(argsBox.govNodeName, argsBox.dep, argsBox.reln, argsBox.weight);
+        if (argsBox.reln == null) {
+          throw new SsurgeonParseException("Relation not specified for AddEdge");
+        }
+        GrammaticalRelation reln = GrammaticalRelation.valueOf(language, argsBox.reln);
+        return new AddEdge(argsBox.govNodeName, argsBox.dep, reln, argsBox.weight);
       } else if (command.equalsIgnoreCase(DeleteGraphFromNode.LABEL)) {
         return new DeleteGraphFromNode(argsBox.node);
       } else if (command.equalsIgnoreCase(EditNode.LABEL)) {
         return new EditNode(argsBox.node, argsBox.annotations);
       } 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
-        return RelabelNamedEdge.createEngRelabel(argsBox.edge, argsBox.reln);
+        if (argsBox.reln == null) {
+          throw new SsurgeonParseException("Relation not specified for AddEdge");
+        }
+        GrammaticalRelation reln = GrammaticalRelation.valueOf(language, argsBox.reln);
+        return new RelabelNamedEdge(argsBox.edge, reln);
       } else if (command.equalsIgnoreCase(RemoveEdge.LABEL)) {
         GrammaticalRelation reln = null;
         if (argsBox.reln != null) {
@@ -592,13 +602,19 @@ public static SsurgeonPattern ssurgeonPatternFromXML(Element elt) {
     SemgrexPattern semgrexPattern = SemgrexPattern.compile(semgrexString);
     SsurgeonPattern retPattern = new SsurgeonPattern(uid, semgrexPattern);
     retPattern.setNotes(notes);
+
+    String language = getTagText(elt, SsurgeonPattern.LANGUAGE_TAG);
+    if (!language.equals("")) {
+      retPattern.setLanguage(language);
+    }
+
     NodeList editNodes = elt.getElementsByTagName(SsurgeonPattern.EDIT_LIST_ELEM_TAG);
     for (int i=0; i<editNodes.getLength(); i++) {
       Node node = editNodes.item(i);
       if (node.getNodeType() == Node.ELEMENT_NODE) {
         Element editElt = (Element) node;
         String editVal = getEltText(editElt);
-        retPattern.addEdit(Ssurgeon.parseEditLine(editVal));
+        retPattern.addEdit(Ssurgeon.parseEditLine(editVal, retPattern.getLanguage()));
       }
     }
 

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

@@ -3,9 +3,10 @@
 import java.io.*;
 import java.util.*;
 
+import edu.stanford.nlp.international.Language;
+import edu.stanford.nlp.ling.IndexedWord;
 import edu.stanford.nlp.semgraph.SemanticGraph;
 import edu.stanford.nlp.semgraph.SemanticGraphFactory;
-import edu.stanford.nlp.ling.IndexedWord;
 import edu.stanford.nlp.semgraph.semgrex.ssurgeon.pred.SsurgPred;
 import edu.stanford.nlp.semgraph.semgrex.*;
 import edu.stanford.nlp.util.Generics;
@@ -26,6 +27,7 @@
 public class SsurgeonPattern {
   protected String UID;
   protected String notes = "";
+  protected Language language = Language.English;
   protected List<SsurgeonEdit> editScript;
   protected SemgrexPattern semgrexPattern;
   protected SemanticGraph semgrexGraph = null; // Source graph semgrex pattern was derived from (used for pattern learning)
@@ -236,6 +238,7 @@ public SemgrexPattern getSemgrexPattern() {
    * ------ */
   public static final String ELT_LIST_TAG = "ssurgeon-pattern-list";
   public static final String UID_ELEM_TAG = "uid";
+  public static final String LANGUAGE_TAG = "language";
   public static final String RESOURCE_TAG = "resource";
   public static final String SSURGEON_ELEM_TAG = "ssurgeon-pattern";
   public static final String SEMGREX_ELEM_TAG = "semgrex";
@@ -274,6 +277,15 @@ public void setUID(String uid) {
     UID = uid;
   }
 
+  public Language getLanguage() {
+    return language;
+  }
+
+  public void setLanguage(String language) {
+    // might be null if the language doesn't exist
+    this.language = Language.valueOfSafe(language);
+  }
+
   /**
    * Simply reads the given Ssurgeon pattern from file (args[0]), parses it, and prints it out.
    * Use this for debugging the class and patterns. 

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

@@ -10,6 +10,7 @@
 
 import org.junit.Test;
 
+import edu.stanford.nlp.international.Language;
 import edu.stanford.nlp.ling.AnnotationLookup;
 import edu.stanford.nlp.ling.CoreAnnotations;
 import edu.stanford.nlp.ling.IndexedWord;
@@ -646,7 +647,6 @@ public void readXMLAddDep() {
     assertEquals("blue", blueVertex.value());
   }
 
-
   /**
    * Check that adding a word to the start of a sentence works as expected
    */
@@ -747,6 +747,90 @@ public void readXMLAddDepRelativePosition() {
     assertEquals("blue", blueVertex.value());
   }
 
+  /**
+   * Set the language when adding a dep.  Should create a UniversalEnglish dependency
+   */
+  @Test
+  public void readXMLAddUniversalDep() {
+    Ssurgeon inst = Ssurgeon.inst();
+
+    String add = String.join(newline,
+                             "<ssurgeon-pattern-list>",
+                             "  <ssurgeon-pattern>",
+                             "    <uid>38</uid>",
+                             "    <notes>Add a word before antennae using the position using a UniversalEnglish dependency</notes>",
+                             "    <language>UniversalEnglish</language>",
+                             // have to bomb-proof the pattern
+                             "    <semgrex>" + XMLUtils.escapeXML("{word:antennae}=antennae !> {word:blue}") + "</semgrex>",
+                             "    <edit-list>addDep -gov antennae -reln amod -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]", Language.UniversalEnglish);
+    IndexedWord blueVertex = sg.getNodeByIndexSafe(4);
+    assertNull(blueVertex);
+    SemanticGraph newSG = addSsurgeon.iterate(sg);
+    SemanticGraph expected = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> [antennae-4 amod> blue-3]]", Language.UniversalEnglish);
+    for (SemanticGraphEdge edge : expected.edgeIterable()) {
+      assertEquals(Language.UniversalEnglish, edge.getRelation().getLanguage());
+    }
+    for (SemanticGraphEdge edge : newSG.edgeIterable()) {
+      assertEquals(Language.UniversalEnglish, edge.getRelation().getLanguage());
+    }
+    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());
+
+
+    // If we repeat the same test with English (SD, not UD) it should fail horribly
+    // this is because SemanticGraph.valueOf will use UniversalEnglish dependencies by default
+    add = String.join(newline,
+                      "<ssurgeon-pattern-list>",
+                      "  <ssurgeon-pattern>",
+                      "    <uid>38</uid>",
+                      "    <notes>Add a word before antennae using the position using an English dependency</notes>",
+                      "    <language>English</language>",
+                      // have to bomb-proof the pattern
+                      "    <semgrex>" + XMLUtils.escapeXML("{word:antennae}=antennae !> {word:blue}") + "</semgrex>",
+                      "    <edit-list>addDep -gov antennae -reln amod -word blue -position -antennae</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]", Language.UniversalEnglish);
+    blueVertex = sg.getNodeByIndexSafe(4);
+    assertNull(blueVertex);
+    newSG = addSsurgeon.iterate(sg);
+    expected = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> [antennae-4 amod> blue-3]]", Language.UniversalEnglish);
+    for (SemanticGraphEdge edge : expected.edgeIterable()) {
+      assertEquals(Language.UniversalEnglish, edge.getRelation().getLanguage());
+    }
+    // they look the same, but they're really not
+    assertEquals(expected.toString(), newSG.toString());
+    assertNotEquals(expected, newSG);
+
+    // In this third version, now valueOf is creating an English graph,
+    // not a UniversalEnglish graph, so it should work again
+    sg = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> antennae-3]", Language.English);
+    blueVertex = sg.getNodeByIndexSafe(4);
+    assertNull(blueVertex);
+    newSG = addSsurgeon.iterate(sg);
+    expected = SemanticGraph.valueOf("[has-2 nsubj> Jennifer-1 obj> [antennae-4 amod> blue-3]]", Language.English);
+    for (SemanticGraphEdge edge : expected.edgeIterable()) {
+      assertEquals(Language.English, edge.getRelation().getLanguage());
+    }
+    assertEquals(expected, newSG);
+  }
+
   /**
    * There should be an exception for an annotation key that does not exist
    */
@@ -1014,7 +1098,7 @@ public void simpleTest() {
     attributes.put("lemma", "is");
     attributes.put("current", "is");
     attributes.put("pos", "VBN");
-    SsurgeonEdit addCopula = new AddDep("a2", EnglishGrammaticalRelations.COPULA, attributes, null);
+    SsurgeonEdit addCopula = new AddDep("a2", EnglishGrammaticalRelations.COPULA, attributes, null, 0.0);
     pattern.addEdit(addCopula);
 
     // Destroy subgraph