Coverage Report - com.puppycrawl.tools.checkstyle.checks.naming.AbstractAccessControlNameCheck
 
Classes in this File Line Coverage Branch Coverage Complexity
AbstractAccessControlNameCheck
100%
23/23
100%
28/28
2.286
 
 1  
 ////////////////////////////////////////////////////////////////////////////////
 2  
 // checkstyle: Checks Java source code for adherence to a set of rules.
 3  
 // Copyright (C) 2001-2017 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  
 ////////////////////////////////////////////////////////////////////////////////
 19  
 
 20  
 package com.puppycrawl.tools.checkstyle.checks.naming;
 21  
 
 22  
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 23  
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
 24  
 
 25  
 /**
 26  
  * Abstract class for checking a class member (field/method)'s name conforms to
 27  
  * a format specified by the format property.
 28  
  *
 29  
  * <p>
 30  
  * This class extends {@link AbstractNameCheck} with support for access level
 31  
  * restrictions. This allows the check to be configured to be applied to one of
 32  
  * the four Java access levels: {@code public}, {@code protected},
 33  
  * {@code "package"}, and {@code private}.
 34  
  * </p>
 35  
  *
 36  
  * <p>Level is configured using the following properties:
 37  
  * <ol>
 38  
  * <li>applyToPublic, default true;</li>
 39  
  * <li>applyToProtected, default true;</li>
 40  
  * <li>applyToPackage, default true;</li>
 41  
  * <li>applyToPrivate, default true;</li>
 42  
  * </ol>
 43  
  *
 44  
  *
 45  
  * @author Rick Giles
 46  
  */
 47  
 public abstract class AbstractAccessControlNameCheck
 48  
     extends AbstractNameCheck {
 49  
     /** If true, applies the check be public members. */
 50  213
     private boolean applyToPublic = true;
 51  
 
 52  
     /** If true, applies the check be protected members. */
 53  213
     private boolean applyToProtected = true;
 54  
 
 55  
     /** If true, applies the check be "package" members. */
 56  213
     private boolean applyToPackage = true;
 57  
 
 58  
     /** If true, applies the check be private members. */
 59  213
     private boolean applyToPrivate = true;
 60  
 
 61  
     /**
 62  
      * Creates a new {@code AbstractAccessControlNameCheck} instance.
 63  
      *
 64  
      * @param format
 65  
      *                format to check with
 66  
      */
 67  
     protected AbstractAccessControlNameCheck(String format) {
 68  213
         super(format);
 69  213
     }
 70  
 
 71  
     @Override
 72  
     protected boolean mustCheckName(DetailAST ast) {
 73  71
         return shouldCheckInScope(ast.findFirstToken(TokenTypes.MODIFIERS));
 74  
     }
 75  
 
 76  
     /**
 77  
      * Should we check member with given modifiers.
 78  
      *
 79  
      * @param modifiers
 80  
      *                modifiers of member to check.
 81  
      * @return true if we should check such member.
 82  
      */
 83  
     protected boolean shouldCheckInScope(DetailAST modifiers) {
 84  742
         final boolean isPublic = modifiers
 85  742
                 .findFirstToken(TokenTypes.LITERAL_PUBLIC) != null;
 86  742
         final boolean isProtected = modifiers
 87  742
                 .findFirstToken(TokenTypes.LITERAL_PROTECTED) != null;
 88  742
         final boolean isPrivate = modifiers
 89  742
                 .findFirstToken(TokenTypes.LITERAL_PRIVATE) != null;
 90  742
         final boolean isPackage = !(isPublic || isProtected || isPrivate);
 91  
 
 92  742
         return applyToPublic && isPublic
 93  
                 || applyToProtected && isProtected
 94  
                 || applyToPackage && isPackage
 95  
                 || applyToPrivate && isPrivate;
 96  
     }
 97  
 
 98  
     /**
 99  
      * Sets whether we should apply the check to public members.
 100  
      *
 101  
      * @param applyTo new value of the property.
 102  
      */
 103  
     public void setApplyToPublic(boolean applyTo) {
 104  4
         applyToPublic = applyTo;
 105  4
     }
 106  
 
 107  
     /**
 108  
      * Sets whether we should apply the check to protected members.
 109  
      *
 110  
      * @param applyTo new value of the property.
 111  
      */
 112  
     public void setApplyToProtected(boolean applyTo) {
 113  4
         applyToProtected = applyTo;
 114  4
     }
 115  
 
 116  
     /**
 117  
      * Sets whether we should apply the check to package-private members.
 118  
      *
 119  
      * @param applyTo new value of the property.
 120  
      */
 121  
     public void setApplyToPackage(boolean applyTo) {
 122  4
         applyToPackage = applyTo;
 123  4
     }
 124  
 
 125  
     /**
 126  
      * Sets whether we should apply the check to private members.
 127  
      *
 128  
      * @param applyTo new value of the property.
 129  
      */
 130  
     public void setApplyToPrivate(boolean applyTo) {
 131  6
         applyToPrivate = applyTo;
 132  6
     }
 133  
 }