Add the ability to semgrex to uniq matches based on a regex varstring, including a couple tests of the ability. Also checks for name conflicts with nodes so that there are no weird ambiguous cases

Author: AngledLuffa

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

@@ -21,6 +21,9 @@ class SemgrexParser implements SemgrexParserConstants {
   // keep track of which variables we've already seen
   // lets us make sure we don't name new nodes under a negation
   private Set<String> knownVariables = Generics.newHashSet();
+  // keep track of which regex variable groups we've already seen
+  // useful for allowing uniq to operate on
+  private Set<String> knownVarGroups = Generics.newHashSet();
 
   private static final Redwood.RedwoodChannels log = Redwood.channels(SemgrexParser.class);
   private boolean deprecatedAmp = false;
@@ -122,8 +125,11 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
 uniqKeys.add(nextIdentifier.image);
       }
 for (String key : uniqKeys) {
-          if (!knownVariables.contains(key)) {
-            {if (true) throw new SemgrexParseException("Semgrex pattern asked for uniq of node " + key + " which does not exist in the pattern");}
+          if (!knownVariables.contains(key) && !knownVarGroups.contains(key)) {
+            {if (true) throw new SemgrexParseException("Semgrex pattern asked for uniq of node " + key + " which does not exist in the pattern (as a node or regex)");}
+          }
+          if (knownVariables.contains(key) && knownVarGroups.contains(key)) {
+            {if (true) throw new SemgrexParseException("Semgrex pattern asked for uniq of node " + key + " which is very confusing, as it is both a node and a regex.  Please rename one of them");}
           }
         }
         // TODO: can error check that the keys are unique between node and edge names
@@ -633,6 +639,7 @@ final public SemgrexPattern Root() throws ParseException {// Root pattern for th
           groupVar = identifier();
 // TODO: this should have been NUMBER, but that doesn't seem to exist
                 varGroups.add(new Pair<Integer,String>(Integer.parseInt(groupNum.image),groupVar.image));
+                knownVarGroups.add(groupVar.image);
         }
 if (attr != null && value != null) {
                  negated = attrType.image.equals("!:");

src/edu/stanford/nlp/semgraph/semgrex/SemgrexParser.jj

@@ -27,6 +27,9 @@ class SemgrexParser {
   // keep track of which variables we've already seen
   // lets us make sure we don't name new nodes under a negation
   private Set<String> knownVariables = Generics.newHashSet();
+  // keep track of which regex variable groups we've already seen
+  // useful for allowing uniq to operate on
+  private Set<String> knownVarGroups = Generics.newHashSet();
 
   private static final Redwood.RedwoodChannels log = Redwood.channels(SemgrexParser.class);
   private boolean deprecatedAmp = false;
@@ -116,8 +119,11 @@ SemgrexPattern Root() : {
       "::" <UNIQ> { uniqKeys = new ArrayList<>(); }  (nextIdentifier = identifier() { uniqKeys.add(nextIdentifier.image); })*
       {
         for (String key : uniqKeys) {
-          if (!knownVariables.contains(key)) {
-            throw new SemgrexParseException("Semgrex pattern asked for uniq of node " + key + " which does not exist in the pattern");
+          if (!knownVariables.contains(key) && !knownVarGroups.contains(key)) {
+            throw new SemgrexParseException("Semgrex pattern asked for uniq of node " + key + " which does not exist in the pattern (as a node or regex)");
+          }
+          if (knownVariables.contains(key) && knownVarGroups.contains(key)) {
+            throw new SemgrexParseException("Semgrex pattern asked for uniq of node " + key + " which is very confusing, as it is both a node and a regex.  Please rename one of them");
           }
         }
         // TODO: can error check that the keys are unique between node and edge names
@@ -316,6 +322,7 @@ void AddAttribute(NodeAttributes attributes) : {
              ( ( ( "#" groupNum = identifier() "%" groupVar = identifier() ) {
                 // TODO: this should have been NUMBER, but that doesn't seem to exist
                 varGroups.add(new Pair<Integer,String>(Integer.parseInt(groupNum.image),groupVar.image));
+                knownVarGroups.add(groupVar.image);
               } )* )
              {
                if (attr != null && value != null) {

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

@@ -32,12 +32,16 @@ public UniqPattern(SemgrexPattern child, List<String> keys) {
   }
 
   private String getKey(SemgrexMatch match, String key) {
-    // TODO: could also do edge names or variable groups (once those exist)
+    // TODO: could also do edge names
     IndexedWord node = match.getNode(key);
-    if (node == null) {
-      return null;
+    if (node != null) {
+      return node.value();
     }
-    return node.value();
+    String varString = match.getVariableString(key);
+    if (varString != null) {
+      return varString;
+    }
+    return null;
   }
 
   public List<Pair<CoreMap, List<SemgrexMatch>>> postprocessMatches(List<Pair<CoreMap, List<SemgrexMatch>>> matches, boolean keepEmptyMatches) {

test/src/edu/stanford/nlp/semgraph/semgrex/SemgrexTest.java

@@ -1524,12 +1524,32 @@ public void testBrokenUniq() {
     }
   }
 
+  /**
+   * Test that an illegal uniq expression throws an exception when both node and regex are named
+   *<br>
+   * Specifically, the expectation is for a SemgrexParseException
+   */
+  public void testOverlappingUniq() {
+    try {
+      String pattern = "{word:__#1%foo}=foo :: uniq foo";
+      SemgrexPattern semgrex = SemgrexPattern.compile(pattern);
+      throw new RuntimeException("This expression should fail because the node name and regex name overlap");
+    } catch (SemgrexParseException e) {
+      // yay
+    }
+  }
+
   /**
    * Test that a simple uniq expression is correctly parsed
    */
   public void testParsesUniq() {
+    // Test the basic node name compilation
     String pattern = "{word:foo}=foo :: uniq foo";
     SemgrexPattern semgrex = SemgrexPattern.compile(pattern);
+
+    // Test the basic regex compilation
+    pattern = "{word:__#1%foo} :: uniq foo";
+    semgrex = SemgrexPattern.compile(pattern);
   }
 
   /**
@@ -1570,6 +1590,17 @@ public void testBatchUniq() {
     assertEquals(1, matches.get(1).second().size());
     assertEquals(BATCH_PARSES[3], matches.get(2).first().get(CoreAnnotations.TextAnnotation.class));
     assertEquals(1, matches.get(2).second().size());
+
+    // test the uniq operator on a regex match
+    semgrex = SemgrexPattern.compile("{word:__#1%x} !< {} :: uniq x");
+    matches = semgrex.matchSentences(sentences, false);
+    assertEquals(2, matches.size());
+    assertEquals(BATCH_PARSES[0], matches.get(0).first().get(CoreAnnotations.TextAnnotation.class));
+    assertEquals(1, matches.get(0).second().size());
+    assertEquals("foo", matches.get(0).second().get(0).getVariableString("x"));
+    assertEquals(BATCH_PARSES[2], matches.get(1).first().get(CoreAnnotations.TextAnnotation.class));
+    assertEquals(1, matches.get(1).second().size());
+    assertEquals("bar", matches.get(1).second().get(0).getVariableString("x"));
   }
 
   public void testRegexVariableGroups() {