Specmate DSL integration (#441)

* Finished DSL Integration
* Bugfixes; Tested Integration
* Fixed dublicte Nodes issue
* Added Rules; Better Language Detection; Bugfixes
* Added Rules
* Added English Adjective Unfolding
* Removed Debugging Code
* Fixed Tree Merging
* Improved Roboustness, added new Rules, begun testing.
* Added More rules, fixed order of operations, bugfixes
* Refactoring
* Fixed last request

Author: Daedo

bundles/specmate-cause-effect-patterns/bnd.bnd

@@ -25,10 +25,10 @@ Private-Package: \
 Export-Package: \
 	com.specmate.cause_effect_patterns.parse,\
 	com.specmate.cause_effect_patterns.parse.matcher,\
+	com.specmate.cause_effect_patterns.parse.wrapper,\
 	com.specmate.cause_effect_patterns.resolve
 Import-Package: \
 	org.eclipse.xtext.smap;resolution:=optional,\
 	*
 -runfw: org.eclipse.osgi;version='[3.10.2.v20150203-1939,3.10.2.v20150203-1939]'
 -runee: JavaSE-1.8
-Bundle-Version: 0.0.0.${tstamp}

bundles/specmate-cause-effect-patterns/src/com/specmate/cause_effect_patterns/parse/DependencyNode.java

@@ -2,6 +2,7 @@
 
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map.Entry;
 import java.util.Set;
 
 import com.google.common.collect.ArrayListMultimap;
@@ -26,6 +27,16 @@ public void addDepenency(Dependency d) {
 		this.dependencies.put(d.getDependencyType(), d);
 	}
 
+	public void addDependencies(DependencyNode other) {
+		for(Entry<String, Dependency> entry: other.dependencies.entries()) {
+			String key = entry.getKey();
+			Dependency value = entry.getValue();
+			if(!this.dependencies.containsEntry(key, value)) {
+				this.dependencies.put(key, value);
+			}
+		}
+	}
+	
 	public List<Dependency> getDependenciesFromTag(String dependencyTag) {
 		return this.dependencies.get(dependencyTag);
 	}

bundles/specmate-cause-effect-patterns/src/com/specmate/cause_effect_patterns/parse/DependencyParsetree.java

@@ -8,6 +8,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Vector;
+import java.util.stream.Collectors;
 
 import org.apache.uima.fit.util.JCasUtil;
 import org.apache.uima.internal.util.SortedIntSet;
@@ -26,8 +27,15 @@
  *
  */
 public class DependencyParsetree {
+	private static Set<String> ignoreDependency;
+	static {
+		DependencyParsetree.ignoreDependency = new HashSet<String>();
+		DependencyParsetree.ignoreDependency.add("punct");
+	}
+	
 	private static String ROOT = "ROOT";
 
+	
 	private Map<Token, DependencyNode> dependencies;
 	private Set<Token> heads;
 	private List<TextInterval> treeFragments;
@@ -45,6 +53,10 @@ public static DependencyParsetree generateFromJCas(JCas jcas) {
 		for(Dependency d: dependencyList) {
 			Token governor = d.getGovernor();
 
+			if(DependencyParsetree.ignoreDependency.contains(d.getDependencyType())) {
+				continue;
+			}
+			
 			if(!result.dependencies.containsKey(governor)) {
 				result.dependencies.put(governor, new DependencyNode());
 				result.addFragment(governor);
@@ -95,19 +107,22 @@ public DependencyParsetree() {
 	}
 
 	public void addSubtree(DependencyParsetree subtree) {
-		this.dependencies.putAll(subtree.dependencies);
+		for(Token token: subtree.dependencies.keySet()) {
+			if(this.dependencies.containsKey(token)) {
+				DependencyNode nodeA = this.dependencies.get(token);
+				DependencyNode nodeB = subtree.dependencies.get(token);
+				nodeA.addDependencies(nodeB);
+			} else {
+				this.dependencies.put(token, subtree.dependencies.get(token));
+			}
+		}
 		this.treeFragments.addAll(subtree.treeFragments);
 		this.tokenOrder.union(subtree.tokenOrder);
 		this.minimizeTreeFragments();
 	}
 
 	public void addSubtree(DependencyParsetree subtree, Dependency dependency) {
-		Token governor = dependency.getGovernor();
-		if(!this.dependencies.containsKey(governor)) {
-			this.dependencies.put(governor, new DependencyNode());
-			addFragment(governor);
-		}
-		this.dependencies.get(governor).addDepenency(dependency);
+		addDependency(dependency);
 		this.addSubtree(subtree);
 	}
 
@@ -157,6 +172,18 @@ public TextInterval getTextInterval(int index) {
 		return this.treeFragments.get(index);
 	}
 
+	public String getRepresentationString(boolean capitalize) {
+		String result = this.treeFragments.stream()
+						  				  .map(f -> f.text)
+						  				  .filter(str -> str.length() > 1)
+						  				  .collect(Collectors.joining(" "));
+		if(capitalize) {
+			result = result.substring(0, 1).toUpperCase() + result.substring(1); 
+		}
+		
+		return result;
+	}
+	
 	public String getTreeFragmentText() {
 		String result = "Fragments:\n";
 		for(TextInterval i: this.treeFragments) {
@@ -187,6 +214,15 @@ public String toString() {
 		result+= this.getTreeFragmentText();
 		return result;
 	}
+
+	public void addDependency(Dependency dependency) {
+		Token governor = dependency.getGovernor();
+		if(!this.dependencies.containsKey(governor)) {
+			this.dependencies.put(governor, new DependencyNode());
+			addFragment(governor);
+		}
+		this.dependencies.get(governor).addDepenency(dependency);
+	}
 
 	public class TextInterval implements Comparable<TextInterval>{
 		public int from, to;
@@ -257,4 +293,5 @@ public int compareTo(TextInterval o) {
 			return 0;
 		}
 	}
+
 }

bundles/specmate-cause-effect-patterns/src/com/specmate/cause_effect_patterns/parse/matcher/MatchResult.java

@@ -1,12 +1,13 @@
 package com.specmate.cause_effect_patterns.parse.matcher;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
+import java.util.Vector;
 
 import com.specmate.cause_effect_patterns.parse.DependencyParsetree;
-import com.specmate.cause_effect_patterns.parse.matcher.MatchResult;
-import com.specmate.cause_effect_patterns.parse.matcher.SubtreeMatcher;
 
 /**
  * Class storing the result of a dependency matching operation.
@@ -23,12 +24,13 @@ public class MatchResult {
 	private boolean isSuccessfulMatch;
 	private Map<String, MatchResult> submatch;
 	private DependencyParsetree matchTree;
-	
+	private Optional<String> ruleName;
 
 	private MatchResult(boolean success, DependencyParsetree matchTree) {
 		this.matchTree = matchTree;
 		this.isSuccessfulMatch = success;
 		this.submatch = new HashMap<String, MatchResult>();
+		this.ruleName = Optional.empty();
 	}
 
 	private MatchResult(boolean success) {
@@ -39,6 +41,24 @@ private MatchResult() {
 		this(false);
 	}
 
+	public void setRuleName(String ruleName) {
+		this.ruleName = Optional.of(ruleName);
+		for(String sub: this.submatch.keySet()) {
+			MatchResult subRes = this.submatch.get(sub);
+			if(!subRes.hasRuleName()) {
+				subRes.setRuleName(ruleName);
+			}
+		}
+	}
+	
+	public boolean hasRuleName() {
+		return this.ruleName.isPresent();
+	}
+	
+	public String getRuleName() {
+		return this.ruleName.get();
+	}
+	
 	public boolean isSuccessfulMatch() {
 		return isSuccessfulMatch;
 	}
@@ -60,10 +80,35 @@ public void addSubtree(MatchResult subtree) {
 		for(String subtreeID: subtree.submatch.keySet()) {
 			this.submatch.put(subtreeID, subtree.submatch.get(subtreeID));
 		}
+		if(subtree.submatch.size() > 0) {
+			this.mergePrefixSubmatches();
+		}
+		
 		this.isSuccessfulMatch = this.isSuccessfulMatch() && subtree.isSuccessfulMatch();
 		this.getMatchTree().addSubtree(subtree.getMatchTree());
 	}
 
+	
+	private void mergePrefixSubmatches() {
+		Vector<String> keys = new Vector<String>(this.submatch.keySet());
+		Collections.sort(keys, (s1,s2) -> s1.length() - s2.length());
+		for (int i = 0; i < keys.size(); i++) {
+			String keyA = keys.get(i);
+			for (int j = i+1; j < keys.size(); j++) {
+				String keyB = keys.get(j);
+				if(keyB.startsWith(keyA+"_")) {
+					//merge keys
+					MatchResult resA = this.submatch.get(keyA);
+					MatchResult resB = this.submatch.get(keyB);
+					resA.addSubtree(resB);
+					keys.remove(j);
+					this.submatch.remove(keyB);
+					j--;
+				}
+			}
+		}
+	}
+	
 	public DependencyParsetree getMatchTree() {
 		return matchTree;
 	}
@@ -75,6 +120,9 @@ public void clearMatchTree() {
 	public void addSubmatch(String subtreeName, MatchResult submatch) {
 		this.isSuccessfulMatch = this.isSuccessfulMatch && submatch.isSuccessfulMatch;
 		this.submatch.put(subtreeName, submatch);
+		if(this.submatch.size() > 1) {
+			this.mergePrefixSubmatches();
+		}
 	}
 
 	public boolean hasSubmatch(String subtreeName) {
@@ -88,4 +136,8 @@ public MatchResult getSubmatch(String subtreeName) {
 	public Set<String> getSubmatchNames() {
 		return this.submatch.keySet();
 	}
+
+	public void clearSubmatches() {
+		this.submatch.clear();
+	}
 }

bundles/specmate-cause-effect-patterns/src/com/specmate/cause_effect_patterns/parse/matcher/MatchRule.java

@@ -1,7 +1,10 @@
 package com.specmate.cause_effect_patterns.parse.matcher;
 
+import com.specmate.cause_effect_patterns.parse.DependencyParsetree;
 import com.specmate.cause_effect_patterns.parse.matcher.MatcherBase;
 
+import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Token;
+
 public class MatchRule {
 	public MatcherBase matcher;
 	public String ruleName;
@@ -11,6 +14,12 @@ public MatchRule(MatcherBase matcher, String name) {
 		this.ruleName = name;
 	}
 
+	public MatchResult match(DependencyParsetree data, Token head) {
+		MatchResult result = this.matcher.match(data, head);
+		result.setRuleName(this.ruleName);
+		return result;
+	}
+	
 	@Override
 	public String toString() {
 		return "Match Rule: " + this.ruleName+"\n"+this.matcher;

bundles/specmate-cause-effect-patterns/src/com/specmate/cause_effect_patterns/parse/matcher/MatchUtil.java

@@ -4,9 +4,6 @@
 import java.util.Vector;
 
 import com.specmate.cause_effect_patterns.parse.DependencyParsetree;
-import com.specmate.cause_effect_patterns.parse.matcher.MatchResult;
-import com.specmate.cause_effect_patterns.parse.matcher.MatchUtil;
-import com.specmate.cause_effect_patterns.parse.matcher.MatcherBase;
 
 import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Token;
 
@@ -18,14 +15,17 @@ public class MatchUtil {
 	 * @param data
 	 * @return A List of Results for each head of the dependency data object.
 	 */
-	public static List<MatchResult> evaluateRuleset(List<MatcherBase> rules, DependencyParsetree data) {
+	public static List<MatchResult> evaluateRuleset(List<MatchRule> rules, DependencyParsetree data) {
 		Vector<MatchResult> result = new Vector<MatchResult>();
 		for(Token head: data.getHeads()) {
 			result.add(MatchUtil.evaluateRuleset(rules, data, head));
 		}
 		return result; 
 	}
 
+	
+	
+	
 	/**
 	 * Recursively applies the list of matchers on the given dependency data object starting at the head token.
 	 * 
@@ -34,26 +34,51 @@ public static List<MatchResult> evaluateRuleset(List<MatcherBase> rules, Depende
 	 * @param head
 	 * @return
 	 */
-	public static MatchResult evaluateRuleset(List<MatcherBase> rules, DependencyParsetree data, Token head) {
+	public static MatchResult evaluateRuleset(List<MatchRule> rules, DependencyParsetree data, Token head) {
+		return evaluateRuleset(rules, data, head, 0);
+	}
+		
+	private static MatchResult evaluateRuleset(List<MatchRule> rules, DependencyParsetree data, Token head, int ruleOffset) {
 		MatchResult result = MatchResult.unsuccessful();
-		for(MatcherBase rule: rules) {
+		
+		List<MatchRule> offsetedRules = rules.subList(ruleOffset, rules.size());
+		for(MatchRule rule: offsetedRules) {
 			result = rule.match(data, head);
 			if(result.isSuccessfulMatch()) {
-				for(String submatchName: result.getSubmatchNames()) {
-					MatchResult sub = result.getSubmatch(submatchName);
-					DependencyParsetree subData = sub.getMatchTree(); 
-					Token subHead = subData.getHeads().stream().findFirst().get();
-					MatchResult recursiveCall = evaluateRuleset(rules, subData, subHead);
-					if(recursiveCall.isSuccessfulMatch()) {
-						for( String subKey: recursiveCall.getSubmatchNames()) {
-							sub.addSubmatch(subKey, recursiveCall.getSubmatch(subKey));	
-						}
-					}
-				}
+				evaluateRulesetOnSubtrees(rules, rule, data, head, result);
 				break;
 			}
 		}
 
 		return result;
 	}
+	
+	private static void evaluateRulesetOnSubtrees(List<MatchRule> rules, MatchRule currentRule, 
+			DependencyParsetree data, Token head, MatchResult result) {
+		for(String submatchName: result.getSubmatchNames()) {
+			MatchResult sub = result.getSubmatch(submatchName);
+			DependencyParsetree subData = sub.getMatchTree();
+			Token subHead = subData.getHeads().stream().findFirst().get();
+			
+			MatchResult recursiveCall;
+			if(subData.getTreeFragmentText().equals(data.getTreeFragmentText()) && subHead.equals(head)) {
+				int newOffset = rules.indexOf(currentRule) + 1;
+				recursiveCall = evaluateRuleset(rules, subData, subHead, newOffset);
+			} else {
+				recursiveCall = evaluateRuleset(rules, subData, subHead);
+			}
+			
+			if(recursiveCall.isSuccessfulMatch()) {
+				sub.setRuleName(recursiveCall.getRuleName());
+				for( String subKey: recursiveCall.getSubmatchNames()) {
+					MatchResult subRes =  recursiveCall.getSubmatch(subKey);
+					if(!subRes.hasRuleName() ) {
+						subRes.setRuleName(recursiveCall.getRuleName());
+					}
+					sub.addSubmatch(subKey, subRes);
+				}
+			}
+		}
+	}
+	
 }