Parse a node containment option... need to process it in the NodePattern still

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

Author: AngledLuffa

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

@@ -26,12 +26,20 @@ public class NodeAttributes {
   // String, String, Boolean: key, value, negated
   private List<Triple<String, String, Boolean>> attributes;
   private Set<String> positiveAttributes;
+  // Some annotations, especially morpho freatures (CoreAnnotations.CoNLLUFeats)
+  // are represented by Maps.  In some cases it will be easier to search
+  // for individual elements of that map rather than turn the map into a string
+  // and search on its contents that way.  This is especially true since there
+  // is no guarantee the map will be in a consistent order.
+  // String, String, String: node attribute for a map (such as CoNLLUFeats), key in that map, value to match
+  private List<Triple<String, String, String>> contains;
 
   public NodeAttributes() {
     root = false;
     empty = false;
     attributes = new ArrayList<>();
     positiveAttributes = new HashSet<>();
+    contains = new ArrayList<>();
   }
 
   public void setRoot(boolean root) {
@@ -60,7 +68,15 @@ public void setAttribute(String key, String value, boolean negated) {
     attributes.add(new Triple(key, value, negated));
   }
 
+  public void addContains(String annotation, String key, String value) {
+    contains.add(new Triple(annotation, key, 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

@@ -32,6 +32,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 List<Pair<String, Attribute>> partialAttributes;
   private final boolean isRoot;
   private final boolean isLink;
   private final boolean isEmpty;
@@ -58,6 +63,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
+    this.partialAttributes = new ArrayList<>();
+
     descString = "{";
     for (Triple<String, String, Boolean> entry : attrs.attributes()) {
       if (!descString.equals("{"))
@@ -70,23 +78,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 +90,27 @@ 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();
+
+      final Attribute attr;
+      // Add the attributes for this key
+      if (value.equals("__")) {
+        attr = new Attribute(key, true, true, false);
+      } else if (value.matches("/.*/")) {
+        attr = buildRegexAttribute(key, value, false);
+      } else { // raw description
+        attr = new Attribute(key, value, value, false);
+      }
+      partialAttributes.add(new Pair<>(annotation, attr));
+
+      if (!descString.equals("{"))
+        descString += ";";
+      descString += (annotation + "@" + key + "=" + value);
+    }
+
     if (attrs.root()) {
       if (!descString.equals("{"))
         descString += ";";
@@ -118,6 +131,53 @@ 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);
+    }
+  }
+
+  private boolean checkMatch(Attribute attr, boolean ignoreCase, String nodeValue) {
+    boolean matches;
+
+    Object toMatch = ignoreCase ? attr.caseless : attr.cased;
+    if (toMatch instanceof Boolean) {
+      matches = ((Boolean) toMatch);
+    } else if (toMatch instanceof String) {
+      if (ignoreCase) {
+        matches = nodeValue.equalsIgnoreCase(toMatch.toString());
+      } else {
+        matches = nodeValue.equals(toMatch.toString());
+      }
+    } else if (toMatch instanceof Pattern) {
+      matches = ((Pattern) toMatch).matcher(nodeValue).matches();
+    } else {
+      throw new IllegalStateException("Unknown matcher type: " + toMatch + " (of class + " + toMatch.getClass() + ")");
+    }
+    if (attr.negated) {
+      matches = !matches;
+    }
+    return matches;
+  }
+
   @SuppressWarnings("unchecked")
   public boolean nodeAttrMatch(IndexedWord node, final SemanticGraph sg, boolean ignoreCase) {
     // System.out.println(node.word());
@@ -156,31 +216,20 @@ public boolean nodeAttrMatch(IndexedWord node, final SemanticGraph sg, boolean i
         return negDesc;
 
       // Get the node pattern
-      Object toMatch = ignoreCase ? attr.caseless : attr.cased;
-      boolean matches;
-      if (toMatch instanceof Boolean) {
-        matches = ((Boolean) toMatch);
-      } else if (toMatch instanceof String) {
-        if (ignoreCase) {
-          matches = nodeValue.equalsIgnoreCase(toMatch.toString());
-        } else {
-          matches = nodeValue.equals(toMatch.toString());
-        }
-      } else if (toMatch instanceof Pattern) {
-        matches = ((Pattern) toMatch).matcher(nodeValue).matches();
-      } else {
-        throw new IllegalStateException("Unknown matcher type: " + toMatch + " (of class + " + toMatch.getClass() + ")");
-      }
-      if (attr.negated) {
-        matches = !matches;
-      }
+      boolean matches = checkMatch(attr, ignoreCase, nodeValue);
 
       if (!matches) {
         // System.out.println("doesn't match");
         // System.out.println("");
         return negDesc;
       }
     }
+    for (Pair<String, Attribute> partialAttribute : partialAttributes) {
+      String annotation = partialAttribute.first();
+      Attribute attr = partialAttribute.second();
+      // TODO
+    }
+
     // System.out.println("matches");
     // System.out.println("");
     return !negDesc;