UniformEnumConstantNameCheck.java

  1. ////////////////////////////////////////////////////////////////////////////////
  2. // checkstyle: Checks Java source code for adherence to a set of rules.
  3. // Copyright (C) 2001-2019 the original author or authors.
  4. //
  5. // This library is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU Lesser General Public
  7. // License as published by the Free Software Foundation; either
  8. // version 2.1 of the License, or (at your option) any later version.
  9. //
  10. // This library is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13. // Lesser General Public License for more details.
  14. //
  15. // You should have received a copy of the GNU Lesser General Public
  16. // License along with this library; if not, write to the Free Software
  17. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. ////////////////////////////////////////////////////////////////////////////////

  20. package com.github.sevntu.checkstyle.checks.naming;

  22. import java.util.ArrayList;
  23. import java.util.BitSet;
  24. import java.util.Collection;
  25. import java.util.List;
  26. import java.util.regex.Pattern;

  28. import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
  29. import com.puppycrawl.tools.checkstyle.api.DetailAST;
  30. import com.puppycrawl.tools.checkstyle.api.TokenTypes;

  32. /**
  33.  * Check forces enum constants to match one of the specified patterns and forces
  34.  * all the values to follow only one of the specified patterns.
  35.  *
  36.  * <p>By default both CamelCase and UPPER_CASE are allowed, so check validates,
  37.  * whether all the values conform the either of them.
  38.  *
  39.  * <p>For example, both enums are allowed by the check:<pre>
  40.  * public enum EnumOne {
  41.  *    FirstElement, SecondElement, ThirdElement;
  42.  * }
  43.  * public enum EnumTwo {
  44.  *    FIRST_ELEMENT, SECOND_ELEMENT, THIRD_ELEMENT;
  45.  * }</pre> But the following enum, is violated, because values conform
  46.  * different notations: <pre>
  47.  * public enum EnumThree {
  48.  *    FirstElement, SECOND_ELEMENT, ThirdElement;
  49.  * }
  50.  * </pre>
  51.  *
  52.  * <p>To use only CamelCase, use the following configuration:
  53.  *
  54.  * <pre>
  55.  * &lt;module name="UniformEnumConstantNameCheck"&gt;
  56.  *    &lt;property name="format" value="^[A-Z][a-zA-Z0-9]*$"/&gt;
  57.  * &lt;/module&gt;
  58.  * </pre>
  59.  *
  60.  * <p>If both CamelCase and UPPER_CASE are allowed, use the following configuration
  61.  * (this is the default):
  62.  *
  63.  * <pre>
  64.  * &lt;module name="UniformEnumConstantNameCheck"&gt;
  65.  *    &lt;property name="format" value="^[A-Z][a-zA-Z0-9]*$,^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$"/&gt;
  66.  * &lt;/module&gt;
  67.  * </pre>
  68.  *
  69.  * <p>Only first violation is reported for each enumeration because of the nature
  70.  * of the check: it's impossible to determine which specific pattern user should
  71.  * follow for this certain enumeration, as multiple patterns have been
  72.  * specified. The only thing that this check reports is whether there is at
  73.  * least one pattern (among specified in the configuration), which all the enum
  74.  * constant conform or there is no.
  75.  *
  76.  * @author Pavel Baranchikov
  77.  * @since 1.21.0
  78.  */
  79. public class UniformEnumConstantNameCheck extends AbstractCheck {

  81.     /**
  82.      * Message code for format violations. Used, when more than one format
  83.      * violated.
  84.      */
  85.     public static final String MSG_NOT_VALID_MULTI = "enum.name.formats.violated";
  86.     /**
  87.      * Message code for format violations. Used, when exactly one format
  88.      * violated.
  89.      */
  90.     public static final String MSG_NOT_VALID_SINGLE = "enum.name.format.violated";
  91.     /**
  92.      * Camel notation regular expression.
  93.      */
  94.     public static final String CAMEL_PATTERN = "^[A-Z][a-zA-Z0-9]*$";
  95.     /**
  96.      * Upper case notation regular expression.
  97.      */
  98.     public static final String UPPERCASE_PATTERN = "^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$";
  99.     /**
  100.      * Default pattern for enumeration values.
  101.      */
  102.     public static final String[] DEFAULT_PATTERN = {
  103.         CAMEL_PATTERN,
  104.         UPPERCASE_PATTERN,
  105.     };

  107.     /**
  108.      * Regular expression list to test Enumeration names against.
  109.      */
  110.     private List<Pattern> patterns;
  111.     /**
  112.      * Number of patterns specified for {@code patterns} field. This field is
  113.      * always the size of {@link #patterns}.
  114.      */
  115.     private int patternCount;

  117.     /**
  118.      * Constructs check with the default pattern.
  119.      */
  120.     public UniformEnumConstantNameCheck() {
  121.         setFormats(DEFAULT_PATTERN);
  122.     }

  124.     /**
  125.      * Method sets format to match Class Enumeration names.
  126.      * @param regexps format to check against
  127.      */
  128.     public final void setFormats(String... regexps) {
  129.         this.patterns = new ArrayList<>(regexps.length);
  130.         for (final String regexp: regexps) {
  131.             final Pattern pattern = Pattern.compile(regexp, 0);
  132.             patterns.add(pattern);
  133.         }
  134.         patternCount = regexps.length;
  135.     }

  137.     @Override
  138.     public int[] getDefaultTokens() {
  139.         return getAcceptableTokens();
  140.     }

  142.     @Override
  143.     public int[] getAcceptableTokens() {
  144.         return new int[] {
  145.             TokenTypes.ENUM_DEF,
  146.             };
  147.     }

  149.     @Override
  150.     public int[] getRequiredTokens() {
  151.         return getAcceptableTokens();
  152.     }

  154.     @Override
  155.     public void visitToken(DetailAST ast) {
  156.         final DetailAST objBlock = ast.findFirstToken(TokenTypes.OBJBLOCK);
  157.         final BitSet conformedPatterns = new BitSet(patternCount);
  158.         conformedPatterns.set(0, patternCount);
  159.         for (DetailAST member = objBlock.getFirstChild(); member != null
  160.                 && !conformedPatterns.isEmpty();
  161.                 member = member.getNextSibling()) {
  162.             if (member.getType() != TokenTypes.ENUM_CONSTANT_DEF) {
  163.                 continue;
  164.             }
  165.             final String enumName = member.findFirstToken(TokenTypes.IDENT).getText();
  166.             final BitSet matched = match(enumName, conformedPatterns);
  167.             if (matched.isEmpty()) {
  168.                 logViolation(member, enumName, conformedPatterns);
  169.             }
  170.             conformedPatterns.and(matched);
  171.         }
  172.     }

  174.     /**
  175.      * Logs violation for the specified token, representing the specified enum
  176.      * value wich violates the specified patterns.
  177.      *
  178.      * @param member
  179.      *        token, which violates the check
  180.      * @param enumName
  181.      *        enum value name for this token
  182.      * @param violated
  183.      *        bit set of violated patterns
  184.      */
  185.     private void logViolation(DetailAST member, String enumName, BitSet violated) {
  186.         final String patternsString;
  187.         final String msgKey;
  188.         if (violated.cardinality() == 1) {
  189.             msgKey = MSG_NOT_VALID_SINGLE;
  190.             patternsString = patterns.get(violated.nextSetBit(0))
  191.                     .toString();
  192.         }
  193.         else {
  194.             msgKey = MSG_NOT_VALID_MULTI;
  195.             final Collection<Pattern> violatedPatterns = new ArrayList<>(
  196.                     violated.cardinality());
  197.             int index = violated.nextSetBit(0);
  198.             while (index >= 0) {
  199.                 violatedPatterns.add(patterns.get(index));
  200.                 index = violated.nextSetBit(index + 1);
  201.             }
  202.             patternsString = violatedPatterns.toString();
  203.         }
  204.         log(member, msgKey, enumName,
  205.                 patternsString);
  206.     }

  208.     /**
  209.      * Matches the specified enum name against the patterns, specified by
  210.      * {@code conformedPatterns}.
  211.      *
  212.      * @param name
  213.      *        name to validate
  214.      * @param conformedPatterns
  215.      *        bit set of patterns, which the method should match against.
  216.      * @return bit set of matched patterns. Returned value is always a subset of
  217.      *         {@code conformedPatterns}
  218.      */
  219.     private BitSet match(String name, BitSet conformedPatterns) {
  220.         final BitSet result = new BitSet(patternCount);
  221.         for (int i = 0; i < patterns.size(); i++) {
  222.             if (conformedPatterns.get(i)) {
  223.                 final Pattern pattern = patterns.get(i);
  224.                 if (pattern.matcher(name).find()) {
  225.                     result.set(i);
  226.                 }
  227.             }
  228.         }
  229.         return result;
  230.     }

  232. }
Created with JaCoCo 0.7.1.201405082137