Coverage Report - com.puppycrawl.tools.checkstyle.checks.whitespace.AbstractParenPadCheck
 
Classes in this File Line Coverage Branch Coverage Complexity
AbstractParenPadCheck
100%
31/31
100%
26/26
6
 
 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.whitespace;
 21  
 
 22  
 import java.util.Locale;
 23  
 
 24  
 import com.puppycrawl.tools.checkstyle.StatelessCheck;
 25  
 import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
 26  
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 27  
 import com.puppycrawl.tools.checkstyle.utils.CommonUtils;
 28  
 
 29  
 /**
 30  
  * <p>Abstract class for checking the padding of parentheses. That is whether a
 31  
  * space is required after a left parenthesis and before a right parenthesis,
 32  
  * or such spaces are forbidden.
 33  
  * </p>
 34  
  * @author Oliver Burn
 35  
  */
 36  
 @StatelessCheck
 37  39
 public abstract class AbstractParenPadCheck
 38  
     extends AbstractCheck {
 39  
 
 40  
     /**
 41  
      * A key is pointing to the warning message text in "messages.properties"
 42  
      * file.
 43  
      */
 44  
     public static final String MSG_WS_FOLLOWED = "ws.followed";
 45  
 
 46  
     /**
 47  
      * A key is pointing to the warning message text in "messages.properties"
 48  
      * file.
 49  
      */
 50  
     public static final String MSG_WS_NOT_FOLLOWED = "ws.notFollowed";
 51  
 
 52  
     /**
 53  
      * A key is pointing to the warning message text in "messages.properties"
 54  
      * file.
 55  
      */
 56  
     public static final String MSG_WS_PRECEDED = "ws.preceded";
 57  
 
 58  
     /**
 59  
      * A key is pointing to the warning message text in "messages.properties"
 60  
      * file.
 61  
      */
 62  
     public static final String MSG_WS_NOT_PRECEDED = "ws.notPreceded";
 63  
 
 64  
     /** Open parenthesis literal. */
 65  
     private static final char OPEN_PARENTHESIS = '(';
 66  
 
 67  
     /** Close parenthesis literal. */
 68  
     private static final char CLOSE_PARENTHESIS = ')';
 69  
 
 70  
     /** The policy to enforce. */
 71  39
     private PadOption option = PadOption.NOSPACE;
 72  
 
 73  
     /**
 74  
      * Set the option to enforce.
 75  
      * @param optionStr string to decode option from
 76  
      * @throws IllegalArgumentException if unable to decode
 77  
      */
 78  
     public void setOption(String optionStr) {
 79  
         try {
 80  13
             option = PadOption.valueOf(optionStr.trim().toUpperCase(Locale.ENGLISH));
 81  
         }
 82  1
         catch (IllegalArgumentException iae) {
 83  1
             throw new IllegalArgumentException("unable to parse " + optionStr, iae);
 84  12
         }
 85  12
     }
 86  
 
 87  
     /**
 88  
      * Process a token representing a left parentheses.
 89  
      * @param ast the token representing a left parentheses
 90  
      */
 91  
     protected void processLeft(DetailAST ast) {
 92  416
         final String line = getLines()[ast.getLineNo() - 1];
 93  416
         final int after = ast.getColumnNo() + 1;
 94  416
         if (after < line.length()) {
 95  414
             if (option == PadOption.NOSPACE
 96  283
                 && Character.isWhitespace(line.charAt(after))) {
 97  91
                 log(ast.getLineNo(), after, MSG_WS_FOLLOWED, OPEN_PARENTHESIS);
 98  
             }
 99  323
             else if (option == PadOption.SPACE
 100  131
                      && !Character.isWhitespace(line.charAt(after))
 101  108
                      && line.charAt(after) != CLOSE_PARENTHESIS) {
 102  39
                 log(ast.getLineNo(), after, MSG_WS_NOT_FOLLOWED, OPEN_PARENTHESIS);
 103  
             }
 104  
         }
 105  416
     }
 106  
 
 107  
     /**
 108  
      * Process a token representing a right parentheses.
 109  
      * @param ast the token representing a right parentheses
 110  
      */
 111  
     protected void processRight(DetailAST ast) {
 112  410
         final int before = ast.getColumnNo() - 1;
 113  410
         if (before >= 0) {
 114  408
             final String line = getLines()[ast.getLineNo() - 1];
 115  408
             if (option == PadOption.NOSPACE
 116  279
                 && Character.isWhitespace(line.charAt(before))
 117  98
                 && !CommonUtils.hasWhitespaceBefore(before, line)) {
 118  97
                 log(ast.getLineNo(), before, MSG_WS_PRECEDED, CLOSE_PARENTHESIS);
 119  
             }
 120  311
             else if (option == PadOption.SPACE
 121  129
                 && !Character.isWhitespace(line.charAt(before))
 122  103
                 && line.charAt(before) != OPEN_PARENTHESIS) {
 123  68
                 log(ast.getLineNo(), ast.getColumnNo(),
 124  34
                     MSG_WS_NOT_PRECEDED, CLOSE_PARENTHESIS);
 125  
             }
 126  
         }
 127  410
     }
 128  
 }