View Javadoc

    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[ruleSets.size()]);
    55      }
    56
    57      public Iterator getRuleSetsIterator() {
    58          return ruleSets.iterator();
    59      }
    60
    61      /***
    62       * Return all rules from all rulesets.
    63       *
    64       * @return Set
    65       */
    66      public Set getAllRules() {
    67          HashSet result = new HashSet();
    68          for (Iterator i = ruleSets.iterator(); i.hasNext();) {
    69              result.addAll(((RuleSet) i.next()).getRules());
    70          }
    71          return result;
    72      }
    73
    74      /***
    75       * Check if a source with given language should be checked by rules for a given
    76       * language. This is the case if both languages are equal, or if the source is in
    77       * java, and the language of the rules is unknown (for backward-compatibility
    78       * reasons).
    79       *
    80       * @param languageOfSource language of a source; can not be null
    81       * @param languageOfRule   language of a ruleset; can be null
    82       * @return  boolean true if the rule applies, else false
    83       */
    84      public boolean applies(Language languageOfSource, Language languageOfRule) {
    85          return (languageOfSource.equals(languageOfRule) || (languageOfSource
    86                  .equals(Language.JAVA) && (null == languageOfRule)));
    87      }
    88
    89      /***
    90       * Apply all applicable rules to the compilation units.
    91       * Applicable means the language of the rules must match the language
    92       * of the source (@see applies).
    93       *
    94       * @param acuList  the List of compilation units; the type these must have,
    95       *                 depends on the source language
    96       * @param ctx      the RuleContext
    97       * @param language the Language of the source
    98       */
    99      public void apply(List acuList, RuleContext ctx, Language language) {
    100         for (Iterator i = ruleSets.iterator(); i.hasNext();) {
    101             RuleSet ruleSet = (RuleSet) i.next();
    102             if (applies(language, ruleSet.getLanguage())) {
    103                 ruleSet.apply(acuList, ctx);
    104             }
    105         }
    106     }
    107
    108     /***
    109      * Check if the rules that apply to a source of the given language
    110      * use DFA.
    111      *
    112      * @param language the language of a source
    113      * @return true if any rule in the RuleSet needs the DFA layer
    114      */
    115     public boolean usesDFA(Language language) {
    116         for (Iterator i = ruleSets.iterator(); i.hasNext();) {
    117             RuleSet ruleSet = (RuleSet) i.next();
    118             if (applies(language, ruleSet.getLanguage()) && ruleSet.usesDFA()) {
    119                 return true;
    120             }
    121         }
    122         return false;
    123     }
    124
    125     /***
    126      * Returns the Rule with the given name
    127      *
    128      * @param ruleName the name of the rule to find
    129      * @return the rule or null if not found
    130      */
    131     public Rule getRuleByName(String ruleName) {
    132         Rule rule = null;
    133         for (Iterator i = ruleSets.iterator(); i.hasNext() && (rule == null);) {
    134             RuleSet ruleSet = (RuleSet) i.next();
    135             rule = ruleSet.getRuleByName(ruleName);
    136         }
    137         return rule;
    138     }
    139
    140 	public boolean usesTypeResolution(Language language) {
    141 		for (Iterator i = ruleSets.iterator(); i.hasNext();) {
    142 			RuleSet ruleSet = (RuleSet) i.next();
    143 			if (applies(language, ruleSet.getLanguage()) && ruleSet.usesTypeResolution()) {
    144 				return true;
    145 			}
    146 		}
    147 		return false;
    148 	}
    149 }