1 package net.sourceforge.pmd; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 import java.util.HashSet; 6 import java.util.Iterator; 7 import java.util.List; 8 import java.util.Set; 9 10 /*** 11 * Grouping of Rules per Language in a RuleSet. 12 * 13 * @author pieter_van_raemdonck - Application Engineers NV/SA - www.ae.be 14 */ 15 public class RuleSets { 16 /*** 17 * Map of RuleLanguage on RuleSet. 18 */ 19 private Collection ruleSets = new ArrayList(); 20 21 /*** 22 * Public constructor. 23 */ 24 public RuleSets() { 25 } 26 27 /*** 28 * Public constructor. Add the given rule set. 29 * 30 * @param ruleSet the RuleSet 31 */ 32 public RuleSets(RuleSet ruleSet) { 33 this(); 34 addRuleSet(ruleSet); 35 } 36 37 /*** 38 * Add a ruleset for a language. Only one ruleset can be added for a specific 39 * language. If ruleSet.getLanguage() is null, it is assumed to be a RuleSet of java 40 * rules. 41 * 42 * @param ruleSet the RuleSet 43 */ 44 public void addRuleSet(RuleSet ruleSet) { 45 ruleSets.add(ruleSet); 46 } 47 48 /*** 49 * Get all the RuleSets. 50 * 51 * @return RuleSet[] 52 */ 53 public RuleSet[] getAllRuleSets() { 54 return (RuleSet[]) ruleSets.toArray(new RuleSet[0]); 55 } 56 57 /*** 58 * Return all rules from all rulesets. 59 * 60 * @return Set 61 */ 62 public Set getAllRules() { 63 HashSet result = new HashSet(); 64 for (Iterator i = ruleSets.iterator(); i.hasNext();) { 65 result.addAll(((RuleSet) i.next()).getRules()); 66 } 67 return result; 68 } 69 70 /*** 71 * Check if a source with given language should be checked by rules for a given 72 * language. This is the case if both languages are equal, or if the source is in 73 * java, and the language of the rules is unknown (for backward-compatibility 74 * reasons). 75 * 76 * @param languageOfSource language of a source; can not be null 77 * @param languageOfRule language of a ruleset; can be null 78 * @return 79 */ 80 public boolean applies(Language languageOfSource, Language languageOfRule) { 81 return (languageOfSource.equals(languageOfRule) || (languageOfSource 82 .equals(Language.JAVA) && (null == languageOfRule))); 83 } 84 85 /*** 86 * Apply all applicable rules to the compilation units. 87 * Applicable means the language of the rules must match the language 88 * of the source (@see applies). 89 * 90 * @param acuList the List of compilation units; the type these must have, 91 * depends on the source language 92 * @param ctx the RuleContext 93 * @param language the Language of the source 94 */ 95 public void apply(List acuList, RuleContext ctx, Language language) { 96 for (Iterator i = ruleSets.iterator(); i.hasNext();) { 97 RuleSet ruleSet = (RuleSet) i.next(); 98 if (applies(language, ruleSet.getLanguage())) { 99 ruleSet.apply(acuList, ctx); 100 } 101 } 102 } 103 104 /*** 105 * Check if the rules that apply to a source of the given language 106 * use DFA. 107 * 108 * @param language the language of a source 109 * @return true if any rule in the RuleSet needs the DFA layer 110 */ 111 public boolean usesDFA(Language language) { 112 for (Iterator i = ruleSets.iterator(); i.hasNext();) { 113 RuleSet ruleSet = (RuleSet) i.next(); 114 if (applies(language, ruleSet.getLanguage()) && ruleSet.usesDFA()) { 115 return true; 116 } 117 } 118 return false; 119 } 120 121 /*** 122 * Returns the Rule with the given name 123 * 124 * @param ruleName the name of the rule to find 125 * @return the rule or null if not found 126 */ 127 public Rule getRuleByName(String ruleName) { 128 Rule rule = null; 129 for (Iterator i = ruleSets.iterator(); i.hasNext() && (rule == null);) { 130 RuleSet ruleSet = (RuleSet) i.next(); 131 rule = ruleSet.getRuleByName(ruleName); 132 } 133 return rule; 134 } 135 }