Keep track of the partial attributes. Still need to actually check them...

Author: AngledLuffa

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

@@ -39,6 +39,7 @@ public NodeAttributes() {
     empty = false;
     attributes = new ArrayList<>();
     positiveAttributes = new HashSet<>();
+    contains = new ArrayList<>();
   }
 
   public void setRoot(boolean root) {
@@ -74,4 +75,8 @@ public void addContains(String annotation, String key, String value) {
   public List<Triple<String, String, Boolean>> attributes() {
     return Collections.unmodifiableList(attributes);
   }
+
+  public List<Triple<String, String, String>> contains() {
+    return Collections.unmodifiableList(contains);
+  }
 }

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

@@ -5,6 +5,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.TreeMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -32,6 +33,11 @@ public class NodePattern extends SemgrexPattern  {
    *  Otherwise, the type will be a Pattern, and you must use Pattern.matches().
    */
   private final List<Attribute> attributes;
+  /**
+   * Attributes which represent Maps (eg CoNLLUFeats)
+   * and only partial matches are necessary
+   */
+  private final Map<String, Attribute> partialAttributes;
   private final boolean isRoot;
   private final boolean isLink;
   private final boolean isEmpty;
@@ -58,6 +64,9 @@ public NodePattern(GraphRelation r, boolean negDesc,
     // order the attributes so that the pattern stays the same when
     // printing a compiled pattern
     this.attributes = new ArrayList<>();
+    // same with partial attributes - use a TreeMap to keep things in order
+    this.partialAttributes = new TreeMap<>();
+
     descString = "{";
     for (Triple<String, String, Boolean> entry : attrs.attributes()) {
       if (!descString.equals("{"))
@@ -70,23 +79,7 @@ public NodePattern(GraphRelation r, boolean negDesc,
       if (value.equals("__")) {
         attributes.add(new Attribute(key, true, true, negated));
       } else if (value.matches("/.*/")) {
-        boolean isRegexp = false;
-        for (int i = 1; i < value.length() - 1; ++i) {
-          char chr = value.charAt(i);
-          if ( !( (chr >= 'A' && chr <= 'Z') || (chr >= 'a' && chr <= 'z') || (chr >= '0' && chr <= '9') ) ) {
-            isRegexp = true;
-            break;
-          }
-        }
-        String patternContent = value.substring(1, value.length() - 1);
-        if (isRegexp) {
-          attributes.add(new Attribute(key,
-                                       Pattern.compile(patternContent),
-                                       Pattern.compile(patternContent, Pattern.CASE_INSENSITIVE|Pattern.UNICODE_CASE),
-                                       negated));
-        } else {
-          attributes.add(new Attribute(key, patternContent, patternContent, negated));
-        }
+        attributes.add(buildRegexAttribute(key, value, negated));
       } else { // raw description
         attributes.add(new Attribute(key, value, value, negated));
       }
@@ -98,6 +91,25 @@ public NodePattern(GraphRelation r, boolean negDesc,
       }
     }
 
+    for (Triple<String, String, String> entry : attrs.contains()) {
+      String annotation = entry.first();
+      String key = entry.second();
+      String value = entry.third();
+
+      // Add the attributes for this key
+      if (value.equals("__")) {
+        partialAttributes.put(annotation, new Attribute(key, true, true, false));
+      } else if (value.matches("/.*/")) {
+        partialAttributes.put(annotation, buildRegexAttribute(key, value, false));
+      } else { // raw description
+        partialAttributes.put(annotation, new Attribute(key, value, value, false));
+      }
+
+      if (!descString.equals("{"))
+        descString += ";";
+      descString += (annotation + "@" + key + "=" + value);
+    }
+
     if (attrs.root()) {
       if (!descString.equals("{"))
         descString += ";";
@@ -118,6 +130,30 @@ public NodePattern(GraphRelation r, boolean negDesc,
     this.variableGroups = Collections.unmodifiableList(variableGroups);
   }
 
+  /**
+   * Tests the value to see if it's really a regex, or just a string wrapped in regex.
+   * Return an Attribute which matches this expression
+   */
+  private Attribute buildRegexAttribute(String key, String value, boolean negated) {
+    boolean isRegexp = false;
+    for (int i = 1; i < value.length() - 1; ++i) {
+      char chr = value.charAt(i);
+      if ( !( (chr >= 'A' && chr <= 'Z') || (chr >= 'a' && chr <= 'z') || (chr >= '0' && chr <= '9') ) ) {
+        isRegexp = true;
+        break;
+      }
+    }
+    String patternContent = value.substring(1, value.length() - 1);
+    if (isRegexp) {
+      return new Attribute(key,
+                           Pattern.compile(patternContent),
+                           Pattern.compile(patternContent, Pattern.CASE_INSENSITIVE|Pattern.UNICODE_CASE),
+                           negated);
+    } else {
+      return new Attribute(key, patternContent, patternContent, negated);
+    }
+  }
+
   @SuppressWarnings("unchecked")
   public boolean nodeAttrMatch(IndexedWord node, final SemanticGraph sg, boolean ignoreCase) {
     // System.out.println(node.word());