From 1d6bf23ccda5197dfdd11d9dc2f653128e6b4d82 Mon Sep 17 00:00:00 2001 From: alexkravin Date: Sun, 11 Jan 2015 14:11:18 +0400 Subject: [PATCH] Prefixes, metrics, #512 --- .../metrics/AbstractClassCouplingCheck.java | 158 +++++++++--------- .../metrics/AbstractComplexityCheck.java | 82 ++++----- .../BooleanExpressionComplexityCheck.java | 78 ++++----- .../metrics/CyclomaticComplexityCheck.java | 2 +- .../checks/metrics/JavaNCSSCheck.java | 112 +++++++------ .../checks/metrics/NPathComplexityCheck.java | 12 +- 6 files changed, 224 insertions(+), 220 deletions(-) diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractClassCouplingCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractClassCouplingCheck.java index c22e9e583..96f6cf136 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractClassCouplingCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractClassCouplingCheck.java @@ -61,24 +61,24 @@ public abstract class AbstractClassCouplingCheck extends Check .add("Map", "HashMap", "SortedMap", "TreeMap") .build(); /** User-configured class names to ignore. */ - private Set mExcludedClasses = DEFAULT_EXCLUDED_CLASSES; + private Set excludedClasses = DEFAULT_EXCLUDED_CLASSES; /** Allowed complexity. */ - private int mMax; + private int max; /** package of the file we check. */ - private String mPackageName; + private String packageName; /** Stack of contexts. */ - private final FastStack mContextStack = FastStack.newInstance(); + private final FastStack contextStack = FastStack.newInstance(); /** Current context. */ - private Context mContext; + private Context context; /** * Creates new instance of the check. - * @param aDefaultMax default value for allowed complexity. + * @param defaultMax default value for allowed complexity. */ - protected AbstractClassCouplingCheck(int aDefaultMax) + protected AbstractClassCouplingCheck(int defaultMax) { - setMax(aDefaultMax); + setMax(defaultMax); } @Override @@ -90,67 +90,67 @@ public abstract class AbstractClassCouplingCheck extends Check /** @return allowed complexity. */ public final int getMax() { - return mMax; + return max; } /** * Sets maximum allowed complexity. - * @param aMax allowed complexity. + * @param max allowed complexity. */ - public final void setMax(int aMax) + public final void setMax(int max) { - mMax = aMax; + this.max = max; } /** * Sets user-excluded classes to ignore. - * @param aExcludedClasses the list of classes to ignore. + * @param excludedClasses the list of classes to ignore. */ - public final void setExcludedClasses(String[] aExcludedClasses) + public final void setExcludedClasses(String[] excludedClasses) { - mExcludedClasses = ImmutableSet.copyOf(aExcludedClasses); + this.excludedClasses = ImmutableSet.copyOf(excludedClasses); } @Override - public final void beginTree(DetailAST aAST) + public final void beginTree(DetailAST ast) { - mPackageName = ""; + packageName = ""; } /** @return message key we use for log violations. */ protected abstract String getLogMessageId(); @Override - public void visitToken(DetailAST aAST) + public void visitToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.PACKAGE_DEF: - visitPackageDef(aAST); + visitPackageDef(ast); break; case TokenTypes.CLASS_DEF: case TokenTypes.INTERFACE_DEF: case TokenTypes.ANNOTATION_DEF: case TokenTypes.ENUM_DEF: - visitClassDef(aAST); + visitClassDef(ast); break; case TokenTypes.TYPE: - mContext.visitType(aAST); + context.visitType(ast); break; case TokenTypes.LITERAL_NEW: - mContext.visitLiteralNew(aAST); + context.visitLiteralNew(ast); break; case TokenTypes.LITERAL_THROWS: - mContext.visitLiteralThrows(aAST); + context.visitLiteralThrows(ast); break; default: - throw new IllegalStateException(aAST.toString()); + throw new IllegalStateException(ast.toString()); } } @Override - public void leaveToken(DetailAST aAST) + public void leaveToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.CLASS_DEF: case TokenTypes.INTERFACE_DEF: case TokenTypes.ANNOTATION_DEF: @@ -164,34 +164,34 @@ public abstract class AbstractClassCouplingCheck extends Check /** * Stores package of current class we check. - * @param aPkg package definition. + * @param pkg package definition. */ - private void visitPackageDef(DetailAST aPkg) + private void visitPackageDef(DetailAST pkg) { - final FullIdent ident = FullIdent.createFullIdent(aPkg.getLastChild() + final FullIdent ident = FullIdent.createFullIdent(pkg.getLastChild() .getPreviousSibling()); - mPackageName = ident.getText(); + packageName = ident.getText(); } /** * Creates new context for a given class. - * @param aClassDef class definition node. + * @param classDef class definition node. */ - private void visitClassDef(DetailAST aClassDef) + private void visitClassDef(DetailAST classDef) { - mContextStack.push(mContext); + contextStack.push(context); final String className = - aClassDef.findFirstToken(TokenTypes.IDENT).getText(); - mContext = new Context(className, - aClassDef.getLineNo(), - aClassDef.getColumnNo()); + classDef.findFirstToken(TokenTypes.IDENT).getText(); + context = new Context(className, + classDef.getLineNo(), + classDef.getColumnNo()); } /** Restores previous context. */ private void leaveClassDef() { - mContext.checkCoupling(); - mContext = mContextStack.pop(); + context.checkCoupling(); + context = contextStack.pop(); } /** @@ -206,35 +206,35 @@ public abstract class AbstractClassCouplingCheck extends Check * Set of referenced classes. * Sorted by name for predictable error messages in unit tests. */ - private final Set mReferencedClassNames = Sets.newTreeSet(); + private final Set referencedClassNames = Sets.newTreeSet(); /** Own class name. */ - private final String mClassName; + private final String className; /* Location of own class. (Used to log violations) */ /** Line number of class definition. */ - private final int mLineNo; + private final int lineNo; /** Column number of class definition. */ - private final int mColumnNo; + private final int columnNo; /** * Create new context associated with given class. - * @param aClassName name of the given class. - * @param aLineNo line of class definition. - * @param aColumnNo column of class definition. + * @param className name of the given class. + * @param lineNo line of class definition. + * @param columnNo column of class definition. */ - public Context(String aClassName, int aLineNo, int aColumnNo) + public Context(String className, int lineNo, int columnNo) { - mClassName = aClassName; - mLineNo = aLineNo; - mColumnNo = aColumnNo; + this.className = className; + this.lineNo = lineNo; + this.columnNo = columnNo; } /** * Visits throws clause and collects all exceptions we throw. - * @param aThrows throws to process. + * @param throws throws to process. */ - public void visitLiteralThrows(DetailAST aThrows) + public void visitLiteralThrows(DetailAST literalThrows) { - for (DetailAST childAST = aThrows.getFirstChild(); + for (DetailAST childAST = literalThrows.getFirstChild(); childAST != null; childAST = childAST.getNextSibling()) { @@ -246,67 +246,67 @@ public abstract class AbstractClassCouplingCheck extends Check /** * Visits type. - * @param aAST type to process. + * @param ast type to process. */ - public void visitType(DetailAST aAST) + public void visitType(DetailAST ast) { - final String className = CheckUtils.createFullType(aAST).getText(); - mContext.addReferencedClassName(className); + final String className = CheckUtils.createFullType(ast).getText(); + context.addReferencedClassName(className); } /** * Visits NEW. - * @param aAST NEW to process. + * @param ast NEW to process. */ - public void visitLiteralNew(DetailAST aAST) + public void visitLiteralNew(DetailAST ast) { - mContext.addReferencedClassName(aAST.getFirstChild()); + context.addReferencedClassName(ast.getFirstChild()); } /** * Adds new referenced class. - * @param aAST a node which represents referenced class. + * @param ast a node which represents referenced class. */ - private void addReferencedClassName(DetailAST aAST) + private void addReferencedClassName(DetailAST ast) { - final String className = FullIdent.createFullIdent(aAST).getText(); + final String className = FullIdent.createFullIdent(ast).getText(); addReferencedClassName(className); } /** * Adds new referenced class. - * @param aClassName class name of the referenced class. + * @param className class name of the referenced class. */ - private void addReferencedClassName(String aClassName) + private void addReferencedClassName(String className) { - if (isSignificant(aClassName)) { - mReferencedClassNames.add(aClassName); + if (isSignificant(className)) { + referencedClassNames.add(className); } } /** Checks if coupling less than allowed or not. */ public void checkCoupling() { - mReferencedClassNames.remove(mClassName); - mReferencedClassNames.remove(mPackageName + "." + mClassName); + referencedClassNames.remove(className); + referencedClassNames.remove(packageName + "." + className); - if (mReferencedClassNames.size() > mMax) { - log(mLineNo, mColumnNo, getLogMessageId(), - mReferencedClassNames.size(), getMax(), - mReferencedClassNames.toString()); + if (referencedClassNames.size() > max) { + log(lineNo, columnNo, getLogMessageId(), + referencedClassNames.size(), getMax(), + referencedClassNames.toString()); } } /** * Checks if given class shouldn't be ignored and not from java.lang. - * @param aClassName class to check. + * @param className class to check. * @return true if we should count this class. */ - private boolean isSignificant(String aClassName) + private boolean isSignificant(String className) { - return (aClassName.length() > 0) - && !mExcludedClasses.contains(aClassName) - && !aClassName.startsWith("java.lang."); + return (className.length() > 0) + && !excludedClasses.contains(className) + && !className.startsWith("java.lang."); } } } diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractComplexityCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractComplexityCheck.java index 4dc646f53..69a100aed 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractComplexityCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/AbstractComplexityCheck.java @@ -2,18 +2,18 @@ // checkstyle: Checks Java source code for adherence to a set of rules. // Copyright (C) 2001-2014 Oliver Burn // -// This library is free software; you can redistribute it and/or +// This librby is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License, or (at your option) any later version. +// version 2.1 of the License, or (at your option) by later version. // -// This library is distributed in the hope that it will be useful, +// This librby is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software +// License along with this librby; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA //////////////////////////////////////////////////////////////////////////////// package com.puppycrawl.tools.checkstyle.checks.metrics; @@ -37,21 +37,21 @@ public abstract class AbstractComplexityCheck private static final BigInteger INITIAL_VALUE = BigInteger.ONE; /** stack of values - all but the current value */ - private final FastStack mValueStack = FastStack.newInstance(); + private final FastStack valueStack = FastStack.newInstance(); /** the current value */ - private BigInteger mCurrentValue = BigInteger.ZERO; + private BigInteger currentValue = BigInteger.ZERO; /** threshold to report error for */ - private int mMax; + private int max; /** * Creates an instance. - * @param aMax the threshold of when to report an error + * @param max the threshold of when to report an error */ - public AbstractComplexityCheck(int aMax) + public AbstractComplexityCheck(int max) { - mMax = aMax; + this.max = max; } /** @@ -63,9 +63,9 @@ public abstract class AbstractComplexityCheck * Hook called when visiting a token. Will not be called the method * definition tokens. * - * @param aAST the token being visited + * @param ast the token being visited */ - protected void visitTokenHook(DetailAST aAST) + protected void visitTokenHook(DetailAST ast) { } @@ -73,9 +73,9 @@ public abstract class AbstractComplexityCheck * Hook called when leaving a token. Will not be called the method * definition tokens. * - * @param aAST the token being left + * @param ast the token being left */ - protected void leaveTokenHook(DetailAST aAST) + protected void leaveTokenHook(DetailAST ast) { } @@ -93,23 +93,23 @@ public abstract class AbstractComplexityCheck /** @return the maximum threshold allowed */ public final int getMax() { - return mMax; + return max; } /** * Set the maximum threshold allowed. * - * @param aMax the maximum threshold + * @param max the maximum threshold */ - public final void setMax(int aMax) + public final void setMax(int max) { - mMax = aMax; + this.max = max; } @Override - public void visitToken(DetailAST aAST) + public void visitToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.CTOR_DEF: case TokenTypes.METHOD_DEF: case TokenTypes.INSTANCE_INIT: @@ -117,22 +117,22 @@ public abstract class AbstractComplexityCheck visitMethodDef(); break; default: - visitTokenHook(aAST); + visitTokenHook(ast); } } @Override - public void leaveToken(DetailAST aAST) + public void leaveToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.CTOR_DEF: case TokenTypes.METHOD_DEF: case TokenTypes.INSTANCE_INIT: case TokenTypes.STATIC_INIT: - leaveMethodDef(aAST); + leaveMethodDef(ast); break; default: - leaveTokenHook(aAST); + leaveTokenHook(ast); } } @@ -141,33 +141,33 @@ public abstract class AbstractComplexityCheck */ protected final BigInteger getCurrentValue() { - return mCurrentValue; + return currentValue; } /** * Set the current value - * @param aValue the new value + * @param value the new value */ - protected final void setCurrentValue(BigInteger aValue) + protected final void setCurrentValue(BigInteger value) { - mCurrentValue = aValue; + currentValue = value; } /** * Increments the current value by a specified amount. * - * @param aBy the amount to increment by + * @param by the amount to increment by */ - protected final void incrementCurrentValue(BigInteger aBy) + protected final void incrementCurrentValue(BigInteger by) { - setCurrentValue(getCurrentValue().add(aBy)); + setCurrentValue(getCurrentValue().add(by)); } /** Push the current value on the stack */ protected final void pushValue() { - mValueStack.push(mCurrentValue); - mCurrentValue = INITIAL_VALUE; + valueStack.push(currentValue); + currentValue = INITIAL_VALUE; } /** @@ -175,8 +175,8 @@ public abstract class AbstractComplexityCheck */ protected final BigInteger popValue() { - mCurrentValue = mValueStack.pop(); - return mCurrentValue; + currentValue = valueStack.pop(); + return currentValue; } /** Process the start of the method definition */ @@ -188,13 +188,13 @@ public abstract class AbstractComplexityCheck /** * Process the end of a method definition. * - * @param aAST the token representing the method definition + * @param ast the token representing the method definition */ - private void leaveMethodDef(DetailAST aAST) + private void leaveMethodDef(DetailAST ast) { - final BigInteger max = BigInteger.valueOf(mMax); - if (mCurrentValue.compareTo(max) > 0) { - log(aAST, getMessageID(), mCurrentValue, max); + final BigInteger bigIntegerMax = BigInteger.valueOf(max); + if (currentValue.compareTo(bigIntegerMax) > 0) { + log(ast, getMessageID(), currentValue, bigIntegerMax); } popValue(); } diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheck.java index 0a26f9a8e..54e1e183e 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheck.java @@ -37,11 +37,11 @@ public final class BooleanExpressionComplexityCheck extends Check private static final int DEFAULT_MAX = 3; /** Stack of contexts. */ - private final FastStack mContextStack = FastStack.newInstance(); + private final FastStack contextStack = FastStack.newInstance(); /** Maximum allowed complexity. */ - private int mMax; + private int max; /** Current context. */ - private Context mContext; + private Context context; /** Creates new instance of the check. */ public BooleanExpressionComplexityCheck() @@ -80,25 +80,25 @@ public final class BooleanExpressionComplexityCheck extends Check */ public int getMax() { - return mMax; + return max; } /** * Setter for maximum allowed complexity. - * @param aMax new maximum allowed complexity. + * @param max new maximum allowed complexity. */ - public void setMax(int aMax) + public void setMax(int max) { - mMax = aMax; + this.max = max; } @Override - public void visitToken(DetailAST aAST) + public void visitToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.CTOR_DEF: case TokenTypes.METHOD_DEF: - visitMethodDef(aAST); + visitMethodDef(ast); break; case TokenTypes.EXPR: visitExpr(); @@ -108,23 +108,23 @@ public final class BooleanExpressionComplexityCheck extends Check case TokenTypes.LOR: case TokenTypes.BOR: case TokenTypes.BXOR: - mContext.visitBooleanOperator(); + context.visitBooleanOperator(); break; default: - throw new IllegalStateException(aAST.toString()); + throw new IllegalStateException(ast.toString()); } } @Override - public void leaveToken(DetailAST aAST) + public void leaveToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.CTOR_DEF: case TokenTypes.METHOD_DEF: leaveMethodDef(); break; case TokenTypes.EXPR: - leaveExpr(aAST); + leaveExpr(ast); break; default: // Do nothing @@ -133,35 +133,35 @@ public final class BooleanExpressionComplexityCheck extends Check /** * Creates new context for a given method. - * @param aAST a method we start to check. + * @param ast a method we start to check. */ - private void visitMethodDef(DetailAST aAST) + private void visitMethodDef(DetailAST ast) { - mContextStack.push(mContext); - mContext = new Context(!CheckUtils.isEqualsMethod(aAST)); + contextStack.push(context); + context = new Context(!CheckUtils.isEqualsMethod(ast)); } /** Removes old context. */ private void leaveMethodDef() { - mContext = mContextStack.pop(); + context = contextStack.pop(); } /** Creates and pushes new context. */ private void visitExpr() { - mContextStack.push(mContext); - mContext = new Context((mContext == null) || mContext.isChecking()); + contextStack.push(context); + context = new Context((context == null) || context.isChecking()); } /** * Restores previous context. - * @param aAST expression we leave. + * @param ast expression we leave. */ - private void leaveExpr(DetailAST aAST) + private void leaveExpr(DetailAST ast) { - mContext.checkCount(aAST); - mContext = mContextStack.pop(); + context.checkCount(ast); + context = contextStack.pop(); } /** @@ -176,18 +176,18 @@ public final class BooleanExpressionComplexityCheck extends Check * Should we perform check in current context or not. * Usually false if we are inside equals() method. */ - private final boolean mChecking; + private final boolean checking; /** Count of boolean operators. */ - private int mCount; + private int count; /** * Creates new instance. - * @param aChecking should we check in current context or not. + * @param checking should we check in current context or not. */ - public Context(boolean aChecking) + public Context(boolean checking) { - mChecking = aChecking; - mCount = 0; + this.checking = checking; + count = 0; } /** @@ -196,26 +196,26 @@ public final class BooleanExpressionComplexityCheck extends Check */ public boolean isChecking() { - return mChecking; + return checking; } /** Increases operator counter. */ public void visitBooleanOperator() { - ++mCount; + ++count; } /** * Checks if we violates maximum allowed complexity. - * @param aAST a node we check now. + * @param ast a node we check now. */ - public void checkCount(DetailAST aAST) + public void checkCount(DetailAST ast) { - if (mChecking && (mCount > getMax())) { - final DetailAST parentAST = aAST.getParent(); + if (checking && (count > getMax())) { + final DetailAST parentAST = ast.getParent(); log(parentAST.getLineNo(), parentAST.getColumnNo(), - "booleanExpressionComplexity", mCount, getMax()); + "booleanExpressionComplexity", count, getMax()); } } } diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/CyclomaticComplexityCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/CyclomaticComplexityCheck.java index cc6af9bb9..0e83db080 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/CyclomaticComplexityCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/CyclomaticComplexityCheck.java @@ -67,7 +67,7 @@ public class CyclomaticComplexityCheck } @Override - protected final void visitTokenHook(DetailAST aAST) + protected final void visitTokenHook(DetailAST ast) { incrementCurrentValue(BigInteger.ONE); } diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/JavaNCSSCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/JavaNCSSCheck.java index cbda7645f..ef80cb924 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/JavaNCSSCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/JavaNCSSCheck.java @@ -26,8 +26,8 @@ import com.puppycrawl.tools.checkstyle.api.TokenTypes; /** * This check calculates the Non Commenting Source Statements (NCSS) metric for * java source files and methods. The check adheres to the JavaNCSS specification - * and gives the same results as the JavaNCSS tool. + * href="http://www.kclee.com/clemens/java/javancss/">JavnCSS specification + * and gives the same results as the JavnCSS tool. * * The NCSS-metric tries to determine complexity of methods, classes and files * by counting the non commenting lines. Roughly said this is (nearly) @@ -47,16 +47,16 @@ public class JavaNCSSCheck extends Check private static final int METHOD_MAX_NCSS = 50; /** maximum ncss for a complete source file */ - private int mFileMax = FILE_MAX_NCSS; + private int fileMax = FILE_MAX_NCSS; /** maximum ncss for a class */ - private int mClassMax = CLASS_MAX_NCSS; + private int classMax = CLASS_MAX_NCSS; /** maximum ncss for a method */ - private int mMethodMax = METHOD_MAX_NCSS; + private int methodMax = METHOD_MAX_NCSS; /** list containing the stacked counters */ - private FastStack mCounters; + private FastStack counters; @Override public int[] getDefaultTokens() @@ -129,18 +129,18 @@ public class JavaNCSSCheck extends Check } @Override - public void beginTree(DetailAST aRootAST) + public void beginTree(DetailAST rootAST) { - mCounters = new FastStack(); + counters = new FastStack(); //add a counter for the file - mCounters.push(new Counter()); + counters.push(new Counter()); } @Override - public void visitToken(DetailAST aAST) + public void visitToken(DetailAST ast) { - final int tokenType = aAST.getType(); + final int tokenType = ast.getType(); if ((TokenTypes.CLASS_DEF == tokenType) || (TokenTypes.METHOD_DEF == tokenType) @@ -149,114 +149,114 @@ public class JavaNCSSCheck extends Check || (TokenTypes.INSTANCE_INIT == tokenType)) { //add a counter for this class/method - mCounters.push(new Counter()); + counters.push(new Counter()); } //check if token is countable - if (isCountable(aAST)) { + if (isCountable(ast)) { //increment the stacked counters - for (final Counter c : mCounters) { + for (final Counter c : counters) { c.increment(); } } } @Override - public void leaveToken(DetailAST aAST) + public void leaveToken(DetailAST ast) { - final int tokenType = aAST.getType(); + final int tokenType = ast.getType(); if ((TokenTypes.METHOD_DEF == tokenType) || (TokenTypes.CTOR_DEF == tokenType) || (TokenTypes.STATIC_INIT == tokenType) || (TokenTypes.INSTANCE_INIT == tokenType)) { //pop counter from the stack - final Counter counter = mCounters.pop(); + final Counter counter = counters.pop(); final int count = counter.getCount(); - if (count > mMethodMax) { - log(aAST.getLineNo(), aAST.getColumnNo(), "ncss.method", - count, mMethodMax); + if (count > methodMax) { + log(ast.getLineNo(), ast.getColumnNo(), "ncss.method", + count, methodMax); } } else if (TokenTypes.CLASS_DEF == tokenType) { //pop counter from the stack - final Counter counter = mCounters.pop(); + final Counter counter = counters.pop(); final int count = counter.getCount(); - if (count > mClassMax) { - log(aAST.getLineNo(), aAST.getColumnNo(), "ncss.class", - count, mClassMax); + if (count > classMax) { + log(ast.getLineNo(), ast.getColumnNo(), "ncss.class", + count, classMax); } } } @Override - public void finishTree(DetailAST aRootAST) + public void finishTree(DetailAST rootAST) { //pop counter from the stack - final Counter counter = mCounters.pop(); + final Counter counter = counters.pop(); final int count = counter.getCount(); - if (count > mFileMax) { - log(aRootAST.getLineNo(), aRootAST.getColumnNo(), "ncss.file", - count, mFileMax); + if (count > fileMax) { + log(rootAST.getLineNo(), rootAST.getColumnNo(), "ncss.file", + count, fileMax); } } /** * Sets the maximum ncss for a file. * - * @param aFileMax + * @param fileMax * the maximum ncss */ - public void setFileMaximum(int aFileMax) + public void setFileMaximum(int fileMax) { - mFileMax = aFileMax; + this.fileMax = fileMax; } /** * Sets the maximum ncss for a class. * - * @param aClassMax + * @param classMax * the maximum ncss */ - public void setClassMaximum(int aClassMax) + public void setClassMaximum(int classMax) { - mClassMax = aClassMax; + this.classMax = classMax; } /** * Sets the maximum ncss for a method. * - * @param aMethodMax + * @param methodMax * the maximum ncss */ - public void setMethodMaximum(int aMethodMax) + public void setMethodMaximum(int methodMax) { - mMethodMax = aMethodMax; + this.methodMax = methodMax; } /** * Checks if a token is countable for the ncss metric * - * @param aAST + * @param ast * the AST * @return true if the token is countable */ - private boolean isCountable(DetailAST aAST) + private boolean isCountable(DetailAST ast) { boolean countable = true; - final int tokenType = aAST.getType(); + final int tokenType = ast.getType(); //check if an expression is countable if (TokenTypes.EXPR == tokenType) { - countable = isExpressionCountable(aAST); + countable = isExpressionCountable(ast); } //check if an variable definition is countable else if (TokenTypes.VARIABLE_DEF == tokenType) { - countable = isVariableDefCountable(aAST); + countable = isVariableDefCountable(ast); } return countable; } @@ -264,21 +264,21 @@ public class JavaNCSSCheck extends Check /** * Checks if a variable definition is countable. * - * @param aAST the AST + * @param ast the AST * @return true if the variable definition is countable, false otherwise */ - private boolean isVariableDefCountable(DetailAST aAST) + private boolean isVariableDefCountable(DetailAST ast) { boolean countable = false; //count variable defs only if they are direct child to a slist or // object block - final int parentType = aAST.getParent().getType(); + final int parentType = ast.getParent().getType(); if ((TokenTypes.SLIST == parentType) || (TokenTypes.OBJBLOCK == parentType)) { - final DetailAST prevSibling = aAST.getPreviousSibling(); + final DetailAST prevSibling = ast.getPreviousSibling(); //is countable if no previous sibling is found or //the sibling is no COMMA. @@ -294,17 +294,17 @@ public class JavaNCSSCheck extends Check /** * Checks if an expression is countable for the ncss metric. * - * @param aAST the AST + * @param ast the AST * @return true if the expression is countable, false otherwise */ - private boolean isExpressionCountable(DetailAST aAST) + private boolean isExpressionCountable(DetailAST ast) { boolean countable = true; //count expressions only if they are direct child to a slist (method // body, for loop...) //or direct child of label,if,else,do,while,for - final int parentType = aAST.getParent().getType(); + final int parentType = ast.getParent().getType(); switch (parentType) { case TokenTypes.SLIST : case TokenTypes.LABELED_STAT : @@ -314,7 +314,7 @@ public class JavaNCSSCheck extends Check case TokenTypes.LITERAL_IF : case TokenTypes.LITERAL_ELSE : //don't count if or loop conditions - final DetailAST prevSibling = aAST.getPreviousSibling(); + final DetailAST prevSibling = ast.getPreviousSibling(); countable = (prevSibling == null) || (TokenTypes.LPAREN != prevSibling.getType()); break; @@ -326,21 +326,25 @@ public class JavaNCSSCheck extends Check } /** +<<<<<<< HEAD * @author Lars Ködderitzsch +======= + * @author Lars K�dderitzsch +>>>>>>> ca5a59d... Prefixes, Metrics, #512 * * Class representing a counter, */ private static class Counter { /** the counters internal integer */ - private int mIvCount; + private int ivCount; /** * Increments the counter. */ public void increment() { - mIvCount++; + ivCount++; } /** @@ -350,7 +354,7 @@ public class JavaNCSSCheck extends Check */ public int getCount() { - return mIvCount; + return ivCount; } } } diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheck.java index 567e8fdaa..a333908ec 100644 --- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheck.java +++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheck.java @@ -68,9 +68,9 @@ public final class NPathComplexityCheck extends AbstractComplexityCheck } @Override - public void visitToken(DetailAST aAST) + public void visitToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.LITERAL_WHILE: case TokenTypes.LITERAL_DO: case TokenTypes.LITERAL_FOR: @@ -86,14 +86,14 @@ public final class NPathComplexityCheck extends AbstractComplexityCheck visitAddingConditional(); break; default: - super.visitToken(aAST); + super.visitToken(ast); } } @Override - public void leaveToken(DetailAST aAST) + public void leaveToken(DetailAST ast) { - switch (aAST.getType()) { + switch (ast.getType()) { case TokenTypes.LITERAL_WHILE: case TokenTypes.LITERAL_DO: case TokenTypes.LITERAL_FOR: @@ -109,7 +109,7 @@ public final class NPathComplexityCheck extends AbstractComplexityCheck leaveAddingConditional(); break; default: - super.leaveToken(aAST); + super.leaveToken(ast); } }