Coverage Report - com.puppycrawl.tools.checkstyle.checks.whitespace.OperatorWrapCheck
 
Classes in this File Line Coverage Branch Coverage Complexity
OperatorWrapCheck
83%
15/18
68%
11/16
3.25
 
 1  
 ////////////////////////////////////////////////////////////////////////////////
 2  
 // checkstyle: Checks Java source code for adherence to a set of rules.
 3  
 // Copyright (C) 2001-2014  Oliver Burn
 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 com.puppycrawl.tools.checkstyle.api.DetailAST;
 23  
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
 24  
 import com.puppycrawl.tools.checkstyle.api.Utils;
 25  
 import com.puppycrawl.tools.checkstyle.checks.AbstractOptionCheck;
 26  
 
 27  
 /**
 28  
  * <p>
 29  
  * Checks line wrapping for operators.
 30  
  * The policy to verify is specified using the {@link OperatorWrapOption} class
 31  
  * and defaults to {@link OperatorWrapOption#NL}.
 32  
  * </p>
 33  
  * <p> By default the check will check the following operators:
 34  
  *  {@link TokenTypes#BAND BAND},
 35  
  *  {@link TokenTypes#BOR BOR},
 36  
  *  {@link TokenTypes#BSR BSR},
 37  
  *  {@link TokenTypes#BXOR BXOR},
 38  
  *  {@link TokenTypes#COLON COLON},
 39  
  *  {@link TokenTypes#DIV DIV},
 40  
  *  {@link TokenTypes#EQUAL EQUAL},
 41  
  *  {@link TokenTypes#GE GE},
 42  
  *  {@link TokenTypes#GT GT},
 43  
  *  {@link TokenTypes#LAND LAND},
 44  
  *  {@link TokenTypes#LE LE},
 45  
  *  {@link TokenTypes#LITERAL_INSTANCEOF LITERAL_INSTANCEOF},
 46  
  *  {@link TokenTypes#LOR LOR},
 47  
  *  {@link TokenTypes#LT LT},
 48  
  *  {@link TokenTypes#MINUS MINUS},
 49  
  *  {@link TokenTypes#MOD MOD},
 50  
  *  {@link TokenTypes#NOT_EQUAL NOT_EQUAL},
 51  
  *  {@link TokenTypes#PLUS PLUS},
 52  
  *  {@link TokenTypes#QUESTION QUESTION},
 53  
  *  {@link TokenTypes#SL SL},
 54  
  *  {@link TokenTypes#SR SR},
 55  
  *  {@link TokenTypes#STAR STAR}.
 56  
  * Other acceptable tokens are
 57  
  *  {@link TokenTypes#ASSIGN ASSIGN},
 58  
  *  {@link TokenTypes#BAND_ASSIGN BAND_ASSIGN},
 59  
  *  {@link TokenTypes#BOR_ASSIGN BOR_ASSIGN},
 60  
  *  {@link TokenTypes#BSR_ASSIGN BSR_ASSIGN},
 61  
  *  {@link TokenTypes#BXOR_ASSIGN BXOR_ASSIGN},
 62  
  *  {@link TokenTypes#DIV_ASSIGN DIV_ASSIGN},
 63  
  *  {@link TokenTypes#MINUS_ASSIGN MINUS_ASSIGN},
 64  
  *  {@link TokenTypes#MOD_ASSIGN MOD_ASSIGN},
 65  
  *  {@link TokenTypes#PLUS_ASSIGN PLUS_ASSIGN},
 66  
  *  {@link TokenTypes#SL_ASSIGN SL_ASSIGN},
 67  
  *  {@link TokenTypes#SR_ASSIGN SR_ASSIGN},
 68  
  *  {@link TokenTypes#STAR_ASSIGN STAR_ASSIGN}.
 69  
  * </p>
 70  
  *  <p>
 71  
  * An example of how to configure the check is:
 72  
  * </p>
 73  
  * <pre>
 74  
  * &lt;module name="OperatorWrap"/&gt;
 75  
  * </pre>
 76  
  * <p> An example of how to configure the check for assignment operators at the
 77  
  * end of a line is:
 78  
  * </p>
 79  
  * <pre>
 80  
  * &lt;module name="OperatorWrap"&gt;
 81  
  *     &lt;property name="tokens"
 82  
  *               value="ASSIGN,DIV_ASSIGN,PLUS_ASSIGN,MINUS_ASSIGN,STAR_ASSIGN,MOD_ASSIGN,SR_ASSIGN,BSR_ASSIGN,SL_ASSIGN,BXOR_ASSIGN,BOR_ASSIGN,BAND_ASSIGN"/&gt;
 83  
  *     &lt;property name="option" value="eol"/&gt;
 84  
   * &lt;/module&gt;
 85  
  * </pre>
 86  
  *
 87  
  * @author Rick Giles
 88  
  * @version 1.0
 89  
  */
 90  
 public class OperatorWrapCheck
 91  
     extends AbstractOptionCheck<OperatorWrapOption>
 92  
 {
 93  
     /**
 94  
      * Sets the operator wrap option to new line.
 95  
      */
 96  
     public OperatorWrapCheck()
 97  
     {
 98  3
         super(OperatorWrapOption.NL, OperatorWrapOption.class);
 99  3
     }
 100  
 
 101  
     @Override
 102  
     public int[] getDefaultTokens()
 103  
     {
 104  2
         return new int[] {
 105  
             TokenTypes.QUESTION,          // '?'
 106  
             TokenTypes.COLON,             // ':' (not reported for a case)
 107  
             TokenTypes.EQUAL,             // "=="
 108  
             TokenTypes.NOT_EQUAL,         // "!="
 109  
             TokenTypes.DIV,               // '/'
 110  
             TokenTypes.PLUS,              //' +' (unary plus is UNARY_PLUS)
 111  
             TokenTypes.MINUS,             // '-' (unary minus is UNARY_MINUS)
 112  
             TokenTypes.STAR,              // '*'
 113  
             TokenTypes.MOD,               // '%'
 114  
             TokenTypes.SR,                // ">>"
 115  
             TokenTypes.BSR,               // ">>>"
 116  
             TokenTypes.GE,                // ">="
 117  
             TokenTypes.GT,                // ">"
 118  
             TokenTypes.SL,                // "<<"
 119  
             TokenTypes.LE,                // "<="
 120  
             TokenTypes.LT,                // '<'
 121  
             TokenTypes.BXOR,              // '^'
 122  
             TokenTypes.BOR,               // '|'
 123  
             TokenTypes.LOR,               // "||"
 124  
             TokenTypes.BAND,              // '&'
 125  
             TokenTypes.LAND,              // "&&"
 126  
             TokenTypes.LITERAL_INSTANCEOF,
 127  
         };
 128  
     }
 129  
 
 130  
     @Override
 131  
     public int[] getAcceptableTokens()
 132  
     {
 133  1
         return new int[] {
 134  
             TokenTypes.QUESTION,          // '?'
 135  
             TokenTypes.COLON,             // ':' (not reported for a case)
 136  
             TokenTypes.EQUAL,             // "=="
 137  
             TokenTypes.NOT_EQUAL,         // "!="
 138  
             TokenTypes.DIV,               // '/'
 139  
             TokenTypes.PLUS,              //' +' (unary plus is UNARY_PLUS)
 140  
             TokenTypes.MINUS,             // '-' (unary minus is UNARY_MINUS)
 141  
             TokenTypes.STAR,              // '*'
 142  
             TokenTypes.MOD,               // '%'
 143  
             TokenTypes.SR,                // ">>"
 144  
             TokenTypes.BSR,               // ">>>"
 145  
             TokenTypes.GE,                // ">="
 146  
             TokenTypes.GT,                // ">"
 147  
             TokenTypes.SL,                // "<<"
 148  
             TokenTypes.LE,                // "<="
 149  
             TokenTypes.LT,                // '<'
 150  
             TokenTypes.BXOR,              // '^'
 151  
             TokenTypes.BOR,               // '|'
 152  
             TokenTypes.LOR,               // "||"
 153  
             TokenTypes.BAND,              // '&'
 154  
             TokenTypes.LAND,              // "&&"
 155  
             TokenTypes.LITERAL_INSTANCEOF,
 156  
             TokenTypes.ASSIGN,            // '='
 157  
             TokenTypes.DIV_ASSIGN,        // "/="
 158  
             TokenTypes.PLUS_ASSIGN,       // "+="
 159  
             TokenTypes.MINUS_ASSIGN,      //"-="
 160  
             TokenTypes.STAR_ASSIGN,       // "*="
 161  
             TokenTypes.MOD_ASSIGN,        // "%="
 162  
             TokenTypes.SR_ASSIGN,         // ">>="
 163  
             TokenTypes.BSR_ASSIGN,        // ">>>="
 164  
             TokenTypes.SL_ASSIGN,         // "<<="
 165  
             TokenTypes.BXOR_ASSIGN,       // "^="
 166  
             TokenTypes.BOR_ASSIGN,        // "|="
 167  
             TokenTypes.BAND_ASSIGN,       // "&="
 168  
 
 169  
         };
 170  
     }
 171  
 
 172  
     @Override
 173  
     public void visitToken(DetailAST aAST)
 174  
     {
 175  22
         if (aAST.getType() == TokenTypes.COLON) {
 176  0
             final DetailAST parent = aAST.getParent();
 177  0
             if ((parent.getType() == TokenTypes.LITERAL_DEFAULT)
 178  
                 || (parent.getType() == TokenTypes.LITERAL_CASE))
 179  
             {
 180  
                 //we do not want to check colon for cases and defaults
 181  0
                 return;
 182  
             }
 183  
         }
 184  22
         final OperatorWrapOption wOp = getAbstractOption();
 185  
 
 186  22
         final String text = aAST.getText();
 187  22
         final int colNo = aAST.getColumnNo();
 188  22
         final int lineNo = aAST.getLineNo();
 189  22
         final String currentLine = getLines()[lineNo - 1];
 190  
 
 191  
         // TODO: Handle comments before and after operator
 192  
         // Check if rest of line is whitespace, and not just the operator
 193  
         // by itself. This last bit is to handle the operator on a line by
 194  
         // itself.
 195  22
         if ((wOp == OperatorWrapOption.NL)
 196  
             && !text.equals(currentLine.trim())
 197  
             && (currentLine.substring(colNo + text.length())
 198  
                 .trim().length() == 0))
 199  
         {
 200  3
             log(lineNo, colNo, "line.new", text);
 201  
         }
 202  19
         else if ((wOp == OperatorWrapOption.EOL)
 203  
                   && Utils.whitespaceBefore(colNo - 1, currentLine))
 204  
         {
 205  4
             log(lineNo, colNo, "line.previous", text);
 206  
         }
 207  22
     }
 208  
 }